diff --git "a/cpp_dataset/train/train.jsonl" "b/cpp_dataset/train/train.jsonl"
--- "a/cpp_dataset/train/train.jsonl"
+++ "b/cpp_dataset/train/train.jsonl"
@@ -98,3 +98,903 @@
 {"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int main() { n   long long a, b; n   cin >> a >> b; n   long long ans = 0; n   while (true) { n     long long x = max(a, b); n     long long y = min(a, b); n     if (x == 0 || y == 0) break; n     long long n = x / y; n     ans += n; n     x -= n * y; n     a = x; n     b = y; n   } n   cout << ans; n   return 0; n } n "}
 {"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int main() { n   ios_base::sync_with_stdio(0); n   cin.tie(0); n   cout.tie(0); n   int x, test; n   cin >> test; n   while (test--) { n     int n, c0, c1, h; n     string s; n     cin >> n >> c0 >> c1 >> h >> s; n     int cnt0 = 0, cnt1 = 0; n     for (auto &z : s) { n       cnt0 += z ==  0 ; n       cnt1 += z ==  1 ; n     } n     int cost = (cnt0 * c0) + (cnt1 * c1); n     int cost0 = (c0 * n) + (cnt1 * h); n     int cost1 = (c1 * n) + (cnt0 * h); n     cout << min({cost, cost0, cost1}) <<   n ; n   } n   return 0; n } n "}
 {"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int inf = int(1e9) + 123; n int main() { n   int n, v; n   cin >> n >> v; n   vector<int> a; n   for (int i = 1; i <= n; i++) { n     int x; n     cin >> x; n     a.push_back(x); n   } n   sort(a.begin(), a.end()); n   int sum = 0; n   for (int i = 0; i < a.size() - 1; i++) { n     sum += a[i]; n   } n   if (sum <= v) { n     cout <<  YES ; n   } else { n     cout <<  NO ; n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n string vow =  aeiou ; n long long month[] = {-1, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}; n const long long dxhorse[] = {-2, -2, -1, -1, 1, 1, 2, 2}; n const long long dyhorse[] = {1, -1, 2, -2, 2, -2, 1, -1}; n const long long dx4[] = {-1, 0, 1, 0}; n const long long dy4[] = {0, 1, 0, -1}; n const long long dx8[] = {-1, -1, -1, 0, 0, 1, 1, 1}; n const long long dy8[] = {-1, 0, 1, -1, 1, -1, 0, 1}; n const long double pie = 3.1415926535897932384626; n const long long special_prime = 982451653l; n const long long mod = 1e9 + 7; n const long long inf = 2e18; n template <class T> n istream &operator>>(istream &in, vector<T> &a) { n   for (auto &i : a) cin >> i; n   return in; n } n template <class T> n ostream &operator<<(ostream &out, const vector<T> &a) { n   for (auto &i : a) cout << i <<    ; n   return out; n } n template <class T, class U> n ostream &operator<<(ostream &out, const map<T, U> &a) { n   for (auto &i : a) cout <<  (  << i.first <<  ,   << i.second <<  ) n ; n   return out; n } n template <class T, class U> n ostream &operator<<(ostream &out, const unordered_map<T, U> &a) { n   for (auto &i : a) cout <<  (  << i.first <<  ,   << i.second <<  ) n ; n   return out; n } n long long GCD(long long a, long long b) { n   if (!b) return a; n   return GCD(b, a % b); n } n long long LCM(long long a, long long b) { return (a * b) / GCD(a, b); } n bool comp(long long a, long long b) { return a > b; } n void sieve(vector<long long> &prime) { n   prime[0] = false; n   prime[1] = false; n   for (long long p = 2; p * p <= 99999; p++) { n     if (prime[p] == true) { n       for (long long i = p * p; i <= 99999; i += p) prime[i] = false; n     } n   } n } n void solve() { n   long long n, g, b; n   cin >> n >> g >> b; n   long long d = n / 2 + n % 2; n   if (d % g) n     cout << max(n, (d / g) * (g + b) + d % g) <<   n ; n   else n     cout << max((d / g) * (g + b) - b, n) <<   n ; n } n int32_t main() { n   ios_base::sync_with_stdio(false); n   cin.tie(0); n   cout.tie(0); n   long long t = 1; n   cin >> t; n   cout << setprecision(15) << fixed; n   for (long long i = 1; i <= t; i++) solve(); n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int mod = (int)1e9 + 7; n const int N = (int)1e6 + 6; n int f[30][N]; n int pref[30][N]; n int lp[N]; n void precalc() { n   pref[0][0] = f[0][0] = 1; n   for (int i = 1; i < 30; i++) { n     f[i][0] = 2; n     pref[i][0] = f[i][0] + pref[i - 1][0]; n     pref[i][0] -= pref[i][0] >= mod ? mod : 0; n   } n   for (int level = 1; level < N; level++) { n     pref[0][level] = f[0][level] = 1; n     for (int pw = 1; pw < 30; pw++) { n       f[pw][level] = pref[pw][level - 1]; n       pref[pw][level] = f[pw][level] + pref[pw - 1][level]; n       pref[pw][level] -= pref[pw][level] >= mod ? mod : 0; n     } n   } n   for (int i = 2; i < N; i++) { n     if (lp[i]) continue; n     for (int j = i; j < N; j += i) { n       lp[j] = lp[j] ? lp[j] : i; n     } n   } n } n signed main() { n   ios_base::sync_with_stdio(false); n   cin.tie(0); n   precalc(); n   int T; n   scanf( %d , &T); n   while (T--) { n     int r, n; n     scanf( %d%d , &r, &n); n     if (n == 1) { n       printf( 1 n ); n       continue; n     } n     long long ans = 1; n     while (n > 1) { n       int p = lp[n]; n       int pw = 0; n       while (lp[n] == p) { n         n /= p; n         ++pw; n       } n       ans = ans * f[pw][r] % mod; n     } n     printf( %lld n , ans); n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int gcd(int a, int b) { return a % b == 0 ? b : gcd(b, a % b); } n const int MAXN = 3e5 + 10; n const int INF = 0x3f3f3f3f; n const int MOD = 1e7 + 9; n int a[MAXN]; n int main() { n   int n; n   scanf( %d , &n); n   for (int i = (1); i < (n + 1); ++i) { n     scanf( %d , &a[i]); n   } n   int ans1 = 0; n   int t1 = 1; n   for (int i = (n); i > (0); --i) { n     if (a[t1] != a[i]) { n       ans1 = i - t1; n       break; n     } else { n       t1++; n       i++; n     } n   } n   int ans2 = 0; n   int t2 = n; n   for (int i = (1); i < (n + 1); ++i) { n     if (a[t2] != a[i]) { n       ans2 = t2 - i; n       break; n     } else { n       t2--; n       i--; n     } n   } n   printf( %d n , max(ans1, ans2)); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int main() { n   long long int n, sum = 1; n   cin >> n; n   sum += 6 * ((n * (n + 1)) / 2); n   cout << sum << endl; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int N = 500005; n const int M = 998244353; n int n, a[N], i, s; n long long f[N], c[N], x, y, z, ans[N], tp; n long long qpow(long long a, long long b) { n   long long s = a, ans = 1; n   while (b) { n     if (b & 1) ans = ans * s % M; n     s = s * s % M; n     b >>= 1; n   } n   return ans; n } n int main() { n   scanf( %d , &n); n   for (i = 1; i <= n; ++i) { n     scanf( %d , &a[i]); n     s += a[i]; n   } n   long long is = qpow(s, M - 2), in = qpow(n - 1, M - 2); n   c[1] = 1 - n; n   f[0] = f[1] = 1; n   for (i = 1; i < s; ++i) { n     x = i * is % M, y = (s - i) * is % M * in % M; n     z = qpow(y, M - 2); n     f[i + 1] = (f[i] * (x + y) - f[i - 1] * x) % M * z % M; n     c[i + 1] = (c[i] * (x + y) - 1 - c[i - 1] * x) % M * z % M; n   } n   ans[0] = -c[s] * qpow(f[s], M - 2) % M; n   for (i = 1; i < s; ++i) ans[i] = (f[i] * ans[0] + c[i]) % M; n   for (i = 1; i <= n; ++i) tp += ans[a[i]]; n   tp -= ans[0] * (n - 1); n   cout << (tp % M * qpow(n, M - 2) % M + M) % M; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n long long w[2], b[2], q[2], mod = 998244353, fac[100001]; n long long modpow(long long b, long long p) { n   long long ret = 1; n   while (p > 0) { n     if (p & 1) ret = ret * b % mod; n     b = b * b % mod; n     p >>= 1; n   } n   return ret; n } n long long choose(long long n, long long m) { n   long long denom = modpow(fac[m], mod - 2) * modpow(fac[n - m], mod - 2) % mod; n   return (fac[n] * denom % mod); n } n int main() { n   ios::sync_with_stdio(0); n   cin.tie(0); n   long long n, qq = 0; n   bool bw = true, wb = true, both = true; n   string s; n   fac[0] = 1; n   for (int i = 1; i < 100001; i++) fac[i] = fac[i - 1] * i % mod; n   cin >> n; n   for (int i = 0; i < n; i++) { n     cin >> s; n     for (int j = 0; j < 2; j++) { n       if (s[j] ==  W ) w[j]++; n       if (s[j] ==  B ) b[j]++; n       if (s[j] ==  ? ) q[j]++; n     } n     if (s ==  ?? ) qq++; n     if (s ==  WW  || s ==  BB ) bw = wb = both = false; n     if (s ==  W?  || s ==  ?B  || s ==  WB ) bw = false; n     if (s ==  B?  || s ==  ?W  || s ==  BW ) wb = false; n   } n   if (n == 1) { n     if (s ==  WW  | s ==  BB ) n       cout << 0; n     else if (s ==  ?? ) n       cout << 2; n     else n       cout << 1; n     return 0; n   } n   long long ans = 0; n   for (int i = 0; i < q[0] + 1; i++) { n     if (w[0] + i < b[1] || w[0] + i > b[1] + q[1]) continue; n     ans = (ans + choose(q[0], i) * choose(q[1], w[0] + i - b[1])) % mod; n   } n   if (both) { n     ans -= modpow(2, qq); n     if (bw) ans++; n     if (wb) ans++; n   } n   ans = ((ans % mod) + mod) % mod; n   cout << ans; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using std::abs; n using std::bitset; n using std::cerr; n using std::cin; n using std::copy; n using std::cout; n using std::endl; n using std::fill; n using std::fixed; n using std::greater; n using std::lower_bound; n using std::map; n using std::max; n using std::min; n using std::next_permutation; n using std::pair; n using std::priority_queue; n using std::queue; n using std::reverse; n using std::rotate; n using std::set; n using std::sort; n using std::string; n using std::swap; n using std::unique; n using std::unordered_map; n using std::unordered_set; n using std::upper_bound; n using std::vector; n int const INF = (int)1e9; n long long const INFL = (long long)1e18; n long double const PI = 3.1415926535897932384626433832795028; n bool isPrime(int x) { n   for (int a = 2; a * a <= x; ++a) { n     if (x % a == 0) { n       return false; n     } n   } n   return true; n } n int const N = 100100; n int len[N]; n int g[N], next[N]; n int find(int v) { n   if (next[v] != v) { n     int root = find(next[v]); n     len[v] += len[next[v]]; n     next[v] = root; n   } n   return next[v]; n } n int v[N], res[N]; n bool did[N]; n int calc(int a, int b) { n   int ret = 0; n   find(a); n   b -= len[a]; n   a = next[a]; n   while (b > 0 && !did[a]) { n     ++ret; n     did[a] = true; n     next[a] = find(g[a]); n     len[a] = 1 + len[g[a]]; n     b -= len[a]; n     a = find(g[a]); n   } n   return ret; n } n void solve() { n   int n, m; n   cin >> n >> m; n   for (int i = 0; i < n; ++i) { n     next[i] = i; n     len[i] = 0; n     cin >> g[i]; n     --g[i]; n   } n   for (int i = 1; i <= m; ++i) { n     cin >> v[i]; n   } n   for (int i = 1; i <= m; ++i) { n     int b; n     cin >> b; n     int a = (v[i] + res[i - 1] - 1) % n; n     res[i] = calc(a, b); n   } n   for (int i = 1; i <= m; ++i) { n     cout << res[i] <<   n ; n   } n } n int main() { solve(); } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n bool vis[305][305]; n string s[305]; n int len[305][305]; n int d[305]; n int hs[305][305]; n int n; n const int mod = 9e8 + 7; n int qpow(int x, int y) { n   long long ret = 1; n   long long now = x; n   while (y) { n     if (y & 1) ret = ret * now % mod; n     now = now * now % mod; n     y >>= 1; n   } n   return ret; n } n void init() { n   memset(vis, false, sizeof(vis)); n   for (int i = 1; i <= n; i++) { n     d[i] = 0; n     len[i][0] = s[i].size(); n     for (int j = 0; j < s[i].size(); j++) { n       d[i] = (d[i] * 233LL + s[i][j] -  a  + 1) % mod; n     } n   } n   for (int i = 1; i <= n; i++) { n     hs[i][0] = d[i]; n     for (int j = 1; j + i <= n; j++) { n       len[i][j] = len[i + j][0] + len[i][j - 1]; n       hs[i][j] = (1LL * hs[i][j - 1] * 2333LL + d[i + j]) % mod; n     } n   } n } n int main() { n   scanf( %d , &n); n   for (int i = 1; i <= n; i++) cin >> s[i]; n   init(); n   int ans = 0; n   for (int i = 1; i <= n; i++) { n     int ls = 0; n     for (int j = 0; i + j <= n; j++) { n       ls += len[i + j][0]; n       int nx = i + j + 1; n       int cnt = 1; n       while (nx + j <= n) { n         if (hs[i][j] == hs[nx][j] && len[i][j] == len[nx][j]) { n           cnt++; n           nx += j + 1; n         } else { n           nx++; n         } n       } n       if (cnt > 1) ans = max(ans, (ls - 1) * cnt); n     } n   } n   ans = n - 1 - ans; n   for (int i = 1; i <= n; i++) ans += len[i][0]; n   cout << ans << endl; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n vector<int> v[100005]; n int p[100005]; n int h[100005]; n int happy[100005]; n int sad[100005]; n bool vis[100005]; n bool ok; n void init(int n) { n   for (int i = 1; i < n + 1; i++) { n     v[i].clear(); n     vis[i] = false; n   } n   ok = true; n } n void dfs(int node) { n   vis[node] = true; n   long long int happyChild = 0; n   long long int sadChild = p[node]; n   for (int child : v[node]) { n     if (vis[child]) continue; n     dfs(child); n     happyChild += happy[child]; n     sadChild += sad[child]; n   } n   long long int gg = (long long int)h[node] - (happyChild - sadChild); n   if (gg >= 0 && gg % 2 == 0 && gg / 2 <= sadChild) { n     long long int x = gg / 2; n     happy[node] = x + happyChild; n     sad[node] = sadChild - x; n   } else { n     ok = false; n     return; n   } n } n int main() { n   int t, n, m, a, b; n   scanf( %d , &t); n   while (t--) { n     scanf( %d %d , &n, &m); n     init(n); n     for (int i = 1; i < n + 1; i++) scanf( %d , &p[i]); n     for (int i = 1; i < n + 1; i++) scanf( %d , &h[i]); n     for (int i = 0; i < n - 1; i++) { n       scanf( %d %d , &a, &b); n       v[a].push_back(b); n       v[b].push_back(a); n     } n     dfs(1); n     if (ok) n       puts( YES ); n     else n       puts( NO ); n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n long long j, k, a, b, s, ss, l, m, n, t, d; n long long e, i, c[221]; n vector<long long> p[111], q[111], r, v; n char w; n map<long long, long long> y, z; n long long too(long long i, long long j) { n   long long l = 0, d = 0; n   for (k = 0; k < q[i].size(); k++) { n     l += q[i][k]; n     r.push_back(l); n   } n   l = 0; n   for (k = 0; k < q[j].size(); k++) { n     l += q[j][k]; n     r.push_back(l); n   } n   l = r.size(); n   sort(r.begin(), r.end()); n   for (k = 0; k < l; k++) c[k] = 0; n   for (k = 0; k < l; k++) { n     long long x, a = 0, b = 0, e = 0; n     x = r[k]; n     while (x > q[i][e] && e < q[i].size()) { n       a += p[i][e] * q[i][e]; n       x -= q[i][e]; n       e++; n     } n     if (e < q[i].size()) a += p[i][e] * x; n     x = r[k]; n     e = 0; n     while (x > q[j][e] && e < q[j].size()) { n       b += p[j][e] * q[j][e]; n       x -= q[j][e]; n       e++; n     } n     if (e < q[j].size()) b += p[j][e] * x; n     if (a > b) c[k] = 1; n     if (a < b) c[k] = 2; n   } n   e = 0; n   while (c[e] == 0) e++; n   for (k = e + 1; k < l; k++) { n     if (c[k] == 0) c[k] = c[k - 1]; n   } n   for (k = e + 1; k < l; k++) n     if (c[k] != c[k - 1]) d++; n   return d; n } n int main() { n   cin >> n >> s; n   for (i = 0; i < n; i++) { n     cin >> k; n     for (j = 0; j < k; j++) { n       cin >> a >> b; n       p[i].push_back(a); n       q[i].push_back(b); n     } n   } n   for (i = 0; i < n; i++) { n     for (j = i + 1; j < n; j++) { n       ss += too(i, j); n       r = v; n     } n   } n   cout << ss; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int N = int(1e6) + 50; n char S[N], T[N]; n int slen, tlen, lef[N], rig[N], cnt[255][255]; n inline int getID(char c) { n   if (c ==  R ) return 0; n   if (c ==  G ) return 1; n   if (c ==  B ) return 2; n   throw; n } n int main() { n   scanf( %s , S + 1); n   slen = strlen(S + 1); n   scanf( %s , T + 1); n   tlen = strlen(T + 1); n   int l = 1, r = 1; n   while (l <= slen && r <= tlen) { n     lef[l] = r; n     r += S[l] == T[r]; n     ++l; n   } n   slen = min(slen, l - 1); n   l = r = 1; n   while (l <= slen && r <= tlen) { n     rig[l] = r; n     l += S[l] == T[r]; n     ++r; n   } n   tlen = min(tlen, r - 1); n   for (int i = l + bool(rig[l]); i <= slen; ++i) { n     rig[i] = tlen; n   } n   long long res = 0; n   for (int i = 1; i <= slen; ++i) { n     for (int j = max(1, lef[i - 1]); j < lef[i]; ++j) --cnt[T[j]][T[j - 1]]; n     for (int j = 1 + rig[i - 1]; j <= rig[i]; ++j) ++cnt[T[j]][T[j - 1]]; n     res += rig[i] - lef[i] + 1; n     if (S[i - 1] != S[i]) res -= cnt[S[i - 1]][S[i]]; n   } n   printf( %I64d n , res); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int n, m, k; n long long ans; n int main() { n   cin >> n >> m >> k; n   if (k > n + m - 2) { n     cout <<  -1  << endl; n     return 0; n   } n   if (n >= m) swap(n, m); n   if (k <= m - 1) { n     ans = (long long)(m / (k + 1)) * n; n   } else { n     ans = (long long)(n / (k - m + 2)); n   } n   if (k <= n - 1) { n     ans = max(ans, (long long)(n / (k + 1)) * m); n   } else { n     ans = max(ans, (long long)(m / (k - n + 2))); n   } n   cout << ans << endl; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int MAXN = 110; n int n, m, k; n int h[MAXN]; n void load() { n   scanf( %d%d%d , &n, &m, &k); n   for (int i = 0; i < n; i++) scanf( %d , h + i); n } n bool solve() { n   long long sum = m; n   int ind = 0; n   while (ind < n - 1) { n     if (h[ind] >= h[ind + 1] - k) { n       int nxt = max(h[ind + 1] - k, 0); n       sum += h[ind] - nxt; n     } else { n       if (sum + h[ind] < h[ind + 1] - k) return false; n       sum -= h[ind + 1] - k - h[ind]; n     } n     ind++; n   } n   return true; n } n int main() { n   int t; n   scanf( %d , &t); n   while (t--) { n     load(); n     if (solve()) n       printf( YES n ); n     else n       printf( NO n ); n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int MAXN = 3e5 + 10; n int n, k; n int a[MAXN], f[MAXN]; n int bsL(int l, int r, int val) { n   int pos = -1; n   while (l <= r) { n     int mid = (l + r) >> 1; n     if (a[mid] >= val) { n       pos = mid; n       r = mid - 1; n     } else n       l = mid + 1; n   } n   return pos; n } n bool check(int x) { n   f[1] = 1; n   for (int i = 1, l = 1; i <= n; i++) { n     while (a[i] - a[l] > x) l++; n     f[i + 1] = (i >= k && f[i - k + 1] - f[l - 1] > 0); n     f[i + 1] += f[i]; n   } n   return f[n + 1] - f[n] > 0; n } n int bs(int l, int r) { n   int pos = 0; n   while (l <= r) { n     int mid = (l + r) >> 1; n     if (check(mid)) { n       pos = mid; n       r = mid - 1; n     } else n       l = mid + 1; n   } n   return pos; n } n int main() { n   ios_base::sync_with_stdio(0); n   cin >> n >> k; n   for (int i = 1; i <= n; i++) cin >> a[i]; n   sort(a + 1, a + 1 + n); n   cout << bs(0, 1e9); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const long long N = 1e5 + 10; n long long h[N], e[2 * N], ne[2 * N], idx; n void add(long long a, long long b) { e[idx] = b, ne[idx] = h[a], h[a] = idx++; } n struct node { n   long long sum, add; n }; n node tr[N << 2]; n long long arr[N]; n long long f[N][20]; n long long dep[N], fa[N], son[N], sz[N]; n long long n, q; n void dfs1(long long u, long long fz) { n   fa[u] = fz; n   dep[u] = dep[fz] + 1; n   sz[u] = 1; n   f[u][0] = fz; n   for (long long i = 1; i < 20; ++i) f[u][i] = f[f[u][i - 1]][i - 1]; n   for (long long i = h[u]; i != -1; i = ne[i]) { n     long long j = e[i]; n     if (j == fz) continue; n     dfs1(j, u); n     sz[u] += sz[j]; n     if (sz[j] > sz[son[u]]) { n       son[u] = j; n     } n   } n } n long long id[N], top[N], uid[N], tot; n void dfs2(long long u, long long topx) { n   top[u] = topx; n   id[u] = ++tot; n   uid[tot] = u; n   if (!son[u]) return; n   dfs2(son[u], topx); n   for (long long i = h[u]; i != -1; i = ne[i]) { n     long long j = e[i]; n     if (j == fa[u] || j == son[u]) continue; n     dfs2(j, j); n   } n } n long long get_lca(long long a, long long b) { n   while (top[a] != top[b]) { n     if (dep[top[a]] > dep[top[b]]) n       a = fa[top[a]]; n     else n       b = fa[top[b]]; n   } n   return dep[a] > dep[b] ? b : a; n } n long long topC(long long x, long long c) { n   for (long long i = 19; i >= 0; i--) { n     if ((1 << i) <= c) { n       x = f[x][i]; n       c -= (1 << i); n     } n   } n   return x; n } n long long root; n void pushup(long long u) { tr[u].sum = tr[u << 1].sum + tr[u << 1 | 1].sum; } n void pushdown(long long l, long long r, long long u) { n   if (tr[u].add) { n     long long mid = l + r >> 1; n     tr[u << 1].sum += (mid - l + 1) * tr[u].add; n     tr[u << 1 | 1].sum += (r - mid) * tr[u].add; n     tr[u << 1].add += tr[u].add; n     tr[u << 1 | 1].add += tr[u].add; n     tr[u].add = 0; n   } n } n long long query(long long l, long long r, long long a, long long b, n                 long long u) { n   if (l <= a && b <= r) { n     return tr[u].sum; n   } n   pushdown(a, b, u); n   long long mid = a + b >> 1; n   long long ans = 0; n   if (l <= mid) ans += query(l, r, a, mid, u << 1); n   if (r > mid) ans += query(l, r, mid + 1, b, u << 1 | 1); n   return ans; n } n void ud(long long l, long long r, long long a, long long b, long long d, n         long long u) { n   if (l <= a && b <= r) { n     tr[u].add += d; n     tr[u].sum += (b - a + 1) * d; n     return; n   } n   pushdown(a, b, u); n   long long mid = a + b >> 1; n   if (l <= mid) ud(l, r, a, mid, d, u << 1); n   if (r > mid) ud(l, r, mid + 1, b, d, u << 1 | 1); n   pushup(u); n } n void update(long long u, long long x) { n   ud(id[u], id[u] + sz[u] - 1, 1, n, x, 1); n } n long long qry(long long u) { return query(id[u], id[u] + sz[u] - 1, 1, n, 1); } n void build(long long l, long long r, long long u) { n   tr[u].add = 0; n   if (l == r) { n     tr[u].sum = arr[uid[l]]; n     return; n   } n   long long mid = l + r >> 1; n   build(l, mid, u << 1); n   build(mid + 1, r, u << 1 | 1); n   pushup(u); n } n int main() { n   ios::sync_with_stdio(false); n   std::cin.tie(0); n   memset(h, -1, sizeof h); n   cin >> n >> q; n   for (long long i = 1; i <= n; ++i) cin >> arr[i]; n   for (long long i = 1; i < n; ++i) { n     long long a, b; n     cin >> a >> b; n     add(a, b); n     add(b, a); n   } n   dfs1(1, 1); n   dfs2(1, 1); n   build(1, n, 1); n   root = 1; n   while (q--) { n     long long t; n     cin >> t; n     long long v, u, x; n     if (t == 1) { n       cin >> v; n       root = v; n     } else if (t == 2) { n       cin >> u >> v >> x; n       long long t1 = get_lca(u, root); n       long long t2 = get_lca(v, root); n       long long t3 = get_lca(u, v); n       long long ans = t1; n       if (dep[ans] < dep[t2]) ans = t2; n       if (dep[ans] < dep[t3]) ans = t3; n       long long lca = get_lca(root, ans); n       if (ans == root) { n         update(1, x); n       } else if (lca != ans) { n         update(ans, x); n       } else { n         update(1, x); n         long long s = topC(root, dep[root] - dep[ans] - 1); n         update(s, -x); n       } n     } else { n       cin >> v; n       long long ans = v; n       long long lca = get_lca(root, ans); n       if (ans == root) { n         cout << qry(1) << endl; n       } else if (lca != ans) { n         cout << qry(ans) << endl; n       } else { n         long long s = topC(root, dep[root] - dep[ans] - 1); n         cout << (qry(1) - qry(s)) << endl; n       } n     } n   } n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int mod = 1e9 + 7; n const double EPS = 1e-9; n const int INF = 1 << 29; n int const NN = 5e3 + 3; n int const MX = 1e9 + 9; n int a[505][505]; n int mx[505][505]; n int main() { n   int n, m, K, q; n   cin >> n >> m >> K >> q; n   for (int i = 1; i <= n; ++i) { n     for (int j = 1; j <= m; ++j) a[i][j] = MX; n   } n   while (q--) { n     int x, y, t; n     cin >> x >> y >> t; n     a[x][y] = t; n   } n   int ans = MX; n   for (int i = 1; i <= n; ++i) { n     for (int j = 1; j <= m; ++j) { n       mx[i][j] = a[i][j]; n       for (int k = 2; i + k - 1 <= n && k <= K; ++k) { n         mx[i][j] = max(mx[i][j], a[i + k - 1][j]); n       } n     } n   } n   for (int i = 1; i + K - 1 <= n; ++i) { n     for (int j = 1; j + K - 1 <= m; ++j) { n       int mxx = -1; n       for (int jj = j; jj <= j + K - 1; ++jj) { n         mxx = max(mxx, mx[i][jj]); n       } n       ans = min(ans, mxx); n     } n   } n   if (ans < MX) { n     printf( %d , ans); n     ; n     putchar(  n ); n   } else n     puts( -1 ); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n using ll = long long; n  n void solve() { n     int n, k; n     cin >> n >> k; n     if(2 * k + 1 > n) { n         cout <<  -1 n ; n         return; n     } n     vector<int> v(n); n     int p = n; n     for(int i = 1; i < 1 + 2 * k; i += 2) n         v[i] = p--; n     p = 1; n     for(int i = 0; i < n; i++) { n         if(v[i]) n             continue; n         v[i] = p++; n     } n     for(auto &x : v) n         cout << x <<    ; n     cout <<   n ; n } n  n int main() { n     ios_base::sync_with_stdio(false); n     cin.tie(0); n  n     int t; n     cin >> t; n     while(t--) n         solve();     n }"}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int maxn = 100005; n char S[maxn][10]; n int ju(char a[], char b[]) { n   int n = strlen(a), m = strlen(b); n   int x = 0, y = 0; n   for (int i = 0; i < n; i++) x = x * 10 + a[i] -  0 ; n   for (int j = 0; j < m; j++) y = y * 10 + (b[j] ==  ?  ? 9 : b[j] -  0 ); n   return x < y; n } n int f(int ind) { n   int m = strlen(S[ind - 1]), n = strlen(S[ind]); n   if (m < n) { n     for (int i = 0; i < n; i++) n       if (S[ind][i] ==  ? ) { n         if (i == 0) n           S[ind][i] =  1 ; n         else n           S[ind][i] =  0 ; n       } n   } else if (m > n) { n     return 1; n   } else { n     for (int i = 0; i < n; i++) { n       if (S[ind][i] ==  ? ) n         for (int j = 0; j <= 9; j++) { n           S[ind][i] =  0  + j; n           if (ju(S[ind - 1], S[ind])) break; n         } n     } n     if (!ju(S[ind - 1], S[ind])) return 1; n   } n   return 0; n } n int main() { n   int n; n   while (scanf( %d , &n) > 0) { n     int si = 1; n     S[0][0] =  0 ; n     S[0][1] =   0 ; n     for (int i = 1; i <= n; i++) { n       scanf( %s , S[i]); n       if (si && f(i)) si = 0; n     } n     if (si) { n       printf( YES n ); n       for (int i = 1; i <= n; i++) printf( %s n , S[i]); n     } else { n       printf( NO n ); n     } n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n struct Friend { n   string name; n   int x, y, z; n } f[123]; n bool Isde(char *a) { n   if (a[0] <= a[1]) return false; n   if (a[1] <= a[3]) return false; n   if (a[3] <= a[4]) return false; n   if (a[4] <= a[6]) return false; n   if (a[6] <= a[7]) return false; n   return true; n } n bool Isiden(char *a) { n   if (a[0] != a[1]) return false; n   if (a[1] != a[3]) return false; n   if (a[3] != a[4]) return false; n   if (a[4] != a[6]) return false; n   if (a[6] != a[7]) return false; n   return true; n } n int main() { n   int n; n   while (cin >> n) { n     int mx = 0, my = 0, mz = 0; n     for (int i = 0; i < n; ++i) { n       int m; n       cin >> m >> f[i].name; n       f[i].x = f[i].y = f[i].z; n       char str[100]; n       for (int j = 0; j < m; ++j) { n         cin >> str; n         if (Isiden(str)) n           f[i].x++; n         else if (Isde(str)) n           f[i].y++; n         else n           f[i].z++; n       } n       mx = max(f[i].x, mx); n       my = max(f[i].y, my); n       mz = max(f[i].z, mz); n     } n     bool flag = false; n     cout <<  If you want to call a taxi, you should call:  ; n     for (int i = 0; i < n; ++i) { n       if (f[i].x == mx) { n         if (flag) cout <<  ,  ; n         cout << f[i].name; n         flag = true; n       } n     } n     cout <<  .  << endl; n     flag = false; n     cout <<  If you want to order a pizza, you should call:  ; n     for (int i = 0; i < n; ++i) { n       if (f[i].y == my) { n         if (flag) cout <<  ,  ; n         cout << f[i].name; n         flag = true; n       } n     } n     cout <<  .  << endl; n     flag = false; n     cout <<  If you want to go to a cafe with a wonderful girl, you should   n              call:  ; n     for (int i = 0; i < n; ++i) { n       if (f[i].z == mz) { n         if (flag) cout <<  ,  ; n         cout << f[i].name; n         flag = true; n       } n     } n     cout <<  .  << endl; n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int L = 0, R = 10000; n int n, vote, tot; n vector<int> p[110000]; n pair<int, int> x[110000]; n long long sum[110000]; n long long he[4 * 110000]; n int num[4 * 110000]; n long long ask(int root, int l, int r, int k) { n   if (k <= 0) n     return 0; n   else if (num[root] == k) n     return he[root]; n   else if (l == r) n     return (long long)k * l; n   else { n     int mid = (l + r) >> 1; n     if (num[2 * root] < k) { n       return ask(2 * root, l, mid, num[2 * root]) + n              ask(2 * root + 1, mid + 1, r, k - num[2 * root]); n     } else { n       return ask(2 * root, l, mid, k); n     } n   } n } n void add(int root, int l, int r, int k) { n   if (l > r || k < l || k > r) n     return; n   else if (l == r) { n     num[root]++; n     he[root] += k; n   } else { n     num[root]++; n     he[root] += k; n     int mid = (l + r) >> 1; n     add(2 * root, l, mid, k); n     add(2 * root + 1, mid + 1, r, k); n   } n } n int main() { n   cin >> n; n   int mx = 0; n   for (int i = 0, a, b; i < n; i++) { n     scanf( %d%d , &a, &b); n     if (a != 0) n       p[a].push_back(b); n     else n       vote++; n   } n   for (int i = 1; i < 110000; i++) { n     sort(p[i].begin(), p[i].end()); n     reverse(p[i].begin(), p[i].end()); n     mx = max(mx, (int)p[i].size()); n   } n   for (int i = 1; i < 110000; i++) { n     int m = (int)p[i].size(); n     for (int j = 0; j < m; j++) { n       x[tot++] = pair<int, int>(j + 1, p[i][j]); n     } n   } n   sort(x, x + tot); n   for (int i = 0; i < tot; i++) { n     if (i == 0) n       sum[i] = x[i].second; n     else n       sum[i] = sum[i - 1] + x[i].second; n   } n   long long ans = 1e10; n   int pre = 0; n   for (int i = 0; i <= mx + 1; i++) { n     int indx = upper_bound(x, x + tot, pair<int, int>(i, 1e9)) - x; n     long long cans = sum[tot - 1] - sum[indx] + x[indx].second; n     if (indx == tot) cans = 0; n     while (pre < indx) { n       add(1, L, R, x[pre].second); n       pre++; n     } n     indx = tot - indx + vote; n     if (i >= indx) { n       indx = i - indx + 1; n       cans += ask(1, L, R, indx); n     } n     ans = min(ans, cans); n   } n   cout << ans << endl; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int mod = 998244353; n long long inv(long long a) { n   long long u = 0, v = 1, b = mod; n   while (a) { n     long long t = b / a; n     b -= t * a, u -= t * v; n     swap(a, b); n     swap(u, v); n   } n   u %= mod; n   if (u < 0) u += mod; n   return u; n } n struct mint { n   int x; n   mint() : x(0) {} n   mint(int x) : x(x) {} n   mint(long long x) : x() { n     if (x >= mod || x < -mod) x %= mod; n     if (x < 0) x += mod; n     this->x = x; n   } n   mint &operator-=(const mint &rhs) { n     x -= rhs.x; n     if (x < 0) x += mod; n     return *this; n   } n   mint &operator+=(const mint &rhs) { n     x += rhs.x; n     if (x >= mod) x -= mod; n     return *this; n   } n   mint &operator*=(const mint &rhs) { n     x = (long long)x * rhs.x % mod; n     return *this; n   } n   mint &operator/=(const mint &rhs) { n     x = (long long)x * inv(rhs.x) % mod; n     return *this; n   } n   bool operator<(const mint &rhs) { return x < rhs.x; } n   bool operator==(const mint &rhs) { return x == rhs.x; } n   bool operator!=(const mint &rhs) { return x != rhs.x; } n   friend mint operator+(const mint &lhs, const mint &rhs) { n     mint ret(lhs); n     return ret += rhs; n   } n   friend mint operator-(const mint &lhs, const mint &rhs) { n     mint ret(lhs); n     return ret -= rhs; n   } n   friend mint operator*(const mint &lhs, const mint &rhs) { n     mint ret(lhs); n     return ret *= rhs; n   } n   friend mint operator/(const mint &lhs, const mint &rhs) { n     mint ret(lhs); n     return ret /= rhs; n   } n   friend ostream &operator<<(ostream &os, const mint &rhs) { n     os << rhs.x; n     return os; n   } n   friend istream &operator>>(istream &is, mint &rhs) { n     long long a; n     is >> a; n     rhs = a; n     return is; n   } n }; n mint fpow(mint a, long long b) { n   mint r = 1; n   for (; b; b >>= 1) { n     if (b & 1) r = r * a; n     a = a * a; n   } n   return r; n } n const int N = 1e6 + 5; n mint pw[N]; n int main() { n   ios::sync_with_stdio(0); n   cin.tie(0); n   cout.tie(0); n   int n, m, k; n   cin >> n >> m >> k; n   pw[0] = 1; n   for (int i = 1; i <= max(n, m); ++i) pw[i] = pw[i - 1] * 2; n   int f0 = 1, f1 = 1, cntx = n, cnty = m, fx = 0, fy = 0; n   vector<int> cnt(2); n   vector<vector<int>> cntr(n, vector<int>(2, 0)), cntc(m, vector<int>(2, 0)); n   map<pair<int, int>, int> mp; n   auto Erase = [&](int x, int y) { n     if (!mp.count({x, y})) return; n     int p = mp[{x, y}]; n     mp.erase({x, y}); n     if (--cntr[x][p ^ y & 1] == 0) { n       if (cntr[x][p ^ y & 1 ^ 1]) n         fx--; n       else n         cntx += 1; n     } n     if (--cntc[y][p ^ x & 1] == 0) { n       if (cntc[y][p ^ x & 1 ^ 1]) n         fy--; n       else n         cnty += 1; n     } n     --cnt[x & 1 ^ y & 1 ^ p]; n   }; n   auto Insert = [&](int x, int y, int p) { n     mp[{x, y}] = p; n     if (cntr[x][p ^ y & 1]++ == 0) { n       if (cntr[x][p ^ y & 1 ^ 1]) n         fx++; n       else n         cntx -= 1; n     } n     if (cntc[y][p ^ x & 1]++ == 0) { n       if (cntc[y][p ^ x & 1 ^ 1]) n         fy++; n       else n         cnty -= 1; n     } n     ++cnt[x & 1 ^ y & 1 ^ p]; n   }; n   while (k--) { n     int x, y, op; n     cin >> x >> y >> op; n     --x, --y; n     Erase(x, y); n     if (op != -1) Insert(x, y, op); n     mint ans = -(cnt[0] == 0) - (cnt[1] == 0); n     if (fx == 0) ans += pw[cntx]; n     if (fy == 0) ans += pw[cnty]; n     cout << ans <<   n ; n   } n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int main() { n   long long int i, a, p, b, p1, p2; n   cin >> a; n   b = a; n   p = 0; n   p1 = p2 = 1; n   for (i = 2; i <= sqrt(b); i++) { n     if (b % i == 0) { n       b = b / i; n       p++; n       if (p == 1) p1 = i; n       if (p == 2) p2 = i; n       i--; n     } n   } n   if (p == 0) cout << 1 << endl << 0 << endl; n   if (p == 1) cout << 2 << endl; n   if (p >= 2) cout << 1 << endl << p1 * p2 << endl; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n template <class P, class Q> n ostream& operator<<(ostream& stream, pair<P, Q> v) { n   stream <<  (  << v.first <<  ,  << v.second <<  ) ; n   return stream; n } n template <class T> n ostream& operator<<(ostream& stream, const vector<T> v) { n   stream <<  [  ; n   for (int i = 0; i < (int)v.size(); i++) stream << v[i] <<    ; n   stream <<  ] ; n   return stream; n } n template <class T> n T smin(T& a, T b) { n   if (a > b) a = b; n   return a; n } n template <class T> n T smax(T& a, T b) { n   if (a < b) a = b; n   return a; n } n const long long M = 10004205361450474; n int ask(vector<long long> s) { n   int sz = s.size(); n   cout << sz <<    ; n   for (int i = 0; i < sz; ++i) cout << s[i] <<    n [i == sz - 1]; n   fflush(stdout); n   int v = 0; n   cin >> v; n   if (v == -1) { n     exit(0); n   } n   return v; n } n const int N = 1e4 + 5; n long long dp[N][6]; n long long f(int A, int B) { n   if (!B) return 0; n   if (dp[A][B] != -1) return dp[A][B]; n   long long& ans = dp[A][B]; n   ans = 0; n   const int W = A; n   for (int i = 0; i < W; ++i) { n     ans += f(A, B - 1) + 1; n     A = min(10000ll, A + f(A, B - 1) + 1); n   } n   ans += f(A, B - 1); n   return ans; n } n long long g(long long a, int b) { return f(min(10000ll, a), b); } n int main(void) { n   memset(dp, -1, sizeof(dp)); n   const long long c1 = M - f(10000, 4); n   const long long c2 = 2046; n   const long long c3 = 6; n   long long l, r; n   int used = 5; n   --used; n   if (ask(vector<long long>{c1}) > 0) { n     l = c1 + 1; n     r = M; n     goto shit; n   } n   --used; n   if (ask(vector<long long>{c2}) > 0) { n     l = c2 + 1; n     r = c1 - 1; n     goto shit; n   } n   --used; n   if (ask(vector<long long>{c3}) > 0) { n     l = c3 + 1; n     r = c2 - 1; n   } else { n     l = 1; n     r = c3 - 1; n   } n shit: n   for (int cs = used - 1; cs >= 0; --cs) { n     vector<long long> s; n     for (long long i = l; i + g(i, cs) <= r && s.size() < min(10000ll, l); n          i += g(i, cs) + 1) n       s.push_back(i + g(i, cs)); n     int v = ask(s); n     if (!v) { n       smin(r, s[0] - 1); n     } else if (v == s.size()) { n       smax(l, s.back() + 1); n     } else { n       smin(r, s[v] - 1); n       smax(l, s[v - 1] + 1); n     } n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n template <typename T> n T inverse(T a, T m) { n   T u = 0, v = 1; n   while (a != 0) { n     T t = m / a; n     m -= t * a; n     swap(a, m); n     u -= t * v; n     swap(u, v); n   } n   assert(m == 1); n   return u; n } n template <typename T> n class Modular { n  public: n   using Type = typename decay<decltype(T::value)>::type; n   constexpr Modular() : value() {} n   template <typename U> n   Modular(const U& x) { n     value = normalize(x); n   } n   template <typename U> n   static Type normalize(const U& x) { n     Type v; n     if (-mod() <= x && x < mod()) n       v = static_cast<Type>(x); n     else n       v = static_cast<Type>(x % mod()); n     if (v < 0) v += mod(); n     return v; n   } n   const Type& operator()() const { return value; } n   template <typename U> n   explicit operator U() const { n     return static_cast<U>(value); n   } n   constexpr static Type mod() { return T::value; } n   Modular& operator+=(const Modular& other) { n     if ((value += other.value) >= mod()) value -= mod(); n     return *this; n   } n   Modular& operator-=(const Modular& other) { n     if ((value -= other.value) < 0) value += mod(); n     return *this; n   } n   template <typename U> n   Modular& operator+=(const U& other) { n     return *this += Modular(other); n   } n   template <typename U> n   Modular& operator-=(const U& other) { n     return *this -= Modular(other); n   } n   Modular& operator++() { return *this += 1; } n   Modular& operator--() { return *this -= 1; } n   Modular operator++(int) { n     Modular result(*this); n     *this += 1; n     return result; n   } n   Modular operator--(int) { n     Modular result(*this); n     *this -= 1; n     return result; n   } n   Modular operator-() const { return Modular(-value); } n   template <typename U = T> n   typename enable_if<is_same<typename Modular<U>::Type, int>::value, n                      Modular>::type& n   operator*=(const Modular& rhs) { n     value = normalize(static_cast<int64_t>(value) * n                       static_cast<int64_t>(rhs.value)); n     return *this; n   } n   template <typename U = T> n   typename enable_if<is_same<typename Modular<U>::Type, long long>::value, n                      Modular>::type& n   operator*=(const Modular& rhs) { n     long long q = static_cast<long long>(static_cast<long double>(value) * n                                          rhs.value / mod()); n     value = normalize(value * rhs.value - q * mod()); n     return *this; n   } n   template <typename U = T> n   typename enable_if<!is_integral<typename Modular<U>::Type>::value, n                      Modular>::type& n   operator*=(const Modular& rhs) { n     value = normalize(value * rhs.value); n     return *this; n   } n   Modular& operator/=(const Modular& other) { n     return *this *= Modular(inverse(other.value, mod())); n   } n   friend const Type& abs(const Modular& x) { return x.value; } n   template <typename U> n   friend bool operator==(const Modular<U>& lhs, const Modular<U>& rhs); n   template <typename U> n   friend bool operator<(const Modular<U>& lhs, const Modular<U>& rhs); n   template <typename V, typename U> n   friend V& operator>>(V& stream, Modular<U>& number); n  n  private: n   Type value; n }; n template <typename T> n bool operator==(const Modular<T>& lhs, const Modular<T>& rhs) { n   return lhs.value == rhs.value; n } n template <typename T, typename U> n bool operator==(const Modular<T>& lhs, U rhs) { n   return lhs == Modular<T>(rhs); n } n template <typename T, typename U> n bool operator==(U lhs, const Modular<T>& rhs) { n   return Modular<T>(lhs) == rhs; n } n template <typename T> n bool operator!=(const Modular<T>& lhs, const Modular<T>& rhs) { n   return !(lhs == rhs); n } n template <typename T, typename U> n bool operator!=(const Modular<T>& lhs, U rhs) { n   return !(lhs == rhs); n } n template <typename T, typename U> n bool operator!=(U lhs, const Modular<T>& rhs) { n   return !(lhs == rhs); n } n template <typename T> n bool operator<(const Modular<T>& lhs, const Modular<T>& rhs) { n   return lhs.value < rhs.value; n } n template <typename T> n Modular<T> operator+(const Modular<T>& lhs, const Modular<T>& rhs) { n   return Modular<T>(lhs) += rhs; n } n template <typename T, typename U> n Modular<T> operator+(const Modular<T>& lhs, U rhs) { n   return Modular<T>(lhs) += rhs; n } n template <typename T, typename U> n Modular<T> operator+(U lhs, const Modular<T>& rhs) { n   return Modular<T>(lhs) += rhs; n } n template <typename T> n Modular<T> operator-(const Modular<T>& lhs, const Modular<T>& rhs) { n   return Modular<T>(lhs) -= rhs; n } n template <typename T, typename U> n Modular<T> operator-(const Modular<T>& lhs, U rhs) { n   return Modular<T>(lhs) -= rhs; n } n template <typename T, typename U> n Modular<T> operator-(U lhs, const Modular<T>& rhs) { n   return Modular<T>(lhs) -= rhs; n } n template <typename T> n Modular<T> operator*(const Modular<T>& lhs, const Modular<T>& rhs) { n   return Modular<T>(lhs) *= rhs; n } n template <typename T, typename U> n Modular<T> operator*(const Modular<T>& lhs, U rhs) { n   return Modular<T>(lhs) *= rhs; n } n template <typename T, typename U> n Modular<T> operator*(U lhs, const Modular<T>& rhs) { n   return Modular<T>(lhs) *= rhs; n } n template <typename T> n Modular<T> operator/(const Modular<T>& lhs, const Modular<T>& rhs) { n   return Modular<T>(lhs) /= rhs; n } n template <typename T, typename U> n Modular<T> operator/(const Modular<T>& lhs, U rhs) { n   return Modular<T>(lhs) /= rhs; n } n template <typename T, typename U> n Modular<T> operator/(U lhs, const Modular<T>& rhs) { n   return Modular<T>(lhs) /= rhs; n } n template <typename T, typename U> n Modular<T> power(const Modular<T>& a, const U& b) { n   assert(b >= 0); n   Modular<T> x = a, res = 1; n   U p = b; n   while (p > 0) { n     if (p & 1) res *= x; n     x *= x; n     p >>= 1; n   } n   return res; n } n template <typename T> n bool IsZero(const Modular<T>& number) { n   return number() == 0; n } n template <typename T> n string to_string(const Modular<T>& number) { n   return to_string(number()); n } n template <typename U, typename T> n U& operator<<(U& stream, const Modular<T>& number) { n   return stream << number(); n } n template <typename U, typename T> n U& operator>>(U& stream, Modular<T>& number) { n   typename common_type<typename Modular<T>::Type, long long>::type x; n   stream >> x; n   number.value = Modular<T>::normalize(x); n   return stream; n } n constexpr int md = 998244353; n using Mint = Modular<std::integral_constant<decay<decltype(md)>::type, md>>; n vector<Mint> fact(1, 1); n vector<Mint> inv_fact(1, 1); n Mint C(int n, int k) { n   if (k < 0 || k > n) { n     return 0; n   } n   while ((int)fact.size() < n + 1) { n     fact.push_back(fact.back() * (int)fact.size()); n     inv_fact.push_back(1 / fact.back()); n   } n   return fact[n] * inv_fact[k] * inv_fact[n - k]; n } n template <typename T> n class NTT { n  public: n   using Type = typename decay<decltype(T::value)>::type; n   static Type md; n   static Modular<T> root; n   static int base; n   static int max_base; n   static vector<Modular<T>> roots; n   static vector<int> rev; n   static void clear() { n     root = 0; n     base = 0; n     max_base = 0; n     roots.clear(); n     rev.clear(); n   } n   static void init() { n     md = T::value; n     assert(md >= 3 && md % 2 == 1); n     auto tmp = md - 1; n     max_base = 0; n     while (tmp % 2 == 0) { n       tmp /= 2; n       max_base++; n     } n     root = 2; n     while (power(root, (md - 1) >> 1) == 1) { n       root++; n     } n     assert(power(root, md - 1) == 1); n     root = power(root, (md - 1) >> max_base); n     base = 1; n     rev = {0, 1}; n     roots = {0, 1}; n   } n   static void ensure_base(int nbase) { n     if (md != T::value) { n       clear(); n     } n     if (roots.empty()) { n       init(); n     } n     if (nbase <= base) { n       return; n     } n     assert(nbase <= max_base); n     rev.resize(1 << nbase); n     for (int i = 0; i < (1 << nbase); i++) { n       rev[i] = (rev[i >> 1] >> 1) + ((i & 1) << (nbase - 1)); n     } n     roots.resize(1 << nbase); n     while (base < nbase) { n       Modular<T> z = power(root, 1 << (max_base - 1 - base)); n       for (int i = 1 << (base - 1); i < (1 << base); i++) { n         roots[i << 1] = roots[i]; n         roots[(i << 1) + 1] = roots[i] * z; n       } n       base++; n     } n   } n   static void fft(vector<Modular<T>>& a) { n     int n = (int)a.size(); n     assert((n & (n - 1)) == 0); n     int zeros = __builtin_ctz(n); n     ensure_base(zeros); n     int shift = base - zeros; n     for (int i = 0; i < n; i++) { n       if (i < (rev[i] >> shift)) { n         swap(a[i], a[rev[i] >> shift]); n       } n     } n     for (int k = 1; k < n; k <<= 1) { n       for (int i = 0; i < n; i += 2 * k) { n         for (int j = 0; j < k; j++) { n           Modular<T> x = a[i + j]; n           Modular<T> y = a[i + j + k] * roots[j + k]; n           a[i + j] = x + y; n           a[i + j + k] = x - y; n         } n       } n     } n   } n   static vector<Modular<T>> multiply(vector<Modular<T>> a, n                                      vector<Modular<T>> b) { n     if (a.empty() || b.empty()) { n       return {}; n     } n     int eq = (a == b); n     int need = (int)a.size() + (int)b.size() - 1; n     int nbase = 0; n     while ((1 << nbase) < need) nbase++; n     ensure_base(nbase); n     int sz = 1 << nbase; n     a.resize(sz); n     b.resize(sz); n     fft(a); n     if (eq) n       b = a; n     else n       fft(b); n     Modular<T> inv_sz = 1 / static_cast<Modular<T>>(sz); n     for (int i = 0; i < sz; i++) { n       a[i] *= b[i] * inv_sz; n     } n     reverse(a.begin() + 1, a.end()); n     fft(a); n     a.resize(need); n     return a; n   } n }; n template <typename T> n typename NTT<T>::Type NTT<T>::md; n template <typename T> n Modular<T> NTT<T>::root; n template <typename T> n int NTT<T>::base; n template <typename T> n int NTT<T>::max_base; n template <typename T> n vector<Modular<T>> NTT<T>::roots; n template <typename T> n vector<int> NTT<T>::rev; n template <typename T> n vector<Modular<T>> inverse(const vector<Modular<T>>& a) { n   assert(!a.empty()); n   int n = (int)a.size(); n   vector<Modular<T>> b = {1 / a[0]}; n   while ((int)b.size() < n) { n     vector<Modular<T>> x(a.begin(), a.begin() + min(a.size(), b.size() << 1)); n     x.resize(b.size() << 1); n     b.resize(b.size() << 1); n     vector<Modular<T>> c = b; n     NTT<T>::fft(c); n     NTT<T>::fft(x); n     Modular<T> inv = 1 / static_cast<Modular<T>>((int)x.size()); n     for (int i = 0; i < (int)x.size(); i++) { n       x[i] *= c[i] * inv; n     } n     reverse(x.begin() + 1, x.end()); n     NTT<T>::fft(x); n     rotate(x.begin(), x.begin() + (x.size() >> 1), x.end()); n     fill(x.begin() + (x.size() >> 1), x.end(), 0); n     NTT<T>::fft(x); n     for (int i = 0; i < (int)x.size(); i++) { n       x[i] *= c[i] * inv; n     } n     reverse(x.begin() + 1, x.end()); n     NTT<T>::fft(x); n     for (int i = 0; i < ((int)x.size() >> 1); i++) { n       b[i + ((int)x.size() >> 1)] = -x[i]; n     } n   } n   b.resize(n); n   return b; n } n template <typename T> n vector<Modular<T>> inverse_old(vector<Modular<T>> a) { n   assert(!a.empty()); n   int n = (int)a.size(); n   if (n == 1) { n     return {1 / a[0]}; n   } n   int m = (n + 1) >> 1; n   vector<Modular<T>> b = inverse(vector<Modular<T>>(a.begin(), a.begin() + m)); n   int need = n << 1; n   int nbase = 0; n   while ((1 << nbase) < need) { n     ++nbase; n   } n   NTT<T>::ensure_base(nbase); n   int size = 1 << nbase; n   a.resize(size); n   b.resize(size); n   NTT<T>::fft(a); n   NTT<T>::fft(b); n   Modular<T> inv = 1 / static_cast<Modular<T>>(size); n   for (int i = 0; i < size; ++i) { n     a[i] = (2 - a[i] * b[i]) * b[i] * inv; n   } n   reverse(a.begin() + 1, a.end()); n   NTT<T>::fft(a); n   a.resize(n); n   return a; n } n template <typename T> n vector<Modular<T>> operator*(const vector<Modular<T>>& a, n                              const vector<Modular<T>>& b) { n   if (a.empty() || b.empty()) { n     return {}; n   } n   if (min(a.size(), b.size()) < 150) { n     vector<Modular<T>> c(a.size() + b.size() - 1, 0); n     for (int i = 0; i < (int)a.size(); i++) { n       for (int j = 0; j < (int)b.size(); j++) { n         c[i + j] += a[i] * b[j]; n       } n     } n     return c; n   } n   return NTT<T>::multiply(a, b); n } n template <typename T> n vector<Modular<T>>& operator*=(vector<Modular<T>>& a, n                                const vector<Modular<T>>& b) { n   return a = a * b; n } n class graph { n  public: n   int n; n   vector<vector<int>> adj; n   vector<int> degree; n   vector<pair<int, int>> edge; n   vector<int> depth; n   vector<bool> covered; n   graph(int N) n       : n(N), n         adj(vector<vector<int>>(n)), n         degree(vector<int>(n)), n         depth(vector<int>(n)), n         covered(vector<bool>(n, false)) {} n   void add(int X, int Y) { n     degree[X]++, degree[Y]++; n     edge.emplace_back(X, Y); n     adj[X].push_back(Y); n     adj[Y].push_back(X); n   } n   void dfs(int N) { n     if (covered[N] == true) return; n     covered[N] = true; n     for (int i : adj[N]) { n       if (covered[i] == false) { n         depth[i] = depth[N] + 1; n         dfs(i); n       } n     } n   } n }; n int main() { n   ios::sync_with_stdio(false); n   cin.tie(0); n   string s, t; n   cin >> s >> t; n   int n = s.size(), m = t.size(); n   while (t.size() < s.size()) t +=  z ; n   assert(t.size() == s.size()); n   vector<graph> gr(n - m + 1, graph(6)); n   for (int i = 0; i < 6; i++) { n     for (int j = 0; j < 6; j++) { n       vector<Mint> a(n), b(n); n       for (int k = 0; k < n; k++) { n         if (int(s[k] -  a ) == i) a[k] = 1; n         if (int(t[k] -  a ) == j) b[k] = 1; n       } n       reverse(a.begin(), a.end()); n       for (int k = 0; k < n; k++) a.push_back(0), b.push_back(b[k]); n       a *= b; n       for (int k = 2 * n - 1, cnt = 0; cnt < n - m + 1; k--, cnt++) { n         if (a[k]()) { n           gr[cnt].add(i, j); n         } n       } n     } n   } n   for (int i = 0; i < n - m + 1; i++) { n     int ans = 0; n     for (int j = 0; j < 6; j++) { n       if (gr[i].covered[j] == false) { n         gr[i].dfs(j); n         ans += 1; n       } n     } n     cout << 6 - ans <<    ; n   } n   cout <<   n ; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n long long f[60][110][2]; n long long bin[60], num[60], s, tt; n inline long long rd() { n   long long x = 0; n   char ch = getchar(); n   for (; ch <  0  || ch >  9 ; ch = getchar()) n     ; n   for (; ch >=  0  && ch <=  9 ; ch = getchar()) x = x * 10 + ch -  0 ; n   return x; n } n int main() { n   s = rd(); n   bin[0] = 1; n   for (int i = 1; i <= 51; i++) bin[i] = bin[i - 1] * 2; n   long long ans = 0; n   for (int h = 1; bin[h] - 1 <= s; h++) { n     long long hh = s % (bin[h] - 1); n     for (int j = h - 1; j; j--) n       if (bin[j] - 1 <= hh) hh -= bin[j] - 1; n     ans += (!hh); n   } n   for (int h0 = 1; h0 <= 50; h0++) n     for (int h1 = 1; h1 <= 50; h1++) n       if (bin[h0 + 1] + bin[h1 + 1] - 3 <= s - bin[h1] + 1) { n         long long hh = (s - bin[h1] + 1) % (bin[h0 + 1] + bin[h1 + 1] - 3); n         for (int n = 0; n <= h0 + h1 - 2 && n <= hh; n++) { n           tt = 0; n           long long now = hh + n; n           if (now & 1) continue; n           memset(num, 0, sizeof(num)); n           for (now >>= 1; now; now >>= 1) num[++tt] = now & 1; n           memset(f, 0, sizeof(f)); n           f[0][0][0] = 1; n           for (int i = 1; i <= tt; i++) n             for (int j = 0; j <= n; j++) n               for (int k = 0; k < 2; k++) n                 if (f[i - 1][j][k]) { n                   for (int l1 = 0; l1 < 2; l1++) n                     for (int l2 = 0; l2 < 2; l2++) { n                       if ((i >= h0 && l1) || (i >= h1 && l2)) continue; n                       int hh = l1 + l2 + k, now = j + l1 + l2; n                       if ((hh & 1) == num[i]) n                         f[i][now][hh >> 1] += f[i - 1][j][k]; n                     } n                 } n           ans += f[tt][n][0]; n         } n       } n   printf( %lld n , ans); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int shortestPaths[100][100]; n int graph[100][100]; n void bfs(int start, int n) { n   queue<int> q; n   q.push(start); n   int visited[n]; n   for (int i = 0; i < n; i++) { n     visited[i] = 0; n   } n   visited[start] = 1; n   int dist = 1; n   while (true) { n     int sz = q.size(); n     if (sz == 0) { n       break; n     } n     for (int i = 0; i < sz; i++) { n       int cur = q.front(); n       q.pop(); n       for (int j = 0; j < 100; j++) { n         if (graph[cur][j] == 1 && visited[j] == 0) { n           visited[j] = 1; n           shortestPaths[start][j] = dist; n           q.push(j); n         } n       } n     } n     dist++; n   } n } n int main() { n   ios_base::sync_with_stdio(false); n   int n; n   cin >> n; n   for (int i = 0; i < 100; i++) { n     for (int j = 0; j < 100; j++) { n       shortestPaths[i][j] = 0; n       graph[i][j] = 0; n     } n   } n   for (int i = 0; i < n; i++) { n     string s; n     cin >> s; n     for (int j = 0; j < n; j++) { n       graph[i][j] = (int)(s[j] -  0 ); n     } n   } n   int m; n   cin >> m; n   vector<int> vertices; n   for (int i = 0; i < m; i++) { n     int a; n     cin >> a; n     a--; n     vertices.push_back(a); n   } n   for (int i = 0; i < n; i++) { n     bfs(i, n); n   } n   vector<int> result; n   result.push_back(vertices[0]); n   int last = vertices[0]; n   int ind = 0; n   for (int i = 1; i < m; i++) { n     if (i != 1) { n       if (shortestPaths[last][vertices[i]] < i - ind) { n         result.push_back(vertices[i - 1]); n         ind = i - 1; n         last = vertices[i - 1]; n       } n     } n   } n   result.push_back(vertices[vertices.size() - 1]); n   cout << result.size() << endl; n   for (int i = 0; i < result.size(); i++) { n     cout << result[i] + 1 <<    ; n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int maxn = 111111; n long long tree[maxn * 4]; n void Insert(int o, int l, int r, int k, int v) { n   if (l == r) { n     tree[o] = v; n     return; n   } n   int mid = (l + r) >> 1; n   if (k <= mid) n     Insert(o * 2, l, mid, k, v); n   else n     Insert(o * 2 + 1, mid + 1, r, k, v); n   tree[o] = tree[o * 2] + tree[o * 2 + 1]; n } n long long Query(int o, int l, int r, int L, int R) { n   if (L <= l && r <= R) return tree[o]; n   int mid = (l + r) >> 1; n   long double ans = 0; n   if (L <= mid) ans += Query(o * 2, l, mid, L, R); n   if (R > mid) ans += Query(o * 2 + 1, mid + 1, r, L, R); n   return ans; n } n int n, x, a[maxn], f[maxn]; n int main() { n   cin >> n; n   long double ans = 0; n   for (int i = 1; i <= n; i++) cin >> a[i], f[a[i]] = i; n   for (int i = 1; i <= n; i++) { n     ans += Query(1, 1, n, a[i], n); n     Insert(1, 1, n, a[i], 1); n   } n   ans *= ((long long)n * (n + 1)); n   memset(tree, 0, sizeof(tree)); n   long long last = 0; n   for (int i = 1; i <= n; i++) { n     ans -= (last + Query(1, 1, n, a[i], n)); n     last = last + Query(1, 1, n, a[i], n); n     Insert(1, 1, n, a[i], f[a[i]] * 2); n   } n   for (int i = 1; i <= n; i++) n     ans += ((long long)(n - i + 1) * i * (i - 1) / 2); n   ans /= ((long long)n * (n + 1)); n   cout << setprecision(15) << ans << endl; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int a[200001][22]; n int p[200001]; n int d[200001]; n int lca(int u, int v) { n   if (d[u] < d[v]) swap(u, v); n   int k = d[u] - d[v]; n   while (k > 0) { n     int t = log2(k); n     k -= (1 << t); n     u = a[u][t]; n   } n   if (u == v) return v; n   for (int i = 20; i >= 0; i--) { n     if (a[u][i] != a[v][i]) u = a[u][i], v = a[v][i]; n   } n   return p[v]; n } n int orobitiasvla(int x, int v) { n   while (x > 0) { n     int t = log2(x); n     v = a[v][t]; n     x -= (1 << t); n   } n   return v; n } n int main() { n   int n; n   cin >> n; n   int cnt = 2; n   for (int i = 1; i <= n; i++) { n     for (int j = 0; j <= 20; j++) a[i][j] = -1; n   } n   d[1] = 0; n   int d1 = 1, d2 = 1; n   int mx = 0; n   n--; n   while (n--) { n     int k; n     cin >> k; n     a[cnt][0] = k; n     p[cnt] = k; n     d[cnt] = d[k] + 1; n     for (int i = 1; i <= 20; i++) n       if (d[cnt] >= (1 << i)) a[cnt][i] = orobitiasvla((1 << i) - 1, k); n     int y = lca(cnt, d1); n     int cost = d[cnt] - d[y] + d[d1] - d[y]; n     y = lca(cnt, d2); n     int cost1 = d[cnt] - d[y] + d[d2] - d[y]; n     if (cost1 > mx || cost > mx) { n       if (cost > cost1) n         d2 = cnt; n       else n         d1 = cnt; n       mx = max(cost, cost1); n     } n     cout << mx <<    ; n     cnt++; n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int N = 6e5 + 7; n int a, b, n, ans; n int main() { n   ios::sync_with_stdio(false); n   cin.tie(0), cout.tie(0); n   cin >> a >> b, n = a + b; n   for (int l = 1, r, s; l <= n; l = r + 1) { n     s = n / l, r = n / s; n     int al = (a + s) / (s + 1), ar = a / s, bl = (b + s) / (s + 1), br = b / s; n     if (al <= ar && bl <= br) ans += min(ar + br, r) - max(al + bl, l) + 1; n   } n   cout << ans << endl; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n long long n, a, b, c, d, s, len; n vector<long long> z, t, v[2]; n map<long long, int> ma; n int main() { n   ios_base::sync_with_stdio(false); n   cin >> n >> a >> b >> c >> d >> s >> len; n   t.assign(n + 1, -1); n   v[0].assign(n + 1, s); n   v[1].assign(n + 1, s); n   for (int i = 0; i < n; ++i) { n     int q; n     cin >> t[i + 1] >> q; n     v[0][i + 1] = v[0][i] + (q ? a : -b); n     v[1][i + 1] = v[1][i] + (q ? c : -d); n   } n   int lim = 0; n   ++ma[v[1][0]]; n   for (int i = 0; i < n + 1; ++i) { n     if (v[0][i] < 0) break; n     if (!(--ma[v[1][i]])) ma.erase(v[1][i]); n     int be = t[i] + 1; n     while (lim < n + 1 && t[lim] < be + len) { n       ++ma[v[1][lim]]; n       ++lim; n     } n     if (i + 1 == lim || v[0][i] - v[1][i] + ma.begin()->first >= 0) { n       cout << be << endl; n       return 0; n     } n   } n   cout << -1 << endl; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int main() { n   int A[100], L[100], n, m; n   cin >> n >> m; n   for (int i = 0; i < n; ++i) cin >> A[i], A[i]--; n   for (int i = 0; i < m; ++i) cin >> L[i]; n   for (int i = 0; i < n; ++i) { n     for (int j = i + 1; j <= n; ++j) { n       vector<int> cnt(m + 1, 0); n       for (int k = i; k < j; ++k) cnt[A[k]]++; n       bool fl = true; n       for (int k = 0; k < m; ++k) fl &= (L[k] == cnt[k]); n       if (fl) { n         cout <<  YES n ; n         return 0; n       } n     } n   } n   cout <<  NO n ; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int n, k, b[1000010]; n int main() { n   scanf( %d%d , &n, &k); n   int i; n   if (k * 3 > n || k == 1) n     puts( -1 ); n   else { n     for (i = 1; i <= (int)(k); ++i) b[i] = b[i + 2 * k] = i, b[i + k] = i - 1; n     b[k + 1] = k; n     for (i = 3 * k + 1; i <= n; ++i) b[i] = 1; n     for (i = 1; i <= (int)(n); ++i) printf( %d  , b[i]); n     puts(  ); n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n long long a[9][5], b[8]; n long long dis(int i, int j) { n   long long x = a[i][0] - a[j][0], y = a[i][1] - a[j][1], z = a[i][2] - a[j][2]; n   return x * x + y * y + z * z; n } n bool check() { n   for (int i = 0; i < 8; i++) { n     for (int j = 0; j < 8; j++) { n       if (i == j) continue; n       if (j < i) n         b[j] = dis(i, j); n       else n         b[j - 1] = dis(i, j); n     } n     sort(b, b + 7); n     long long t1 = b[0], t2 = 2 * b[0], t3 = 3 * b[0]; n     if (t1 == 0 || t1 != b[1] || t1 != b[2] || t2 != b[3] || t2 != b[4] || n         t2 != b[5] || t3 != b[6]) n       return false; n   } n   return true; n } n bool is_ok(int cur) { n   if (cur == 8) { n     return check(); n   } n   sort(a[cur], a[cur] + 3); n   do { n     if (is_ok(cur + 1)) return true; n   } while (next_permutation(a[cur], a[cur] + 3)); n   return false; n } n int main() { n   for (int i = 0; i < 8; i++) cin >> a[i][0] >> a[i][1] >> a[i][2]; n   if (!is_ok(0)) n     puts( NO ); n   else { n     puts( YES ); n     for (int i = 0; i < 8; i++) n       for (int j = 0; j < 3; j++) { n         cout << a[i][j] <<    ; n         if (j == 2) cout << endl; n       } n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int constexpr nax = 3e5 + 5; n using ll = int64_t; n const int INF = 1e9; n template <typename T> n struct fenwick { n   T bit[nax]; n   fenwick() { memset(bit, 0, sizeof(bit)); } n   void update(int x, T val) { n     for (; x < nax; x += x & -x) bit[x] += val; n   } n   T get(int x) { n     int res = 0; n     for (; x > 0; x -= x & -x) res += bit[x]; n     return res; n   } n   T get(int l, int r) { return get(r) - get(l - 1); } n }; n struct segtree { n   static constexpr int Mx = 4 * nax; n   ll sg[Mx] = {}, tag[Mx] = {}; n   inline void pull(int v) { sg[v] = min(sg[v * 2], sg[v * 2 + 1]); } n   segtree() { n     fill(sg, sg + Mx, INF); n     fill(tag, tag + Mx, 0); n   } n   inline void push(int v) { n     if (v * 2 + 1 < Mx && tag[v]) { n       sg[v * 2] += tag[v]; n       sg[v * 2 + 1] += tag[v]; n       tag[v * 2] += tag[v]; n       tag[v * 2 + 1] += tag[v]; n     } n     tag[v] = 0; n   } n   inline void update(int v, int x, int y, int l, int r, ll val) { n     push(v); n     if (l > r) return; n     if (l == x && r == y) { n       sg[v] += val; n       tag[v] += val; n       return push(v); n     } n     int mid = x + y >> 1; n     update(v * 2, x, mid, l, min(r, mid), val); n     update(v * 2 + 1, mid + 1, y, max(l, mid + 1), r, val); n     pull(v); n   } n   int find_first_neg(int v, int x, int y) { n     push(v); n     if (x == y) { n       assert(sg[v] <= 0); n       return x; n     } else { n       int mid = x + y >> 1; n       if (sg[v * 2] <= 0) n         return find_first_neg(v * 2, x, mid); n       else n         return find_first_neg(v * 2 + 1, mid + 1, y); n     } n   } n }; n segtree sg; n fenwick<int> sum; n int n, nq; n int ans[nax]; n int b[nax]; n vector<pair<int, int>> q[nax]; n int main() { n   cin.tie(0)->sync_with_stdio(false); n   cin >> n >> nq; n   for (int i = 1; i <= n; ++i) { n     cin >> b[i]; n     b[i] = i < b[i] ? INF : i - b[i]; n   } n   for (int i = 1; i <= nq; ++i) { n     int x, y; n     cin >> x >> y; n     q[x + 1].emplace_back(n - y, i); n   } n   for (int i = n; i >= 1; --i) { n     sg.update(1, 1, n, i, i, (ll)b[i] - INF); n     while (sg.sg[1] <= 0) { n       int v = sg.find_first_neg(1, 1, n); n       sum.update(v, 1); n       sg.update(1, 1, n, v, v, INF); n       sg.update(1, 1, n, v, n, -1); n     } n     for (const auto &[r, id] : q[i]) ans[id] = sum.get(i, r); n   } n   for (int i = 1; i <= nq; ++i) { n     cout << ans[i] <<   n ; n   } n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int inf = 1e9 + 239; n int n, m, k; n vector<set<int>> row; n vector<set<int>> column; n vector<set<int>> row_free; n vector<set<int>> column_free; n int get_row_left(int i, int to, int from) { n   auto it = row[i].lower_bound(from); n   if (it == row[i].begin()) { n     return to; n   } n   it--; n   if (to <= *(it) && *(it) <= from) { n     return *(it) + 1; n   } else { n     return to; n   } n } n int get_row_right(int i, int to, int from) { n   auto it = row[i].lower_bound(from); n   if (it == row[i].end()) { n     return to; n   } n   if ((*it) <= to) { n     return (*it) - 1; n   } else { n     return to; n   } n } n int get_column_up(int j, int to, int from) { n   auto it = column[j].lower_bound(from); n   if (it == column[j].begin()) { n     return to; n   } n   it--; n   if (to <= *(it) && *(it) <= from) { n     return *(it) + 1; n   } else { n     return to; n   } n } n int get_column_down(int j, int to, int from) { n   auto it = column[j].lower_bound(from); n   if (it == column[j].end()) { n     return to; n   } n   if ((*it) <= to) { n     return (*it) - 1; n   } else { n     return to; n   } n } n vector<pair<int, int>> all_next(int i, int j) { n   int ff = get_row_left(i, max(0, j - k), j); n   int ss = get_row_right(i, min(m - 1, j + k), j); n   int tt = get_column_up(j, max(0, i - k), i); n   int th = get_column_down(j, min(n - 1, i + k), i); n   vector<pair<int, int>> ans; n   if (j > 0) { n     auto it = row_free[i].lower_bound(ff); n     while (true) { n       if (it == row_free[i].end()) { n         break; n       } n       if (*(it) >= j) { n         break; n       } n       ans.push_back({i, *(it)}); n       it++; n     } n   } n   if (j + 1 < m) { n     auto it = row_free[i].upper_bound(j); n     while (true) { n       if (it == row_free[i].end()) { n         break; n       } n       if (*(it) > ss) { n         break; n       } n       ans.push_back({i, *(it)}); n       it++; n     } n   } n   if (i > 0) { n     auto it = column_free[j].lower_bound(tt); n     while (true) { n       if (it == column_free[j].end()) { n         break; n       } n       if (*(it) >= i) { n         break; n       } n       ans.push_back({*(it), j}); n       it++; n     } n   } n   if (i + 1 < n) { n     auto it = column_free[j].upper_bound(i); n     while (true) { n       if (it == column_free[j].end()) { n         break; n       } n       if (*(it) > th) { n         break; n       } n       ans.push_back({*(it), j}); n       it++; n     } n   } n   return ans; n } n void bfs(int si, int sj, int ei, int ej) { n   vector<vector<int>> d(n, vector<int>(m, inf)); n   d[si][sj] = 0; n   queue<pair<int, int>> q; n   q.push({si, sj}); n   row_free[si].erase(sj); n   column_free[sj].erase(si); n   while (!q.empty()) { n     auto tmp = q.front(); n     q.pop(); n     int ci = tmp.first; n     int cj = tmp.second; n     auto next = all_next(ci, cj); n     for (auto [ni, nj] : next) { n       if (d[ni][nj] > d[ci][cj] + 1) { n         d[ni][nj] = d[ci][cj] + 1; n         row_free[ni].erase(nj); n         column_free[nj].erase(ni); n         q.push({ni, nj}); n       } n     } n   } n   int res = d[ei][ej]; n   if (res == inf) { n     cout << -1; n   } else { n     cout << res; n   } n } n signed main() { n   ios_base::sync_with_stdio(false); n   cin.tie(0); n   cin >> n >> m >> k; n   row.resize(n); n   column.resize(m); n   row_free.resize(n); n   column_free.resize(m); n   for (int i = 0; i < n; i++) { n     for (int j = 0; j < m; j++) { n       char c; n       cin >> c; n       if (c ==  # ) { n         row[i].insert(j); n         column[j].insert(i); n       } else { n         row_free[i].insert(j); n         column_free[j].insert(i); n       } n     } n   } n   int si, sj, ei, ej; n   cin >> si >> sj >> ei >> ej; n   si--; n   sj--; n   ei--; n   ej--; n   bfs(si, sj, ei, ej); n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n string s, t; n int dp[5005][5005]; n int get(int i, int j) { n   if (dp[i][j] != -1) return dp[i][j]; n   if (i >= s.size() or j >= t.size()) return 0; n   int ret = get(i, j + 1); n   if (s[i] == t[j]) ret = (ret + 1 + get(i + 1, j + 1)) % 1000000007; n   return dp[i][j] = ret; n   ; n } n int main() { n   for (int i = 0; i < 5005; ++i) n     for (int j = 0; j < 5005; ++j) dp[i][j] = -1; n   cin >> s >> t; n   long long ret = 0; n   for (int i = 0; i < s.size(); ++i) ret = (ret + get(i, 0)) % 1000000007; n   cout << ret << endl; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n long long t, n, k; n long long f(long long x) { n   if (x == 0) return k * (k + 1) / 2; n   long long t = x % k, val = f(x / k), ofs = 0; n   if (val < k * t + 2) { n     ofs = k; n   } else if ((t + 1) * k < val) { n     ofs = 0; n   } else { n     ofs = (t + 1) * k - val + 1; n   } n   return k * (k + 1) / 2 - t + ofs; n } n long long rjesi(long long x) { n   long long buk = (x - 1) / (k * k + 1); n   long long pos = (k * k + 1) * buk + f(buk); n   if (x != pos) { n     long long lef = buk + (pos < x); n     return (x - 1 - lef) / k - lef + x; n   } else { n     long long t = buk % k, val = f(buk / k); n     if ((t + 1) * k < val) { n       return rjesi(buk / k * (k * k + 1) + (t + 1) * k) + 1; n     } else { n       return rjesi(buk / k * (k * k + 1) + (t + 1) * k + 1) + 1; n     } n   } n } n int main() { n   cin >> t; n   while (t--) { n     cin >> n >> k; n     cout << rjesi(n) <<   n ; n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int maxn = 305; n long long dp[maxn][maxn][6]; n int n, x[maxn], y[maxn]; n vector<pair<double, pair<int, int>>> seg; n int main() { n   ios_base::sync_with_stdio(0); n   cin >> n; n   for (int i = 0; i < n; i++) cin >> x[i] >> y[i]; n   for (int i = 0; i < n; i++) { n     for (int j = 0; j < n; j++) { n       for (int k = 0; k < 6; k++) dp[i][j][k] = 0; n       if (i == j) dp[i][j][0] = 1; n     } n   } n   for (int i = 0; i < n; i++) { n     for (int j = 0; j < n; j++) { n       if (i != j) { n         int xx = x[j] - x[i], yy = y[j] - y[i]; n         seg.push_back({atan2(xx, yy), {i, j}}); n       } n     } n   } n   sort(seg.begin(), seg.end()); n   int m = seg.size(); n   for (int cc = 0; cc < m; cc++) { n     int i = seg[cc].second.first, j = seg[cc].second.second; n     for (int k = 0; k < n; k++) n       for (int f = 0; f < 5; f++) dp[k][i][f + 1] += dp[k][j][f]; n   } n   long long ret = 0; n   for (int i = 0; i < n; i++) ret += dp[i][i][5]; n   cout << ret << endl; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int main() { n   ios::sync_with_stdio(false); n   cin.tie(0); n   int n; n   cin >> n; n   if ((n & (n - 1)) == 0) { n     cout << 0 <<   n ; n   } else { n     int k = 0; n     while ((1 << k + 1) <= n) { n       k++; n     } n     n ^= 1 << k; n     int ans = 0; n     for (int i = 0; i < k; ++i) { n       int j = i + 1; n       if (j >= k) { n         j -= k; n       } n       if (n & (1 << j)) { n         ans |= 1 << i; n       } n     } n     cout << ans <<   n ; n   } n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n bool isprime(int n) { n   if (n == 2) return 1; n   for (int i = 2; i < n; i++) { n     if (n % i == 0) return 0; n   } n   return 1; n } n int main() { n   int n, m; n   cin >> n >> m; n   int flag = 1; n   if (isprime(n) && isprime(m)) { n     for (int i = n + 1; i < m; i++) { n       if (isprime(i)) { n         cout <<  NO  << endl; n         flag = 0; n         break; n       } n     } n     if (flag) cout <<  YES  << endl; n   } else { n     cout <<  NO  << endl; n   } n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n const int N = 200000 + 10; n int a[N], n, K; n int main() { n   scanf( %d%d , &n, &K); n   for (int i = 0; i < n; ++i) scanf( %d , &a[i]); n   long long pre = 0; n   int tot = n - 1, id = 0; n   for (int i = 0; i < n; ++i) { n     long long d = pre - (long long)a[i] * (tot - id) * id; n     if (d < K) { n       printf( %d n , i + 1); n       --tot; n     } else { n       pre = pre + (long long)a[i] * id; n       ++id; n     } n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int a[105][105], t, m, n, ret, cnt, mn; n int main(void) { n   cin >> t; n   for (int i = 0; i < t; i++) { n     ret = 0, cnt = 0, mn = 101; n     cin >> n >> m; n     for (int j = 0; j < n; j++) { n       for (int k = 0; k < m; k++) { n         cin >> a[j][k]; n         if (a[j][k] <= 0) cnt++; n         if (abs(a[j][k]) < mn) mn = abs(a[j][k]); n       } n     } n     for (int j = 0; j < n; j++) { n       for (int k = 0; k < m; k++) { n         ret += abs(a[j][k]); n       } n     } n     if (cnt % 2 == 1) ret -= 2 * mn; n     cout << ret << endl; n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int MAX = 510; n int n, m; n double xa, ya, x2, y2; n double v, vx1, vx2, vy1, vy2, t; n int check(double k) { n   double x, y; n   x = xa + vx1 * min(k, t) + vx2 * max(0.0, k - t); n   y = ya + vy1 * min(k, t) + vy2 * max(0.0, k - t); n   double dist = sqrt((x - x2) * (x - x2) + (y - y2) * (y - y2)); n   if (v * k >= dist) return 1; n   return 0; n } n int main() { n   int i, j, k; n   while (~scanf( %lf%lf%lf%lf , &xa, &ya, &x2, &y2)) { n     scanf( %lf%lf , &v, &t); n     scanf( %lf%lf , &vx1, &vy1); n     scanf( %lf%lf , &vx2, &vy2); n     double l = 0.0, r = 1e9; n     while ((r - l) > 1e-6) { n       double mid = (l + r) / 2; n       if (check(mid)) n         r = mid; n       else n         l = mid; n     } n     printf( %.10lf n , l); n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int main() { n   int n, x, sum = 0, q; n   vector<int> v; n   vector<int>::iterator it; n   scanf( %d , &n); n   while (n--) { n     scanf( %d , &x); n     sum += x; n     v.push_back(sum); n   } n   int sz = v.size(); n   scanf( %d , &q); n   while (q--) { n     scanf( %d , &x); n     it = lower_bound(v.begin(), v.end(), x); n     printf( %d n , (it - v.begin()) + 1); n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int a[3005]; n int main() { n   int n; n   int cnt = 0; n   scanf( %d , &n); n   for (int i = 0; i < n; i++) { n     scanf( %d , &a[i]); n   } n   for (int i = 0; i < n; i++) { n     for (int j = i + 1; j < n; j++) { n       if (a[i] > a[j]) cnt++; n     } n   } n   if (cnt % 2 == 0) n     printf( %.6f , cnt * 2.0); n   else n     printf( %.6f , cnt * 2.0 - 1); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int main() { n   long long n; n   cin >> n; n   long long r = n % 3; n   if (r != 2) n     cout << 1ll <<     << 1ll <<     << n - 2 << endl; n   else n     cout << 1ll <<     << 2ll <<     << n - 3 << endl; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n #pragma GCC optimize( Ofast,unroll-loops ) n #pragma GCC target( avx,avx2,fma ) n using namespace std; n template <typename T> n using vc = vector<T>; n template <typename T> n using uset = unordered_set<T>; n template <typename A, typename B> n using umap = unordered_map<A, B>; n template <typename T, typename Comp = less<T>> n using pq = priority_queue<T, vc<T>, Comp>; n template <typename T> n using minpq = pq<T, greater<T>>; n using ld = long double; n using ll = long long; n using ull = unsigned long long; n using pii = pair<int, int>; n using ppi = pair<pii, int>; n using pip = pair<int, pii>; n using vi = vc<int>; n using vii = vc<pii>; n constexpr char el =   n ; n constexpr char sp =    ; n constexpr int INF = 0x3f3f3f3f; n constexpr ll LLINF = 0x3f3f3f3f3f3f3f3fLL; n char g[8][8]; n int dr[] = {-1, -1, -1, 0, 0, 0, 1, 1, 1}; n int dc[] = {-1, 0, 1, -1, 0, 1, -1, 0, 1}; n vi a[8][8]; n bool good(int r, int c) { return 0 <= r && r < 8 && 0 <= c && c < 8; } n signed main() { n   ios_base::sync_with_stdio(false); n   cin.tie(nullptr); n   cout << fixed; n   for (auto& x : g) n     for (auto& y : x) cin >> y; n   for (int i = 0; i < 8; ++i) n     for (int j = 0; j < 8; ++j) n       if (g[i][j] ==  S ) n         for (int k = i; k < 8; ++k) a[k][j].push_back(k - i); n   for (auto& x : a) n     for (auto& y : x) sort(y.begin(), y.end()); n   queue<tuple<int, int, int>> q; n   q.emplace(7, 0, 0); n   while (!q.empty()) { n     auto [r, c, d] = q.front(); n     q.pop(); n     for (int i = 0; i < 9; ++i) { n       int r1 = r + dr[i]; n       int c1 = c + dc[i]; n       if (r1 == 0 && c1 == 7) { n         cout <<  WIN ; n         exit(0); n       } n       if (!good(r1, c1) || binary_search(begin(a[r1][c1]), end(a[r1][c1]), d) || n           binary_search(begin(a[r1][c1]), end(a[r1][c1]), d + 1)) n         continue; n       q.emplace(r1, c1, d + 1); n     } n   } n   cout <<  LOSE ; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n   n using namespace std; n   n #define SPEED ios::sync_with_stdio(false); cin.tie(0); cout.tie(0) n #define fileio freopen( in.in ,  r , stdin),freopen( out.out ,  w , stdout); n #define ll long long n #define int long long n #define FF first n #define SS second n #define mp make_pair n #define pb push_back n #define pii pair<ll,ll> n #define pll pair<long long,long long> n #define sd(x) scanf( %d ,&x) n #define slld(x) scanf( %lld ,&x) n #define pd(x) prllf( %d n ,x) n #define plld(x) prllf( %lld n ,x) n #define pss prllf n #define MOD 1000000007 n #define eps 0.00001 n #define endl   n  n #define debug(n1) cout<<n1<<endl n ll n,k,s[1005],e[1005],c[1005]; n bool y[1005]; n const ll INF = 1e17+5; n int mm[100005]; n vector<int>temp[100005]; n  n struct MinimumCostMaximumFlow { n   typedef ll Index; typedef ll Flow; typedef ll Cost; n   static const Flow InfCapacity = INF; n   struct Edge { n     Index to; Index rev; n     Flow capacity; Cost cost; n   }; n   vector<vector<Edge> > g; n   void init(Index n) { g.assign(n, vector<Edge>()); } n   void addEdge(bool inv,Index i, Index j, Flow capacity = InfCapacity, Cost cost = Cost() ) { n     Edge e, f; e.to = j, f.to = i; e.capacity = capacity, f.capacity = 0; e.cost = cost, f.cost = -cost; n     if(inv) n     { n         temp[i].push_back(mm[i]); n     } n     mm[i]++; n     mm[j]++; n  n     g[i].push_back(e); g[j].push_back(f); n     g[i].back().rev = (Index)g[j].size() - 1; g[j].back().rev = (Index)g[i].size() - 1; n   } n   void addB(Index i, Index j, Flow capacity = InfCapacity, Cost cost = Cost()) { n     addEdge(0,i, j, capacity, cost); n     addEdge(0,j, i, capacity, cost); n   } n  n   pair<Cost, Flow> minimumCostMaximumFlow(Index s, Index t, Flow f = InfCapacity, bool useSPFA = false) { n     ll n = g.size(); n     vector<Cost> dist(n); vector<Index> prev(n); vector<Index> prevEdge(n); n     pair<Cost, Flow> total = make_pair(0, 0); n     vector<Cost> potential(n); n     while(f > 0) { n       fill(dist.begin(), dist.end(), INF); n       if(useSPFA || total.second == 0) { n         deque<Index> q; n         q.push_back(s); dist[s] = 0; vector<bool> inqueue(n); n         while(!q.empty()) { n           Index i = q.front(); q.pop_front(); inqueue[i] = false; n           for(Index ei = 0; ei < (Index)g[i].size(); ei ++) { n             const Edge &e = g[i][ei]; Index j = e.to; Cost d = dist[i] + e.cost; n             if(e.capacity > 0 && d < dist[j]) { n               if(!inqueue[j]) { n                 inqueue[j] = true; n                 q.push_back(j); n               } n               dist[j] = d; prev[j] = i; prevEdge[j] = ei; n             } n           } n         } n       } else { n         vector<bool> vis(n); n         priority_queue<pair<Cost, Index> > q; n         q.push(make_pair(-0, s)); dist[s] = 0; n         while(!q.empty()) { n           Index i = q.top().second; q.pop(); n           if(vis[i]) continue; n           vis[i] = true; n           for(Index ei = 0; ei < (Index)g[i].size(); ei ++) { n             const Edge &e = g[i][ei]; n             if(e.capacity <= 0) continue; n             Index j = e.to; Cost d = dist[i] + e.cost + potential[i] - potential[j]; n             if(dist[j] > d) { n               dist[j] = d; prev[j] = i; prevEdge[j] = ei; n               q.push(make_pair(-d, j)); n             } n           } n         } n       } n       if(dist[t] == INF) break; n       if(!useSPFA) for(Index i = 0; i < n; i ++) potential[i] += dist[i]; n   n       Flow d = f; Cost distt = 0; n       for(Index v = t; v != s; ) { n         Index u = prev[v]; const Edge &e = g[u][prevEdge[v]]; n         d = min(d, e.capacity); distt += e.cost; v = u; n       } n       f -= d; total.first += d * distt; total.second += d; n       for(Index v = t; v != s; v = prev[v]) { n         Edge &e = g[prev[v]][prevEdge[v]]; n         e.capacity -= d; g[e.to][e.rev].capacity += d; n       } n     } n     return total; n   } n }; n   n  n int find_num(string ss) n { n     int ans=0; n     int tt=1; n     reverse(ss.begin(),ss.end()); n  n     for(auto i:ss) n     { n         ans+=(i- 0 )*tt; n         tt*=2; n     } n     return ans; n } n  n  n  n vector<vector<int> >adj; n int sz[1000005]; n int vis[1000005]; n int a[100005]; n vector<string>fi; n int d; n  n void print(int yy) n { n     for(int i=0;i<10;i++) n     { n         if(((1<<i)&yy)) n         { n             fi.push_back(to_string(d-i-1)); n         } n     } n } n  n void dfs(int ver,int x) n { n     vis[ver]=1; n     print(a[ver]^x); n     int cnt=0; n  n  n     for(auto i:adj[ver]) n     { n         if(vis[i]==0) n         { n             if(cnt) n             { n                 fi.push_back( R ); n                 print(a[ver]); n                 dfs(i,a[ver]); n             } n             else n             { n                 dfs(i,a[ver]); n             } n             cnt++; n         } n     } n } n  n signed main() n { n   n ios_base::sync_with_stdio(false);  n cin.tie(NULL);   n cout.tie(0);    n   n #ifndef ONLINE_JUDGE n     if(fopen( INPUT.txt , r )) n     { n         freopen( INPUT.txt , r ,stdin); n         freopen( OUTPUT.txt , w ,stdout); n     } n  n #endif           n  n     int n; n     cin>>d>>n; n     string se[n]; n     for(int i=0;i<n;i++) n     { n         cin>>se[i]; n         a[i+1]=find_num(se[i]); n     } n  n     adj.resize(n+1); n  n     MinimumCostMaximumFlow kad; n     int source=0; n     int sink=2*n+5; n  n     kad.init(2*n+10); n  n     for(int i=1;i<=n;i++) n     { n         for(int j=1;j<=n;j++) n         { n             if(i!=j) n             { n                 if((a[i]&a[j])==a[j]) n                 { n                     kad.addEdge(1,n+j,i,1,-(__builtin_popcount(a[j])+1)); n                 } n             } n         } n  n         kad.addEdge(0,i,n+i,1,0); n         kad.addEdge(0,source,i,1,0); n         kad.addEdge(0,n+i,sink,1,-(__builtin_popcount(a[i])+1)); n     } n  n     kad.addEdge(0,source,sink,n,0); n  n     pair<int,int> ans=kad.minimumCostMaximumFlow(source,sink,n,0); n  n     for(int i=n+1;i<=2*n;i++) n     { n         for(auto j:temp[i]) n         { n             if(kad.g[i][j].capacity==0) n             { n                 adj[i-n].push_back(kad.g[i][j].to); n             } n         } n     } n  n     set<pair<int,int> >ss; n     int cc=0; n     for(int i=1;i<=n;i++) n     { n         ss.insert({a[i],i}); n     } n  n     while(!ss.empty()) n     { n         auto j=ss.begin(); n         if(vis[j->second]) n         { n             ss.erase(j); n             continue; n         } n         if(cc) n             fi.push_back( R ); n         cc++; n         dfs(j->second,0); n     } n  n     cout<<fi.size()<<  n ; n     for(auto i:fi) n         cout<<i<<   ; n  n  n  n }"}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n namespace INIT { n char buf[1 << 15], *fs, *ft; n inline char getc() { n   return (fs == ft && n           (ft = (fs = buf) + fread(buf, 1, 1 << 15, stdin), fs == ft)) n              ? 0 n              : *fs++; n } n inline int read() { n   int x = 0, f = 1; n   char ch = getc(); n   while (!isdigit(ch)) { n     if (ch ==  - ) f = -1; n     ch = getc(); n   } n   while (isdigit(ch)) { n     x = x * 10 + ch -  0 ; n     ch = getc(); n   } n   return x * f; n } n }  // namespace INIT n using namespace INIT; n int n, p[1000010], vis[1000010], ans[1000010]; n vector<int> a[1000010], b[1000010]; n int main() { n   n = read(); n   for (int i = 1; i <= n; ++i) p[i] = read(); n   for (int i = 1; i <= n; ++i) { n     int num = 0; n     for (int j = i; !vis[j]; j = p[j]) vis[j] = 1, ++num, a[i].push_back(j); n     b[num].push_back(i); n   } n   for (int i = 1; i <= n; ++i) n     if (i % 2 == 0 && (b[i].size() & 1)) { n       puts( -1 ); n       return 0; n     } n   memset(vis, 0, sizeof(vis)); n   for (int i = 0; i <= (int)b[1].size() - 1; ++i) ans[b[1][i]] = b[1][i]; n   for (int i = 2; i <= n; ++i) n     for (int j = 0; j <= (int)b[i].size() - 1; ++j) { n       if (i & 1) { n         int x = a[b[i][j]][0], y = a[b[i][j]][i / 2 + 1]; n         while (!vis[x]) { n           vis[x] = vis[y] = 1; n           ans[x] = y; n           x = p[x]; n           ans[y] = x; n           y = p[y]; n         } n       } else { n         int x = a[b[i][j]][0], y = a[b[i][j + 1]][0]; n         while (!vis[x] && !vis[y]) { n           vis[x] = vis[y] = 1; n           ans[x] = y; n           x = p[x]; n           ans[y] = x; n           y = p[y]; n         } n         j++; n       } n     } n   for (int i = 1; i <= n; ++i) printf( %d  , ans[i]); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int MAXN = 100010; n const int MAXM = 20010; n const int MAXNODE = 16 * MAXN; n const int LOGMAXN = 50; n const int INF = 0x3f3f3f3f; n const double eps = 1e-9; n int N, M; n int b[MAXM], z[MAXM], x[3 * (MAXN + MAXM)]; n struct Tree { n   int x, h; n   double l, r; n } a[MAXN]; n struct SegmentTree { n   double mul[MAXNODE]; n   void build(int o, int L, int R) { n     mul[o] = 1; n     if (L >= R) return; n     int mid = L + (R - L) / 2; n     build(o << 1, L, mid); n     build(o << 1 | 1, mid + 1, R); n   } n   void pushdown(int o) { n     mul[o << 1] *= mul[o]; n     mul[o << 1 | 1] *= mul[o]; n     mul[o] = 1; n   } n   void update(int o, int L, int R, int ql, int qr, double p) { n     if (ql <= L && qr >= R) { n       mul[o] *= p; n       return; n     } n     pushdown(o); n     int mid = L + (R - L) / 2; n     if (ql <= mid) update(o << 1, L, mid, ql, qr, p); n     if (qr > mid) update(o << 1 | 1, mid + 1, R, ql, qr, p); n   } n   double query(int o, int L, int R, int pos) { n     if (L >= R) return mul[o]; n     pushdown(o); n     int mid = L + (R - L) / 2; n     double ans; n     if (pos <= mid) n       ans = query(o << 1, L, mid, pos); n     else n       ans = query(o << 1 | 1, mid + 1, R, pos); n     return ans; n   } n } tree; n int main() { n   while (scanf( %d%d , &N, &M) != EOF) { n     int k = 0; n     for (int i = 0; i < N; i++) { n       scanf( %d%d%lf%lf , &a[i].x, &a[i].h, &a[i].l, &a[i].r); n       a[i].l /= 100; n       a[i].r /= 100; n       x[k++] = a[i].x; n       x[k++] = a[i].x - a[i].h; n       x[k++] = a[i].x + a[i].h; n     } n     for (int i = 0; i < M; i++) { n       scanf( %d%d , &b[i], &z[i]); n       x[k++] = b[i]; n     } n     sort(x, x + k); n     k = unique(x, x + k) - x; n     tree.build(1, 1, k); n     for (int i = 0; i < N; i++) { n       int qm = lower_bound(x, x + k, a[i].x) - x + 1; n       int ql = lower_bound(x, x + k, a[i].x - a[i].h) - x + 1, n           qr = lower_bound(x, x + k, a[i].x + a[i].h) - x + 1; n       tree.update(1, 1, k, ql, qm - 1, (1 - a[i].l)); n       tree.update(1, 1, k, qm + 1, qr, (1 - a[i].r)); n     } n     double ans = 0; n     for (int i = 0; i < M; i++) { n       int pos = lower_bound(x, x + k, b[i]) - x + 1; n       ans += z[i] * tree.query(1, 1, k, pos); n     } n     printf( %.10lf n , ans); n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n const int N = 502; n void sw(float* x) { n   float tmp = *x; n   *x = *(x + 2); n   *(x + 2) = *(x + 1); n   *(x + 1) = tmp; n } n int main() { n   int _t; n   scanf( %d , &_t); n   while (_t--) { n     static float arr[N]; n     static int anss[N * N]; n     static int tm[N]; n     memset(tm, 0, sizeof(tm)); n     int n; n     scanf( %d , &n); n     int f2 = -1; n     for (int i = 1; i <= n; i++) { n       int a; n       scanf( %d , &a); n       tm[a]++; n       if (tm[a] == 2) f2 = a; n       arr[i] = a + 0.0001 * tm[a]; n     } n     int nx = 0; n     for (int i = 1; i < n; i++) n       for (int j = i + 1; j <= n; j++) n         if (arr[i] > arr[j]) nx++; n     if (nx & 1) { n       if (f2 != -1) { n         int f21 = -1, f22 = -1; n         for (int i = 1; i <= n; i++) n           if (((int)arr[i]) == f2) { n             if (f21 == -1) n               f21 = i; n             else if (f22 == -1) n               f22 = i; n             else n               break; n           } n         std::swap(arr[f21], arr[f22]); n         nx++; n       } else { n         printf( -1 n ); n         continue; n       } n     } n     int ans = 0; n     while (nx) { n       for (int i = 1; i <= n - 2; i++) { n         if (arr[i] < arr[i + 2] && arr[i + 2] < arr[i + 1] || n             arr[i] > arr[i + 2] && arr[i + 2] > arr[i + 1]) { n           sw(arr + i); n           anss[++ans] = i; n         } n         if (arr[i] < arr[i + 1] && arr[i] > arr[i + 2] || n             arr[i] > arr[i + 1] && arr[i + 1] > arr[i + 2]) { n           sw(arr + i); n           nx -= 2; n           anss[++ans] = i; n         } n       } n     } n     printf( %d n , ans); n     for (int i = 1; i <= ans; i++) printf( %d  , anss[i]); n     printf(  n ); n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int main() { n   int n, m; n   cin >> n >> m; n   string test; n   cin >> test; n   for (int i = 0; i < m; i++) { n     int l, r; n     char c1, c2; n     cin >> l >> r >> c1 >> c2; n     l -= 1; n     r -= 1; n     for (; l <= r; l++) { n       if (test[l] == c1) { n         test[l] = c2; n       } n     } n   } n   cout << test << endl; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int maxn = 1e5 + 100; n const long long mod = 1e9 + 7; n char s[maxn]; n int num[55]; n long long dp[maxn]; n long long tmp[maxn]; n long long quesnum[55][55]; n long long ques[55][55]; n long long inv[maxn], fac[maxn], invf[maxn]; n void init(int hf) { n   inv[1] = 1; n   for (int i = 2; i < maxn; i++) n     inv[i] = ((mod - mod / i) * inv[mod % i]) % mod; n   fac[0] = 1; n   for (int i = 1; i < maxn; i++) fac[i] = (fac[i - 1] * (long long)i) % mod; n   invf[0] = 1; n   for (int i = 1; i < maxn; i++) invf[i] = (invf[i - 1] * inv[i]) % mod; n   memset(dp, 0, sizeof(dp)); n   memset(ques, -1, sizeof(ques)); n   dp[0] = 1; n   for (int i = 0; i < 55; i++) { n     if (!num[i]) continue; n     for (int j = hf; j >= num[i]; j--) { n       dp[j] = (dp[j] + dp[j - num[i]]) % mod; n     } n   } n   for (int i = 0; i < 52; i++) { n     for (int j = i; j < 52; j++) { n       for (int k = 0; k <= hf; k++) tmp[k] = dp[k]; n       for (int k = num[i]; k <= hf; k++) n         tmp[k] = (tmp[k] - tmp[k - num[i]] + mod) % mod; n       if (i != j) n         for (int k = num[j]; k <= hf; k++) n           tmp[k] = (tmp[k] - tmp[k - num[j]] + mod) % mod; n       quesnum[i][j] = quesnum[j][i] = tmp[hf]; n     } n   } n } n int main() { n   scanf( %s , s); n   memset(num, 0, sizeof(num)); n   int len = strlen(s); n   int hf = len / 2; n   for (int i = 0; i < len; i++) { n     if (s[i] >=  a  && s[i] <=  z ) n       num[s[i] -  a ]++; n     else n       num[s[i] -  A  + 26]++; n   } n   init(hf); n   int q; n   scanf( %d , &q); n   int x, y; n   while (q--) { n     scanf( %d%d , &x, &y); n     x--; n     y--; n     int idx, idy; n     if (s[x] >=  a  && s[x] <=  z ) n       idx = s[x] -  a ; n     else n       idx = s[x] -  A  + 26; n     if (s[y] >=  a  && s[y] <=  z ) n       idy = s[y] -  a ; n     else n       idy = s[y] -  A  + 26; n     if (ques[idx][idy] != -1) { n       printf( %I64d n , ques[idx][idy]); n       continue; n     } n     long long ans; n     if (idx == idy) { n       if (num[idx] > hf) { n         printf( 0 n ); n         ques[idx][idx] = 0; n         continue; n       } n       long long cc = n           ((fac[hf] * invf[num[idx]]) % mod * invf[hf - num[idx]]) % mod; n       ans = ((cc * fac[hf - num[idx]]) % mod * fac[hf]) % mod; n     } else { n       if (num[idx] + num[idy] > hf) { n         ques[idx][idy] = ques[idy][idx] = 0; n         printf( 0 n ); n         continue; n       } n       int numx = num[idx], numy = num[idy]; n       int num_hfx = hf - numx; n       long long cc1 = ((fac[hf] * invf[numx]) % mod * invf[hf - numx]) % mod; n       long long cc2 = n           ((fac[num_hfx] * invf[numy]) % mod * invf[num_hfx - numy]) % mod; n       ans = (((cc1 * cc2) % mod * fac[hf]) % mod * fac[hf - numx - numy]) % mod; n     } n     for (int i = 0; i < 55; i++) { n       if (i == idx || i == idy) continue; n       ans = (ans * invf[num[i]]) % mod; n     } n     ans = (ans * quesnum[idx][idy]) % mod; n     ans = (ans * 2) % mod; n     ques[idx][idy] = ques[idy][idx] = ans; n     printf( %I64d n , ans); n   } n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int MAXN = 500000 + 10; n int a[MAXN]; n int n, m, ans, tp, tot; n int main() { n   scanf( %d , &n); n   for (int i = 1; i <= n; ++i) scanf( %d , a + i); n   ans = n; n   sort(a + 1, a + 1 + n); n   for (int i = n / 2; i >= 1; --i) n     if (a[ans] >= a[i] * 2) --ans; n   printf( %d n , ans); n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n char a[500001 + 10], b[500001 + 10], s[(500001 << 1) + 10]; n int n, m; n struct BIT { n   long long c[500001 << 1]; n   long long query(int x) { n     if (x <= 0) return 0; n     long long ans = 0; n     for (int i = x; i; i -= (i & -i)) ans += c[i]; n     return ans; n   } n   void add(int x, long long p) { n     if (x <= 0) x = 1; n     for (int i = x; i <= 1000000; i += (i & -i)) c[i] += p; n   } n } b1, b2; n int za[500001 * 3], zb[500001 * 3]; n char mod[500001 * 3]; n void zfunc(char *s, int n, int *z) { n   int l = 0, r = 0; n   z[1] = n; n   int pt; n   for (int i = 2; i <= n; ++i) { n     if (r < i) { n       for (pt = i; pt <= n && s[pt] == s[pt - i + 1]; ++pt) n         ; n       --pt; n       z[i] = pt - i + 1; n       if (z[i]) l = i, r = pt; n     } else { n       int b = r - i + 1, i_ = i - l + 1; n       if (z[i_] < b) n         z[i] = z[i_]; n       else { n         for (pt = r + 1; pt <= n && s[pt] == s[pt - i + 1]; ++pt) n           ; n         --pt; n         z[i] = pt - i + 1; n         l = i, r = pt; n       } n     } n   } n } n int main() { n   scanf( %d%d , &n, &m); n   scanf( %s%s%s , a + 1, b + 1, s + 1); n   memcpy(mod + 1, s + 1, m - 1); n   mod[m] =  $ ; n   memcpy(mod + m + 1, a + 1, n); n   zfunc(mod, n + m, za); n   for (int i = 1; i <= n; ++i) za[i] = za[i + m]; n   reverse(s + 1, s + 1 + m); n   reverse(b + 1, b + 1 + n); n   memcpy(mod + 1, s + 1, m - 1); n   mod[m] =  $ ; n   memcpy(mod + m + 1, b + 1, n); n   zfunc(mod, n + m, zb); n   for (int i = 1; i <= n; ++i) zb[i] = zb[i + m]; n   reverse(zb + 1, zb + 1 + n); n   int cur = 1; n   long long ans = 0; n   for (int i = 1; i <= n; ++i) { n     while (cur <= min(i + m - 2, n)) n       b1.add(m - 1 - zb[cur], 1), b2.add(m - 1 - zb[cur], zb[cur]), ++cur; n     ans += 1ll * b1.query(za[i]) * (za[i] - m + 1) + b2.query(za[i]); n     b1.add(m - 1 - zb[i], -1), b2.add(m - 1 - zb[i], -zb[i]); n   } n   printf( %lld n , ans); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n long long int dec(string s, int n) { n   long long int r = 0, p = 0, l = s.size() - 1, tmp; n   while (l >= 0) { n     if (isalpha(s[l])) n       tmp = s[l] - 55; n     else n       tmp = s[l] - 48; n     int prod = 1; n     for (int k = 0; k < p; k++) prod *= n; n     r += prod * tmp; n     p++; n     l--; n   } n   return r; n } n int main() { n   string s, a, b; n   int mx = 0; n   cin >> s; n   int i = 0; n   while (s[i] !=  : ) { n     a.push_back(s[i]); n     if (mx < s[i]) mx = s[i]; n     i++; n   } n   i++; n   while (s[i] !=   0 ) { n     b.push_back(s[i]); n     if (mx < s[i]) mx = s[i]; n     i++; n   } n   int bg; n   bg = mx < 65 ? mx - 48 : mx - 55; n   int beg = max(2, bg + 1); n   if (dec(a, beg) >= 24 || dec(b, beg) >= 60) { n     cout << 0 << endl; n     return 0; n   } n   if (dec(a, 100) < 24 && dec(b, 100) < 60) { n     cout << -1 << endl; n     return 0; n   } n   for (i = beg;; i++) { n     if (dec(a, i) < 24 && dec(b, i) < 60) { n       cout << i <<    ; n     } else n       break; n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int INF = (int)2e9; n const long long INFL = (long long)9e18; n const int MAXINT = ((~0) ^ (1 << 31)); n const long long MAXLL = ((~0) ^ ((long long)1 << 63)); n template <class T> n inline T pow2(T a) { n   return a * a; n } n template <class T> n inline bool mineq(T& a, T b) { n   return (a > b) ? (a = b, true) : false; n } n template <class T> n inline bool maxeq(T& a, T b) { n   return (a < b) ? (a = b, true) : false; n } n const int maxn = 2e5; n long long n, k, x, cnt; n pair<long long, long long> p[maxn]; n int main() { n   ios_base::sync_with_stdio(0); n   cin >> n >> k; n   for (int i = 1; i <= n; i++) p[i] = {1e10, 0}; n   for (int i = 1; i <= k; i++) { n     cin >> x; n     p[x].first = min(p[x].first, (long long)i); n     p[x].second = max(p[x].second, (long long)i); n   } n   if (p[1].first > p[2].second && n != 1) { n     cnt++; n   } n   if (p[n].first > p[n - 1].second && n != 1) { n     cnt++; n   } n   if (p[1].second == 0) cnt++; n   if (p[n].second == 0 && n != 1) cnt++; n   for (int i = 2; i <= n - 1; i++) { n     if (p[i].second == 0) cnt++; n     if (p[i].first > p[i + 1].second) { n       cnt++; n     } n     if (p[i].first > p[i - 1].second) { n       cnt++; n     } n   } n   cout << cnt; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n long long n, ti[2005], co[2005], dp[2005][2005], i, j; n int main() { n   cin >> n; n   for (i = 1; i <= n; i++) { n     cin >> ti[i] >> co[i]; n     ti[i]++; n   } n   for (i = 0; i <= n; i++) { n     for (j = 1; j <= n; j++) dp[i][j] = 1e16; n   } n   for (i = 1; i <= n; i++) { n     for (j = 1; j <= n; j++) { n       dp[i][j] = min(dp[i - 1][j], dp[i - 1][max(0ll, j - ti[i])] + co[i]); n     } n   } n   cout << dp[n][n]; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n struct pen { n   int color; n   int diameter; n }; n int n, m, u, v; n pen marker[100000], cap[100000]; n struct match { n   vector<pen> marker; n   vector<pen> cap; n }; n match singleMatch[1000 + 1]; n match doubleMatch[1000 + 1][1000 + 1]; n int main(int argc, char *argv[]) { n   u = 0, v = 0; n   cin >> n >> m; n   for (int i = 0; i < n; i++) { n     int color, diameter; n     cin >> color >> diameter; n     marker[i].color = color; n     marker[i].diameter = diameter; n     singleMatch[diameter].marker.push_back(marker[i]); n     doubleMatch[diameter][color].marker.push_back(marker[i]); n   } n   for (int i = 0; i < m; i++) { n     int color, diameter; n     cin >> color >> diameter; n     cap[i].color = color; n     cap[i].diameter = diameter; n     singleMatch[diameter].cap.push_back(marker[i]); n     doubleMatch[diameter][color].cap.push_back(cap[i]); n   } n   for (int i = 1; i < 1000 + 1; i++) { n     vector<pen> tempM = singleMatch[i].marker; n     vector<pen> tempC = singleMatch[i].cap; n     int temp1 = (int)tempM.size(); n     int temp2 = (int)tempC.size(); n     if (temp1 > 0 && temp2 > 0) u += min(temp1, temp2); n   } n   for (int i = 1; i < 1000 + 1; i++) n     for (int j = 1; j < 1000 + 1; j++) { n       vector<pen> tempM = doubleMatch[i][j].marker; n       vector<pen> tempC = doubleMatch[i][j].cap; n       int temp1 = (int)tempM.size(); n       int temp2 = (int)tempC.size(); n       if (temp1 > 0 && temp2 > 0) v += min(temp1, temp2); n     } n   cout << u <<     << v << endl; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int inf = 109; n const int mod = 1000000007; n long long cnt[inf]; n long long dp[inf]; n long long temp[inf][inf]; n long long sol[inf][inf]; n long long bs[inf][inf]; n int main() { n   int n, x, a; n   scanf( %d%d , &n, &x); n   for (int i = 0; i < n; ++i) { n     scanf( %d , &a); n     cnt[a]++; n   } n   dp[0] = 1; n   int all = 0; n   for (int i = 1; i <= 100; ++i) { n     for (int j = 1; j <= i; ++j) dp[i] = (dp[i] + dp[i - j] * cnt[j]) % mod; n     all = (all + dp[i]) % mod; n   } n   dp[0] = all; n   for (int i = 1; i <= 50; ++i) swap(dp[i], dp[101 - i]); n   for (int i = 1; i <= 100; ++i) sol[i][i] = 1, bs[0][i] = bs[1][i] = cnt[i]; n   sol[0][0] = bs[0][0] = 1; n   for (int i = 2; i <= 100; ++i) bs[i][i - 1] = 1; n   if (x <= 100) { n     int ad = 0; n     for (int i = 100; i > 0 && x > 0; --i, --x) ad = (ad + dp[i]) % mod; n     printf( %d n , ad + 1); n     return 0; n   } n   x -= 100; n   while (x) { n     if (x & 1) { n       for (int i = 0; i <= 100; ++i) n         for (int j = 0; j <= 100; ++j) { n           temp[i][j] = 0; n           for (int u = 0; u <= 100; ++u) n             temp[i][j] = (temp[i][j] + sol[i][u] * bs[u][j]) % mod; n         } n       for (int i = 0; i <= 100; ++i) n         for (int j = 0; j <= 100; ++j) sol[i][j] = temp[i][j]; n     } n     x = x >> 1; n     for (int i = 0; i <= 100; ++i) n       for (int j = 0; j <= 100; ++j) { n         temp[i][j] = 0; n         for (int u = 0; u <= 100; ++u) n           temp[i][j] = (temp[i][j] + bs[i][u] * bs[u][j]) % mod; n       } n     for (int i = 0; i <= 100; ++i) n       for (int j = 0; j <= 100; ++j) bs[i][j] = temp[i][j]; n   } n   int ans = 0; n   for (int i = 0; i <= 100; ++i) ans = (ans + sol[0][i] * dp[i]) % mod; n   printf( %d n , (ans + 1) % mod); n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const long long INF = 1e9 + 7; n const int N = 4e5 + 10; n const int M = 22; n class SegmentTree { n  public: n   int ql, qr, qx; n   int xorv[N]; n   int sumv[N]; n   void init() { n     memset((xorv), (0), sizeof(xorv)); n     memset((sumv), (0), sizeof(sumv)); n   } n   void set(int ql, int qr, int qx) { n     this->ql = ql; n     this->qr = qr; n     this->qx = qx; n   } n   void pushdown(int o, int len) { n     if (xorv[o]) { n       xorv[o << 1] ^= 1; n       xorv[o << 1 | 1] ^= 1; n       sumv[o << 1] = (len - len / 2) - sumv[o << 1]; n       sumv[o << 1 | 1] = len / 2 - sumv[o << 1 | 1]; n       xorv[o] = 0; n     } n   } n   void maintain(int o) { sumv[o] = sumv[o << 1] + sumv[o << 1 | 1]; } n   int query(int l, int r, int o = 1) { n     if (ql <= l && qr >= r) { n       return sumv[o]; n     } n     int mid = (l + r) >> 1; n     pushdown(o, r - l + 1); n     int ans = 0; n     if (ql <= mid) ans += query(l, mid, o << 1); n     if (qr > mid) ans += query(mid + 1, r, o << 1 | 1); n     return ans; n   } n   void update(int l, int r, int o = 1) { n     if (ql <= l && qr >= r) { n       xorv[o] ^= 1; n       sumv[o] = r - l + 1 - sumv[o]; n       return; n     } n     int mid = (l + r) >> 1; n     pushdown(o, r - l + 1); n     if (ql <= mid) update(l, mid, o << 1); n     if (qr > mid) update(mid + 1, r, o << 1 | 1); n     maintain(o); n   } n } st[M]; n int main() { n   for (int i = 0; i < M; i++) st[i].init(); n   int n; n   cin >> n; n   for (int i = 1; i <= n; i++) { n     int x; n     cin >> x; n     for (int j = 0; j < M; j++) { n       if (x >> j & 1) st[j].set(i, i, 1), st[j].update(1, n); n     } n   } n   int q; n   cin >> q; n   while (q--) { n     int op; n     cin >> op; n     if (op == 1) { n       int l, r; n       cin >> l >> r; n       long long ans = 0; n       for (int i = 0; i < M; i++) { n         st[i].set(l, r, 0); n         ans += (1LL << i) * st[i].query(1, n); n       } n       cout << ans <<   n ; n     } else { n       int l, r, x; n       cin >> l >> r >> x; n       for (int i = 0; i < M; i++) { n         if (x >> i & 1) st[i].set(l, r, 1), st[i].update(1, n); n       } n     } n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n struct data { n   int s, m, r, t; n   int operator<(const data &b) const { return t < b.t; } n   void get() { n     scanf( %d , &s); n     scanf( %d , &m); n     scanf( %d , &r); n     t = r ? (m / r + (m % r > 0)) : 2e9; n   } n   int calc(int o) { return min(1ll * m, s + 1ll * r * o); } n } a[20][100005]; n int T[100005 << 2]; n long long R[20][100005], sum[20][100005], ans; n int n, Q, t, ql, qr; n void Build(int x, int l, int r, int d) { n   T[x] = -2; n   if (l == r) { n     a[d][l].get(); n     R[d][l] = R[d][l - 1] + a[d][l].r; n     sum[d][l] = sum[d][l - 1] + a[d][l].m; n     return; n   } n   int mid = (l + r) >> 1; n   Build(x << 1, l, mid, d + 1); n   Build(x << 1 | 1, mid + 1, r, d + 1); n   for (int i = l; i <= r; i++) a[d][i] = a[d + 1][i]; n   sort(a[d] + l, a[d] + r + 1); n   for (int i = l; i <= r; i++) R[d][i] = R[d][i - 1] + a[d][i].r; n   for (int i = l; i <= r; i++) sum[d][i] = sum[d][i - 1] + a[d][i].m; n } n void Find(int x, int l, int r, int d) { n   if (ql <= l && r <= qr && T[x] != -1) { n     if (T[x] == -2) { n       for (int i = l; i <= r; i++) ans += a[d][i].calc(t); n       T[x] = t; n       return; n     } n     data tmp = (data){0, 0, 0, t - T[x]}; n     int id = upper_bound(a[d] + l, a[d] + r + 1, tmp) - a[d]; n     ans += 1ll * (R[d][r] - R[d][id - 1]) * (t - T[x]) + sum[d][id - 1] - n            sum[d][l - 1]; n     T[x] = t; n     return; n   } n   if (T[x] >= 0) T[x << 1] = T[x << 1 | 1] = T[x]; n   int mid = (l + r) >> 1; n   if (ql <= mid) Find(x << 1, l, mid, d + 1); n   if (qr > mid) Find(x << 1 | 1, mid + 1, r, d + 1); n   T[x] = (T[x << 1] == T[x << 1 | 1]) ? T[x << 1] : -1; n } n int main() { n   scanf( %d , &n); n   Build(1, 1, n, 0); n   scanf( %d , &Q); n   while (Q--) { n     scanf( %d , &t); n     scanf( %d , &ql); n     scanf( %d , &qr); n     ans = 0; n     Find(1, 1, n, 0); n     printf( %I64d n , ans); n   } n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n struct Edge { n   int v; n   Edge *link; n } edge[400010 * 2], *adj[200010], *tree[200010 * 2]; n int totE, con, root, currT, top, top1; n int totCut, totBi; n int dep[200010], deps[200010], num[200010], dfn[200010], lowlink[200010], n     cut[200010], bi[200010], color[200010]; n int temp[200010], st1[200010], st2[200010], st3[200010], st4[200010], n     f[200010 * 2]; n int used[200010 * 2], odd[200010 * 2]; n int fa[200010][20]; n int LOG[200010]; n void addEdge(int u, int v) { n   Edge *p = &edge[totE++]; n   p->v = v; n   p->link = adj[u]; n   adj[u] = p; n } n void addTree(int u, int v) { n   Edge *p = &edge[totE++]; n   p->v = v; n   p->link = tree[u]; n   tree[u] = p; n } n void dfs(int u, int pre) { n   dep[u] = dep[pre] + 1; n   dfn[u] = lowlink[u] = ++currT; n   num[u] = con; n   Edge *p = adj[u]; n   int cnt = 0; n   bool flag = false; n   while (p) { n     if (!dfn[p->v]) { n       ++cnt; n       dfs(p->v, u); n       lowlink[u] = min(lowlink[u], lowlink[p->v]); n       if (lowlink[p->v] >= dfn[u]) flag = true; n     } else if (p->v != pre) n       lowlink[u] = min(lowlink[u], dfn[p->v]); n     p = p->link; n   } n   if (flag && (u != root || cnt > 1)) cut[u] = ++totCut; n } n bool dfs2(int u) { n   Edge *p = adj[u]; n   while (p) { n     if (bi[p->v] == totBi) { n       if (color[p->v] == -1) { n         color[p->v] = !color[u]; n         if (!dfs2(p->v)) return false; n       } else if (color[p->v] == color[u]) n         return false; n     } n     p = p->link; n   } n   return true; n } n void solve() { n   ++totBi; n   int cnt = 0; n   for (int i = 0; i < top1; ++i) { n     int u = st3[i], v = st4[i]; n     bi[u] = totBi; n     bi[v] = totBi; n     color[u] = color[v] = -1; n     if (cut[u]) temp[cnt++] = cut[u]; n     if (cut[v]) temp[cnt++] = cut[v]; n   } n   sort(temp, temp + cnt); n   for (int i = 0; i < cnt; ++i) n     if (i == 0 || temp[i] != temp[i - 1]) { n       addTree(temp[i], totCut + totBi); n       addTree(totCut + totBi, temp[i]); n     } n   color[st3[0]] = 0; n   odd[totBi] = !dfs2(st3[0]); n } n void dfs1(int u, int pre) { n   dfn[u] = lowlink[u] = ++currT; n   Edge *p = adj[u]; n   while (p) { n     if (!dfn[p->v]) { n       st1[top] = u; n       st2[top++] = p->v; n       dfs1(p->v, u); n       lowlink[u] = min(lowlink[u], lowlink[p->v]); n       if (lowlink[p->v] >= dfn[u]) { n         top1 = 0; n         while (true) { n           --top; n           st3[top1] = st1[top]; n           st4[top1++] = st2[top]; n           if (st1[top] == u && st2[top] == p->v) break; n         } n         solve(); n       } n     } else { n       if (dfn[u] > dfn[p->v] && p->v != pre) { n         st1[top] = u; n         st2[top++] = p->v; n       } n       if (p->v != pre) lowlink[u] = min(lowlink[u], dfn[p->v]); n     } n     p = p->link; n   } n } n void dfs3(int u, int pre) { n   deps[u] = deps[pre] + 1; n   used[u] = true; n   fa[u][0] = pre; n   if (u <= totCut) n     f[u] = 0; n   else n     f[u] = odd[u - totCut]; n   f[u] += f[pre]; n   Edge *p = tree[u]; n   while (p) { n     if (!used[p->v]) dfs3(p->v, u); n     p = p->link; n   } n } n int LCA(int u, int v) { n   if (deps[u] < deps[v]) swap(u, v); n   int diff = deps[u] - deps[v]; n   for (int i = 0; diff; ++i, diff >>= 1) n     if (diff & 1) u = fa[u][i]; n   if (u == v) return u; n   int t = 19; n   for (int i = t; i >= 0; --i) { n     if (fa[u][i] != fa[v][i]) { n       u = fa[u][i]; n       v = fa[v][i]; n     } n   } n   return fa[u][0]; n } n int main() { n   LOG[1] = 0; n   for (int i = 2; i < 200010; ++i) LOG[i] = (LOG[i] >> 1) + 1; n   int n, m; n   scanf( %d%d , &n, &m); n   for (int i = 0; i < m; ++i) { n     int u, v; n     scanf( %d%d , &u, &v); n     addEdge(u, v); n     addEdge(v, u); n   } n   dep[0] = -1; n   for (int i = 1; i <= n; ++i) n     if (!dfn[i]) { n       root = i; n       dfs(i, 0); n       ++con; n     } n   currT = 0; n   memset(dfn, 0, sizeof(dfn)); n   for (int i = 1; i <= n; ++i) n     if (!dfn[i]) dfs1(i, 0); n   for (int i = 1; i <= totCut + totBi; ++i) n     if (!used[i]) dfs3(i, 0); n   for (int l = 1; (1 << l) <= totCut + totBi; ++l) n     for (int i = 1; i <= totCut + totBi; ++i) n       if (fa[i][l - 1] != 0) fa[i][l] = fa[fa[i][l - 1]][l - 1]; n   int q; n   scanf( %d , &q); n   for (int i = 0; i < q; ++i) { n     int u, v; n     scanf( %d%d , &u, &v); n     if (u == v || num[u] != num[v]) n       puts( No ); n     else { n       int x, y; n       if (cut[u]) n         x = cut[u]; n       else n         x = totCut + bi[u]; n       if (cut[v]) n         y = cut[v]; n       else n         y = totCut + bi[v]; n       int lca = LCA(x, y); n       int sum = f[x] + f[y] - 2 * f[fa[lca][0]]; n       if (sum > 0) n         puts( Yes ); n       else if ((dep[u] + dep[v]) % 2 == 0) n         puts( No ); n       else n         puts( Yes ); n     } n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n template <typename T> n inline void read(T &x) { n   x = 0; n   char c = getchar(); n   while (!isdigit(c)) c = getchar(); n   while (isdigit(c)) x = x * 10 + (c ^ 48), c = getchar(); n } n using namespace std; n int t; n int pri[4001000], pcnt; n bool depri[35001000]; n inline void init() { n   depri[1] = true; n   const int up = 3.5e7; n   for (int i = 2; i <= up; ++i) { n     if (!depri[i]) pri[++pcnt] = i; n     for (int j = 1; j <= pcnt && i * pri[j] <= up; ++j) { n       depri[i * pri[j]] = true; n       if (i % pri[j] == 0) break; n     } n   } n } n struct TC { n   int id; n   long long n, k; n   inline bool operator<(const TC &a) const { return k < a.k; } n } tc[10100]; n bool ans[10100]; n long long p[100]; n int ptot; n inline void Div(long long x) { n   ptot = 0; n   for (int i = 1; 1ll * pri[i] * pri[i] <= x; ++i) { n     if (x % pri[i] == 0) { n       p[++ptot] = pri[i]; n       while (x % pri[i] == 0) x /= pri[i]; n     } n   } n   if (x != 1) p[++ptot] = x; n } n struct node { n   int cur; n   long long val; n   inline bool operator<(const node &a) const { return val > a.val; } n }; n priority_queue<node> q; n long long dis[100100]; n bool vis[100100]; n inline void Update(long long k) { n   Div(k); n   if (ptot <= 2) return; n   memset(dis, 0x3f, sizeof(dis)); n   memset(vis, 0, sizeof(vis)); n   dis[0] = 0; n   q.push((node){0, 0}); n   while (!q.empty()) { n     int cur = (q.top()).cur; n     q.pop(); n     if (vis[cur]) continue; n     vis[cur] = true; n     for (int i = 2; i <= ptot; ++i) { n       int to = (cur + p[i]) % p[1]; n       long long val = (cur + p[i]) / p[1]; n       if (dis[to] <= dis[cur] + val) continue; n       dis[to] = dis[cur] + val; n       q.push((node){to, dis[to]}); n     } n   } n } n inline long long quickmul(long long x, long long k, long long P) { n   x = (x % P + P) % P; n   k = (k % P + P) % P; n   long long res = 0; n   while (k) { n     if (k & 1) res = (res + x) % P; n     x = (x + x) % P; n     k >>= 1; n   } n   return res; n } n long long exgcd(long long a, long long b, long long &x, long long &y) { n   if (!b) { n     x = 1; n     y = 0; n     return a; n   } n   long long g = exgcd(b, a % b, x, y); n   long long tmp = x; n   x = y; n   y = tmp - a / b * y; n   return g; n } n inline bool get_ans(long long n) { n   if (!ptot) return false; n   if (ptot == 1) return n % p[1] == 0; n   if (ptot == 2) { n     long long x = 0, y = 1; n     exgcd(p[1], p[2], x, y); n     x = quickmul(x, n, p[2]); n     if (1.0 * x * p[1] > 2e18) return false; n     return n >= x * p[1]; n   } n   if (1.0 * dis[n % p[1]] * p[1] > 2e18) return false; n   return dis[n % p[1]] * p[1] + n % p[1] <= n; n } n signed main() { n   init(); n   read(t); n   for (int i = 1; i <= t; ++i) { n     read(tc[i].n), read(tc[i].k); n     tc[i].id = i; n   } n   sort(tc + 1, tc + 1 + t); n   for (int i = 1; i <= t; ++i) { n     if (tc[i].k != tc[i - 1].k) Update(tc[i].k); n     ans[tc[i].id] = get_ans(tc[i].n); n   } n   for (int i = 1; i <= t; ++i) puts(ans[i] ?  YES  :  NO ); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n long long MOD = 1e9 + 7; n std::vector<long long> factorial; n void precompute_factorial(int ma) { n   factorial.push_back(1); n   for (int i = 1; i <= ma; i++) n     factorial.push_back((factorial.back() * i) % MOD); n } n long long power(long long base, int e) { n   long long result = 1; n   while (e) { n     if (e & 1) result = (result * base) % MOD; n     base = (base * base) % MOD; n     e >>= 1; n   } n   return result; n } n int main() { n   ios_base::sync_with_stdio(false); n   cin.tie(NULL); n   int n, k; n   cin >> n >> k; n   precompute_factorial(n + 1); n   vector<long long> inv_factorial(n + 1, 1); n   for (int i = 2; i < n + 1; i++) n     inv_factorial[i] = power(factorial[i], MOD - 2); n   vector<long long> inv(n + 2); n   for (int i = 1; i < n + 2; i++) inv[i] = power(i, MOD - 2); n   if (k == 0) { n     cout << ((factorial[n] - factorial[n - 1] + MOD) % MOD) << endl; n     return 0; n   } n   vector<long long> dp2(n + 1, 1); n   vector<long long> xxx(n + 1, 1); n   long long sum = 0; n   for (int i = 1; i < n + 1; i++) { n     sum = (sum + xxx[i - 1]) % MOD; n     if (i - 1 - k >= 0) { n       sum = (sum + MOD - xxx[i - 1 - k]) % MOD; n     } n     dp2[i] = (sum * factorial[i - 1]) % MOD; n     xxx[i] = (dp2[i] * inv_factorial[i]) % MOD; n   } n   vector<long long> dp(n + 1, 0); n   long long last = 0; n   long long total = 0; n   for (int i = k + 2; i <= n; i++) { n     long long y = i - k - 2; n     long long tt = dp2[y]; n     tt = (tt + MOD) % MOD; n     tt = (tt * inv_factorial[y]) % MOD; n     tt = (tt * inv[i - 1]) % MOD; n     last += tt; n     last %= MOD; n     total += last; n     total %= MOD; n     dp[i] = (factorial[i - 1] * total) % MOD; n   } n   cout << dp.back() << endl; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int N = 105; n const int M = 505; n const int MOD = int(1e9) + 7; n const int INF = 0x3f3f3f3f; n const double EPS = 1e-9; n const double PI = acos(-1.0); n const int dx[] = {-1, 1, 0, 0}; n const int dy[] = {0, 0, -1, 1}; n template <class T> n inline T Min(T a, T b) { n   return a < b ? a : b; n } n template <class T> n inline T Max(T a, T b) { n   return a > b ? a : b; n } n template <class T> n inline T Min(T a, T b, T c) { n   return min(min(a, b), c); n } n template <class T> n inline T Max(T a, T b, T c) { n   return max(max(a, b), c); n } n template <class T> n inline T sqr(T a) { n   return a * a; n } n template <class T> n inline T cub(T a) { n   return a * a * a; n } n template <class T> n inline T gcd(T a, T b) { n   return b == 0 ? a : gcd(b, a % b); n } n template <class T> n inline T lcm(T a, T b) { n   return a * b / gcd(a, b); n } n int main() { n   int a, b; n   while (scanf( %d%d , &a, &b) != EOF) { n     int i, tot = (a * (a - 1)) / 2; n     if (tot <= b) { n       printf( no solution n ); n     } else { n       for (i = 0; i < a; i++) { n         printf( %d %d n , 0, i); n       } n     } n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int n, q; n int A[600006]; n int gcd(int a, int b) { return !b ? a : gcd(b, a % b); } n map<pair<int, int>, int> M; n int L[600006], R[600006], lst[600006], cn; n struct que { n   int l, r, idx; n } Q[600006]; n vector<int> bc[600006]; n int T[600006]; n void ad(int x, int c) { n   while (x <= cn) T[x] += c, x += (x & -x); n } n int sum(int x) { n   int ret = 0; n   while (x > 0) ret += T[x], x -= (x & -x); n   return ret; n } n int ans[600006]; n void solve() { n   cin >> n; n   for (int i = (1), iend = (n); i <= iend; ++i) { n     int k; n     scanf( %d , &k); n     L[i] = cn + 1; n     int px, py, tx, ty, x, y, sx, sy; n     scanf( %d%d , &px, &py); n     sx = px, sy = py; n     for (int j = (1), jend = (k); j <= jend; ++j) { n       if (j != k) n         scanf( %d%d , &x, &y); n       else n         x = sx, y = sy; n       tx = x, ty = y; n       x -= px, y -= py; n       int g = gcd(abs(x), abs(y)); n       x /= g, y /= g; n       ++cn; n       lst[cn] = M[make_pair(x, y)]; n       bc[lst[cn]].push_back(cn); n       M[make_pair(x, y)] = cn; n       px = tx, py = ty; n     } n     R[i] = cn; n   } n   cin >> q; n   for (int i = (1), iend = (q); i <= iend; ++i) { n     int l, r; n     scanf( %d%d , &l, &r); n     l = L[l], r = R[r]; n     Q[i] = (que){l, r, i}; n   } n   sort(Q + 1, Q + 1 + q, [](que a, que b) { return a.l < b.l; }); n   int cur = 1; n   for (int i = (0), iend = (cn); i <= iend; ++i) { n     while (cur <= q && Q[cur].l == i) { n       ans[Q[cur].idx] = sum(Q[cur].r) - sum(Q[cur].l - 1); n       ++cur; n     } n     for (int x : bc[i]) ad(x, 1); n   } n   for (int i = (1), iend = (q); i <= iend; ++i) printf( %d n , ans[i]); n } n signed main() { solve(); } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const long long remi = 1000000007; n const long long remi2 = 998244353; n const long long inf = 1e18 + 1e17 + 1e16 + 1e15 + 1e14; n long long Pow(long long x, long long y, long long m) { n   if (y == 0) return 1; n   long long p = Pow(x, y / 2, m) % m; n   p = (p * p) % m; n   return (y % 2 == 0) ? p : (x * p) % m; n } n int main() { n   ios_base::sync_with_stdio(false); n   cin.tie(NULL); n   cout.tie(NULL); n   long long i, j, k; n   long long n, m; n   cin >> n >> m; n   vector<long long> v(m); n   for (i = 0; i < m; i++) { n     cin >> v[i]; n   } n   sort(v.begin(), v.end()); n   bool ans = true; n   if (m == 0) { n     cout <<  YES ; n     exit(0); n   } n   if (v[0] == 1 or v[m - 1] == n) ans = false; n   for (i = 2; i < m; i++) { n     long long s0 = v[i - 2]; n     long long s1 = v[i - 1]; n     long long s2 = v[i]; n     if ((s0 == s2 - 2) and (s1 == s2 - 1)) ans = false; n   } n   if (ans) n     cout <<  YES ; n   else n     cout <<  NO ; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n  n int main() n { n  ios_base::sync_with_stdio(false), cin.tie(0); n  int t; n  cin >> t; n  while (t--) { n   map<int, int>L, R; n   int bal = 0; n   string s; n   cin >> s; n   for (char &c : s) { n    if (c ==  1 ) { n     R[bal]++; n     bal++; n    } else { n     L[bal]++; n     bal--; n    } n   } n  n   int cur = 0; n   while (L[cur] > 0 || R[cur] > 0) { n    if (L[cur] > 0 && R[cur - 1] > 0 || (!R[cur] && !L[cur + 1])) { n     L[cur]--; n     cur--; n     cout << 0; n    } else { n     R[cur]--; n     cur++; n     cout << 1; n    } n   } n   cout <<   n ; n  } n  return 0; n }"}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int tree[100010 << 2]; n bool flag; n struct node { n   int row, col, pos; n   friend bool operator<(node a, node b) { n     if (a.row == b.row) return a.col < b.col; n     return a.row < b.row; n   } n }; n node p[100010]; n inline void pushUp(int rt) { tree[rt] = min(tree[rt << 1], tree[rt << 1 | 1]); } n void update(int x, int y, int val, int L, int R, int rt) { n   if (flag) return; n   if (L == R) { n     if (tree[rt] == 0) { n       flag = true; n       tree[rt] = val; n     } n     return; n   } else if (x <= L && R <= y) { n     int mid = (L + R) >> 1; n     if (tree[rt << 1] == 0) n       update(x, y, val, L, mid, rt << 1); n     else if (tree[rt << 1 | 1] == 0) n       update(x, y, val, mid + 1, R, rt << 1 | 1); n   } else { n     int mid = (L + R) >> 1; n     if (x <= mid) update(x, y, val, L, mid, rt << 1); n     if (y > mid) update(x, y, val, mid + 1, R, rt << 1 | 1); n   } n   pushUp(rt); n } n void out(int L, int R, int rt) { n   if (L == R) { n     if (tree[rt]) printf( %d  , tree[rt]); n   } else { n     int mid = (L + R) >> 1; n     out(L, mid, rt << 1); n     out(mid + 1, R, rt << 1 | 1); n   } n } n int main() { n   int i; n   int n, m, cnt; n   while (~scanf( %d%d , &n, &m)) { n     memset(tree, 0, sizeof(tree)); n     for (i = 0; i < m; i++) { n       scanf( %d%d , &p[i].row, &p[i].col); n       p[i].pos = i + 1; n     } n     sort(p, p + m); n     for (cnt = i = 0; i < m; i++) { n       flag = false; n       update(n - p[i].col + 1, p[i].row, p[i].pos, 1, n, 1); n       if (flag) cnt++; n     } n     printf( %d n , cnt); n     out(1, n, 1); n     putchar(  n ); n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const long long MOD = 1e9 + 7; n int n, t, sz[200010], cen; n vector<int> g[200010], v; n bool mark[200010]; n int dfs(int pos, int par) { n   sz[pos] = (int)mark[pos]; n   bool ok = true; n   for (int i = 0; i < g[pos].size(); i++) n     if (g[pos][i] != par) { n       sz[pos] += dfs(g[pos][i], pos); n       if (sz[g[pos][i]] > t) ok = false; n     } n   if (ok && sz[pos] >= t) cen = pos; n   return sz[pos]; n } n void dfs2(int pos, int par) { n   if (mark[pos]) v.push_back(pos); n   for (int i = 0; i < g[pos].size(); i++) n     if (g[pos][i] != par) dfs2(g[pos][i], pos); n } n int main() { n   cin >> n >> t; n   int x, y; n   for (int i = 0; i < n - 1; i++) { n     scanf( %d%d , &x, &y); n     g[x].push_back(y); n     g[y].push_back(x); n   } n   for (int i = 0; i < t + t; i++) { n     scanf( %d , &x); n     mark[x] = true; n   } n   dfs(1, 0); n   for (int i = 0; i < g[cen].size(); i++) dfs2(g[cen][i], cen); n   if (mark[cen]) v.push_back(cen); n   cout << 1 << endl << cen << endl; n   for (int i = 0; i < t; i++) printf( %d %d %d n , v[i], v[i + t], cen); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n template <class T> n inline int countbit(T n) { n   return (n == 0) ? 0 : (1 + countbit(n & (n - 1))); n } n template <class T> n inline T gcd(T a, T b) { n   return b ? gcd(b, a % b) : a; n } n const double EPS = 1e-9; n const double PI = acos(-1.0); n int n, k, h; n int ind[100005]; n int vel[100005]; n int mass[100005]; n int ret[100005]; n bool can(double mid) { n   int cnt = 0; n   double step = k; n   for (int j = n - 1; j >= 0 && cnt <= k; j--) { n     double tempo = step * h / ((double)vel[ind[j]]); n     if (tempo < mid - EPS || fabs(tempo - mid) < EPS) cnt++, step--; n   } n   return cnt >= k; n } n bool cmp(int i, int j) { n   if (mass[i] != mass[j]) return mass[i] < mass[j]; n   return vel[i] < vel[j]; n } n int main(void) { n   scanf( %d %d %d , &n, &k, &h); n   for (int i = (0); i < int(n); i++) scanf( %d , &mass[i]); n   for (int i = (0); i < int(n); i++) scanf( %d , &vel[i]); n   for (int i = (0); i < int(n); i++) ind[i] = i; n   sort(ind, ind + n, cmp); n   double l = 0, r = 10E9 + 100; n   for (int i = (0); i < int(100); i++) { n     double mid = (l + r) / 2; n     if (can(mid)) n       r = mid; n     else n       l = mid; n   } n   double mid = r, step = k; n   int p = k - 1; n   for (int j = n - 1; j >= 0 && p >= 0; j--) { n     double tempo = step * h / ((double)vel[ind[j]]); n     if (tempo < mid - EPS || fabs(tempo - mid) < EPS) { n       step--; n       ret[p--] = ind[j] + 1; n     } n   } n   for (int i = (0); i < int(k); i++) { n     if (i) printf(   ); n     printf( %d , ret[i]); n   } n   printf(  n ); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int n, m; n map<int, int> mym; n void kaisa() { n   ios_base::sync_with_stdio(false); n   cin.tie(NULL); n   cout.tie(NULL); n   cin >> n >> m; n   queue<int> q; n   for (int i = 1; i <= n; i++) { n     int x; n     cin >> x; n     mym[x] = 0; n     q.push(x); n   } n   long long res = 0; n   vector<int> ans; n   while (!q.empty()) { n     int x = q.front(); n     q.pop(); n     if (mym[x] != 0) { n       res += mym[x]; n       ans.push_back(x); n       if (ans.size() == m) break; n     } n     if (!mym.count(x + 1)) { n       mym[x + 1] = mym[x] + 1; n       q.push(x + 1); n     } n     if (!mym.count(x - 1)) { n       mym[x - 1] = mym[x] + 1; n       q.push(x - 1); n     } n   } n   cout << res <<   n ; n   for (int i : ans) { n     cout << i <<    ; n   } n   cout <<   n ; n } n int main() { n   kaisa(); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n long long q, x, y; n int main() { n   ios::sync_with_stdio(0); n   cin.tie(0); n   cin >> q; n   while (q--) { n     cin >> x >> y; n     if (x - y > 1) n       cout <<  YES  n            <<   n ; n     else n       cout <<  NO  n            <<   n ; n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int main() { n   int t, a, b, x; n   cin >> t; n   while (t--) { n     cin >> a >> b; n     if (a < b) { n       x = b - a; n       x % 2 == 0 ? cout << 2 : cout << 1; n     } else if (a > b) { n       x = a - b; n       x % 2 == 0 ? cout << 1 : cout << 2; n     } else n       cout << 0; n     cout << endl; n   } n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int gcd_(int a, int b) { n   if (b == 0) n     return a; n   else n     return gcd_(b, a % b); n } n int main() { n   int n, i, x; n   vector<int> v; n   cin >> n; n   for (i = 0; i < n; i++) { n     cin >> x; n     v.push_back(x); n   } n   int max1 = v[0]; n   x = v[0]; n   for (i = 1; i < n; i++) { n     x = gcd_(v[i], x); n     if (v[i] > max1) max1 = v[i]; n   } n   int moves = ((max1 / x) - n); n   if (moves % 2 != 0) n     cout <<  Alice  << endl; n   else n     cout <<  Bob  << endl; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n std::vector<int> ReadVector(size_t size) { n   std::vector<int> vector(size); n   for (auto& element : vector) { n     std::cin >> element; n   } n   return vector; n } n bool is_pal(const std::string& a) { n   for (size_t i = 0; i < a.size() / 2; ++i) { n     if (a[i] != a[a.size() - i - 1]) { n       return false; n     } n   } n   return true; n } n class Solver { n  public: n   std::vector<std::vector<int>> g; n   Solver() {} n   void read() {} n   void solve() { n     size_t n; n     std::cin >> n; n     g.resize(n); n     for (size_t i = 0; i < n - 1; ++i) { n       int a, b; n       std::cin >> a >> b; n       a--; n       b--; n       g[a].push_back(b); n       g[b].push_back(a); n     } n     int root = -1; n     int begin = -1; n     int end = -1; n     for (int v = 0; v < n; ++v) { n       if (g[v].size() > 2) { n         if (root != -1) { n           std::cout <<  No  << std::endl; n           return; n         } else { n           root = v; n         } n       } n       if (g[v].size() == 1) { n         if (begin == -1) { n           begin = v; n         } else { n           end = v; n         } n       } n     } n     std::cout <<  Yes n ; n     if (root == -1) { n       std::cout << 1 << std::endl; n       std::cout << begin + 1 <<     << end + 1 << std::endl; n       return; n     } n     std::cout << g[root].size() << std::endl; n     for (auto ch : g[root]) { n       std::cout << root + 1 <<    ; n       int tmp = ch; n       int parent = root; n       while (g[tmp].size() == 2) { n         if (g[tmp][0] == parent) { n           parent = tmp; n           tmp = g[tmp][1]; n         } else { n           parent = tmp; n           tmp = g[tmp][0]; n         } n       } n       std::cout << tmp + 1 << std::endl; n     } n   } n }; n int main() { n   std::ios_base::sync_with_stdio(false); n   std::cin.tie(nullptr); n   Solver solver; n   solver.solve(); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n long long INF = 1e9; n const int maxn = 1e6 + 5; n int a[maxn]; n int tpr = 0; n vector<int> adj[maxn]; n void dfs(int root) { n   if (adj[root].size() > 0) { n     if (adj[root][0] == (root + 1)) { n       dfs(root + 1); n       tpr++; n     } else n       return; n   } n } n int main() { n   int n, m, t, i, j, k; n   int flag = 0, flag2; n   int ans = 0; n   cin >> n >> k; n   for (int i = 0; i < k; i++) { n     cin >> m; n     ans += m - 1; n     int y; n     int prev = -1; n     for (int j = 0; j < m; j++) { n       cin >> y; n       if (y == 1) { n         flag2 = m - 1; n       } n       if ((j == 0) && (y == 1)) { n         flag = 1; n       } n       if (prev != -1) adj[prev].push_back(y); n       prev = y; n     } n   } n   if (flag == 0) { n     ans += n - 1; n     cout << ans << endl; n     return 0; n   } n   dfs(1); n   ans -= tpr; n   ans += (n - tpr - 1); n   cout << ans << endl; n   return 0; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n #pragma GCC optimize( O3 ) n #pragma GCC target( sse4 ) n using namespace std; n using ii = pair<int, int>; n using ll = long long; n const int N = 3000 + 5; n const int mod = 1e9 + 7; n string source[N], target[N]; n int n; n ii ranges[N]; n vector<int> FAIL(string pat) { n   int m = pat.size(); n   vector<int> F(m + 1); n   int i = 0, j = -1; n   F[0] = -1; n   while (i < m) { n     while (j >= 0 && pat[i] != pat[j]) j = F[j]; n     i++, j++; n     F[i] = j; n   } n   return F; n } n bool check(string a, string b, string s, string t) { n   vector<int> F = FAIL(s); n   int i = 0, j = 0; n   int n = a.size(); n   int m = s.size(); n   while (i < n) { n     while (j >= 0 && a[i] != s[j]) j = F[j]; n     i++, j++; n     if (j == m) { n       int idx = i - j; n       for (int k = 0; k < m; k++) { n         a[k + idx] = t[k]; n       } n       break; n     } n   } n   return a == b; n } n int main() { n   ios_base::sync_with_stdio(0); n   cin.tie(0); n   cin >> n; n   for (int i = 0; i < n; i++) cin >> source[i]; n   for (int i = 0; i < n; i++) cin >> target[i]; n   string s, t; n   string prefix, suffix; n   for (int i = 0; i < n; i++) { n     if (source[i] != target[i]) { n       int l = -1, r = -1; n       for (int j = 0; j < source[i].size(); j++) { n         if (source[i][j] != target[i][j]) r = j; n         if (source[i][j] != target[i][j] && l == -1) l = j; n       } n       ranges[i] = {l, r}; n       if (s.empty()) { n         s = source[i].substr(l, r - l + 1); n         t = target[i].substr(l, r - l + 1); n         prefix = source[i].substr(0, l); n         suffix = source[i].substr(r + 1); n         reverse(prefix.begin(), prefix.end()); n       } else { n         if (s != source[i].substr(l, r - l + 1) || n             t != target[i].substr(l, r - l + 1)) { n           cout <<  NO n ; n           return 0; n         } n         string cprefix = source[i].substr(0, l); n         string csuffix = source[i].substr(r + 1); n         reverse(cprefix.begin(), cprefix.end()); n         string p, ss; n         for (int j = 0; n              j < min(cprefix.size(), prefix.size()) && cprefix[j] == prefix[j]; n              j++) { n           p.push_back(prefix[j]); n         } n         for (int j = 0; n              j < min(csuffix.size(), suffix.size()) && csuffix[j] == suffix[j]; n              j++) { n           ss.push_back(suffix[j]); n         } n         prefix = p; n         suffix = ss; n       } n     } n   } n   reverse(prefix.begin(), prefix.end()); n   s = prefix + s + suffix; n   t = prefix + t + suffix; n   for (int i = 0; i < n; i++) { n     if (!check(source[i], target[i], s, t)) { n       cout <<  NO n ; n       return 0; n     } n   } n   cout <<  YES n ; n   cout << s <<   n ; n   cout << t <<   n ; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n template <typename T> n inline bool inrange(T a, T l, T r) { n   if (l > r) swap(l, r); n   return (a >= l and a <= r); n } n template <typename T, typename U> n inline bool exist(T val, U &any) { n   return (any.find(val) != any.end()); n } n template <typename T> n inline void inp(T &any) { n   cin >> any; n } n template <typename T, typename... U> n inline void inp(T &a, U &...b) { n   cin >> a; n   inp(b...); n } n template <typename T> n inline istream &operator>>(istream &in, vector<T> &a) { n   for (auto &x : a) in >> x; n   return in; n } n template <typename T, typename U> n inline istream &operator>>(istream &in, pair<T, U> &a) { n   in >> a.first >> a.second; n   return in; n } n void solve(long long int &T) { n   long long int n; n   std::cin >> n; n   vector<long long int> a(n), b(n); n   std::cin >> a >> b; n   vector<long long int> sol(n); n   for (long long int i = (0); i < (n); i++) sol[a[i] - 1] = b[i]; n   for (auto &X : sol) std::cout << X <<    ; n   std::cout <<   n ; n } n int main() { n   ios::sync_with_stdio(0); n   cin.tie(0); n   cout.tie(0); n   ; n   int t = 1; n   for (long long int i = (1); i < (t + 1); i++) { n     cerr <<  Case #  << i <<   n ; n     solve(i); n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int main() { n   int n; n   cin >> n; n   vector<vector<int>> v; n   for (int i = 0; i < (n); ++i) { n     int l; n     cin >> l; n     vector<int> temp; n     for (int j = 0; j < (l); ++j) { n       int ele; n       cin >> ele; n       temp.push_back(ele); n     } n     v.push_back(temp); n   } n   vector<int> maxi; n   int cnt_no_ascent = 0; n   bool ascent[n]; n   int mini_arr[n]; n   int maxi_arr[n]; n   for (int i = 0; i < (n); ++i) ascent[i] = false; n   for (int i = 0; i < (n); ++i) { n     int flag = 0; n     int maxi_el = INT_MIN; n     int mini_el = INT_MAX; n     for (int j = 0; j < (v[i].size()); ++j) { n       if (v[i][j] > maxi_el) { n         maxi_el = v[i][j]; n       } n       if (v[i][j] < mini_el) { n         mini_el = v[i][j]; n       } n       if (j != 0 && v[i][j - 1] < v[i][j]) { n         ++cnt_no_ascent; n         flag = 1; n         ascent[i] = true; n         break; n       } n     } n     if (flag == 0) { n       mini_arr[i] = mini_el; n       maxi.push_back(maxi_el); n       maxi_arr[i] = maxi_el; n     } n   } n   long long ans = ((long long)cnt_no_ascent * (long long)n); n   sort(maxi.begin(), maxi.end()); n   for (int i = 0; i < (n); ++i) { n     if (ascent[i] == true) continue; n     auto it = upper_bound(maxi.begin(), maxi.end(), mini_arr[i]); n     ans = ans + (long long)(maxi.end() - it); n     ans = ans + cnt_no_ascent; n   } n   cout << ans << endl; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int MAX = 1e6 + 6; n int main() { n   int n; n   cin >> n; n   string str =   ; n   while (n) { n     str += ((n % 2) +  0 ); n     n /= 2; n   } n   reverse(str.begin(), str.end()); n   while (str.size() < 6) str =  0  + str; n   string ss =   ; n   ss += str[0]; n   ss += str[5]; n   ss += str[3]; n   ss += str[2]; n   ss += str[4]; n   ss += str[1]; n   int ret = 0; n   for (auto x : ss) ret = ret * 2 + (x -  0 ); n   cout << ret <<   n ; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int getint() { n   unsigned int c; n   int x = 0; n   while (((c = getchar()) -  0 ) >= 10) { n     if (c ==  - ) return -getint(); n     if (!~c) exit(0); n   } n   do { n     x = (x << 3) + (x << 1) + (c -  0 ); n   } while (((c = getchar()) -  0 ) < 10); n   return x; n } n int n, nn, sum; n int as[20]; n int c[10][10]; n bool used[20]; n int num[20], have[20], ns; n int perm[20][20][20]; n void dfs(int row, int col, int rows, int cols, int dir, int cnt) { n   int i, j, k; n   if (cnt == nn) { n     int tmp1 = 0, tmp2 = 0; n     for (i = 0; i < n; i++) { n       tmp1 += c[i][i]; n       tmp2 += c[i][n - 1 - i]; n     } n     if (tmp1 != sum) return; n     if (tmp2 != sum) return; n     tmp1 = tmp2 = 0; n     for (i = 0; i < n; i++) { n       tmp1 += c[n - 1][i]; n       tmp2 += c[i][n - 1]; n     } n     if (tmp1 != sum) return; n     if (tmp2 != sum) return; n     for (i = 0; i < n; i++) { n       for (j = 0; j < n; j++) { n         if (j) putchar(   ); n         printf( %d , c[i][j]); n       } n       puts(  ); n     } n     exit(0); n   } n   if (row == n or col == n) { n     int tmp = 0; n     if (dir == 0) { n       for (i = 0; i < n; i++) tmp += c[row][i]; n       if (tmp != sum) return; n     } else { n       for (i = 0; i < n; i++) tmp += c[i][col]; n       if (tmp != sum) return; n     } n     if (dir == 0) { n       dfs(rows + 1, cols, rows + 1, cols, 1, cnt); n     } else { n       dfs(rows, cols + 1, rows, cols + 1, 0, cnt); n     } n   } n   for (i = 0; i < ns; i++) { n     int d = perm[row][col][i]; n     if (have[d]) { n       have[d]--; n       c[row][col] = num[d]; n       if (dir == 0) dfs(row, col + 1, rows, cols, dir, cnt + 1); n       if (dir == 1) dfs(row + 1, col, rows, cols, dir, cnt + 1); n       have[d]++; n     } n   } n } n int main() { n   int i, j, tcc, tc = 1 << 28; n   for (tcc = 0; tcc < tc; tcc++) { n     n = getint(), nn = n * n, sum = 0; n     for (i = 0; i < nn; i++) as[i] = getint(), sum += as[i]; n     sum /= n; n     for (i = 0; i < nn; i++) num[i] = as[i]; n     sort(num, num + nn); n     ns = unique(num, num + nn) - num; n     for (i = 0; i < ns; i++) { n       for (j = 0; j < nn; j++) n         if (num[i] == as[j]) have[i]++; n     } n     for (i = 0; i < n; i++) n       for (j = 0; j < n; j++) { n         for (int k = 0; k < ns; k++) perm[i][j][k] = k; n         random_shuffle(perm[i][j], perm[i][j] + ns); n       } n     printf( %d n , sum); n     dfs(0, 0, 0, 0, 0, 0); n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int MXX = 3e5 + 5; n int n, m; n int a[MXX], ans[MXX]; n bool ok(int x) { n   int mx = m - 1; n   for (int i = n - 1; i >= 0; i--) { n     if (a[i] <= mx) { n       if (a[i] + x >= mx) { n         ans[i] = mx; n       } else { n         ans[i] = a[i] + x; n       } n     } else { n       if (a[i] + x >= mx + m) n         ans[i] = mx; n       else n         ans[i] = (a[i] + x) % m; n     } n     mx = ans[i]; n   } n   for (int i = 0; i < n - 1; i++) { n     if (ans[i] > ans[i + 1]) { n       return false; n     } n   } n   return true; n } n bool ok2() { n   for (int i = 0; i < n - 1; i++) { n     if (a[i] > a[i + 1]) { n       return false; n     } n   } n   return true; n } n int main() { n   cin >> n >> m; n   for (int i = 0; i < n; i++) { n     cin >> a[i]; n   } n   if (ok2()) { n     return cout << 0 << endl, 0; n   } n   int lo = 0, hi = m - 1, mid, ans = -1; n   while (lo <= hi) { n     mid = (lo + hi) / 2; n     if (ok(mid)) { n       ans = mid; n       hi = mid - 1; n     } else { n       lo = mid + 1; n     } n   } n   cout << ans << endl; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n long long gcd(long long a, long long b); n void print(long long arr[], long long n); n void printv(vector<long long> arr); n signed main() { n   long long t; n   cin >> t; n   while (t--) { n     long long n; n     cin >> n; n     long long k; n     cin >> k; n     vector<long long> arr(n); n     unordered_map<long long, long long> m; n     for (long long i = 0; i < n; i++) { n       cin >> arr[i]; n       m[arr[i]]++; n     } n     vector<long long> tem = arr; n     sort(tem.begin(), tem.end()); n     set<long long> a, b; n     if (arr[0] * 2 != k) a.insert(arr[0]); n     for (long long i = 1; i < n; i++) { n       if (arr[i] * 2 == k) continue; n       if (a.find(k - arr[i]) == a.end()) n         a.insert(arr[i]); n       else n         b.insert(arr[i]); n     } n     long long ii = 0; n     for (long long i = 0; i < n; i++) { n       if (a.find(arr[i]) != a.end()) n         cout << 1 <<    ; n       else if (b.find(arr[i]) != b.end()) n         cout << 0 <<    ; n       else { n         cout << ii <<    ; n         ii = (ii + 1) % 2; n       } n     } n     cout <<   n ; n   } n } n long long gcd(long long a, long long b) { n   if (b == 0) return a; n   return gcd(b, a % b); n } n void print(long long arr[], long long n) { n   for (long long i = 0; i < n; i++) cout << arr[i] <<    ; n   cout <<   n ; n } n void printv(vector<long long> arr) { n   for (long long i = 0; i < arr.size(); i++) cout << arr[i] <<    ; n   cout <<   n ; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int par[300005]; n int vis[300005]; n unordered_map<int, int> edge[300005]; n int d[300005]; n vector<int> ans; n int find(int u) { return par[u] == u ? u : par[u] = find(par[u]); } n void join(int u, int v) { n   u = find(u); n   v = find(v); n   if (u > v) swap(u, v); n   par[v] = u; n } n void dfs(int u, int pr) { n   if (vis[u]) return; n   vis[u] = 1; n   for (auto i : edge[u]) { n     dfs(i.first, u); n   } n   if (d[u] == 1) { n     ans.push_back(edge[u][pr]); n     d[pr]++; n     d[pr] %= 2; n     return; n   } n } n int main() { n   ios_base::sync_with_stdio(false); n   memset(vis, 0, sizeof vis); n   int n, k, u, v; n   cin >> n >> k; n   for (int i = 1; i <= n; i++) { n     edge[i].clear(); n     par[i] = i; n     cin >> d[i]; n   } n   for (int i = 1; i <= k; i++) { n     cin >> u >> v; n     if (find(u) != find(v)) { n       edge[u][v] = i; n       edge[v][u] = i; n       join(u, v); n     } n   } n   int sum = 0; n   int avail = 0; n   for (int i = 1; i <= n; i++) { n     if (d[i] == -1) { n       avail++; n     } else n       sum += d[i]; n   } n   if (sum % 2 && !avail) { n     cout << -1 << endl; n     return 0; n   } n   for (int i = 1; i <= n; i++) { n     if (d[i] == -1) { n       if (sum % 2 == 1) { n         d[i] = 1; n         sum++; n       } else n         d[i] = 0; n     } n   } n   dfs(1, 0); n   cout << ans.size() << endl; n   for (int i = 0; i < ans.size(); i++) { n     cout << ans[i] <<    ; n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const long long MAX = 1e6 + 100; n const long long mod = 1e9 + 7; n const long long inf = 1e18 + 12; n vector<long long> arr(MAX); n map<long long, long long> mm; n int main() { n   ios_base::sync_with_stdio(false); n   cout.tie(NULL); n   cout.tie(NULL); n   ; n   long long tt = 1; n   while (tt--) { n     long long n; n     cin >> n; n     long long a[n]; n     for (long long i = 0; i < n; i++) cin >> a[i]; n     long long w = 0, b = 0; n     long long i = 0; n     while (i < n) { n       if (i % 2 == 0) { n         w += (a[i] + 1) / 2; n         b += (a[i]) / 2; n       } else { n         w += a[i] / 2; n         b += (a[i] + 1) / 2; n       } n       i++; n     } n     cout << min(w, b); n   } n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int MOD = 998244353; n const int N = 200005; n const double PI = 4 * atan(1); n const long long MAX = 9223372036854775807; n int dx[] = {1, -1, 0, 0, 1, -1, 1, -1}; n int dy[] = {0, 0, 1, -1, 1, 1, -1, -1}; n long long gcd(long long a, long long b) { return (b == 0 ? a : gcd(b, a % b)); } n long long lcm(long long a, long long b) { return a * (b / gcd(a, b)); } n bool issquare(long long w) { return trunc(sqrt(w)) * trunc(sqrt(w)) == w; } n bool isprime(long long u) { n   for (long long i = 2; i <= (int)sqrt(u); i++) { n     if (u % i == 0) return 0; n   } n   return 1; n } n long long mod(long long to_mod, long long MOD) { n   to_mod %= MOD; n   while (to_mod < 0) to_mod += MOD; n   return to_mod % MOD; n } n long long moduloMultiplication(long long a, long long b, long long mod) { n   long long res = 0; n   a %= mod; n   while (b) { n     if (b & 1) res = (res + a) % mod; n     a = (2 * a) % mod; n     b >>= 1; n   } n   return res; n } n long long power(long long x, long long y) { n   long long res = 1; n   x = x; n   while (y > 0) { n     if (y & 1) res = (res * x); n     y = y >> 1; n     x = (x * x); n   } n   return res; n } n long long n, m, x, y, t, k, z, w, l, r, ans; n bool vis[N]; n long long a[N]; n long long lvl[N]; n map<long long, vector<long long> > adj; n map<long long, long long> maa; n void bfs(long long src) { n   queue<long long> q; n   q.push(src); n   lvl[src] = 1; n   while (!q.empty()) { n     long long ras = q.front(); n     q.pop(); n     if (lvl[ras] % 2 == 0) { n       vis[ras] = 1; n       continue; n     } n     for (auto t : adj[ras]) { n       if (vis[t]) continue; n       lvl[t] = lvl[ras] + 1; n       q.push(t); n     } n   } n } n int main() { n   ios::sync_with_stdio(0); n   cin.tie(NULL); n   cin >> n; n   for (int i = 0; i < n; i++) { n     cin >> a[i]; n     maa[a[i]] = i; n   } n   for (int j = 0; j < n; j++) { n     k = a[j]; n     for (int i = j; i < n; i += k) { n       if (a[i] > k) adj[i].push_back(j); n     } n     for (int i = j; i >= 0; i -= k) { n       if (a[i] > k) adj[i].push_back(j); n     } n   } n   for (int i = n; i >= 1; i--) { n     if (vis[maa[i]]) continue; n     bfs(maa[i]); n   } n   for (int i = 0; i < n; i++) { n     if (vis[i]) n       cout <<  A ; n     else n       cout <<  B ; n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int N = 1e6 + 7; n int n, lim, a[N], mn[N], mx[N], suf[N]; n long long ans; n int main() { n   scanf( %d%d , &n, &lim); n   for (int i = 1; i <= lim; i++) mn[i] = n + 1; n   for (int i = 1; i <= n; i++) { n     scanf( %d , &a[i]); n     mn[a[i]] = min(mn[a[i]], i); n     mx[a[i]] = max(mx[a[i]], i); n   } n   int L = lim, R = 1, pre = mx[1]; n   for (int i = 1; i < lim; i++) { n     pre = max(pre, mx[i]); n     if (pre > mn[i + 1]) { n       L = i; n       break; n     } n   } n   if (L == lim) { n     cout << 1ll * lim * (lim + 1) / 2; n     return 0; n   } n   pre = mn[lim]; n   for (int i = lim; i > 1; i--) { n     pre = min(pre, mn[i]); n     if (mx[i - 1] > pre) { n       R = i; n       break; n     } n   } n   ans = lim - R + 2; n   suf[lim] = mn[lim]; n   for (int i = lim - 1; i >= R; i--) suf[i] = min(suf[i + 1], mn[i]); n   pre = mx[1]; n   for (int i = 1, j = R; i <= L; i++) { n     pre = max(pre, mx[i]); n     while (j <= lim && pre > suf[j]) j++; n     ans += lim - j + 2; n     if (j == i + 1) ans--; n   } n   cout << ans; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n #pragma warning(disable : 4996) n using namespace std; n int n, m; n int a[300000]; n int b[300000]; n vector<int> edge[300000]; n int ngood; n int child[300000]; n int good[300000]; n int d[300000]; n int ans; n void back(int now, int parent) { n   child[now] = 1; n   good[now] = b[now]; n   for (auto e : edge[now]) n     if (e != parent) { n       back(e, now); n       child[now] += child[e], good[now] += good[e]; n     } n } n vector<pair<int, int> > v; n void back2(int now, int parent) { n   for (auto e : edge[now]) n     if (e != parent) { n       back2(e, now); n     } n   if (b[now] == 0) { n     d[now] = 0; n     return; n   } n   d[now] = 1; n   int xgood = 0; n   for (auto e : edge[now]) n     if (e != parent) { n       if (child[e] == good[e]) xgood += child[e]; n     } n   d[now] = 1 + xgood; n   for (auto e : edge[now]) n     if (e != parent) { n       d[now] = n           max(d[now], 1 + d[e] + xgood - (child[e] == good[e] ? child[e] : 0)); n     } n   ans = max(ans, d[now]); n   int u = 1 + (n - child[now] == ngood - good[now] ? n - child[now] : 0); n   v.clear(); n   for (auto e : edge[now]) n     if (e != parent) { n       v.emplace_back(d[e], e); n     } n   sort((v).begin(), (v).end(), greater<pair<int, int> >()); n   for (int i = 0; i < 8 && i < v.size(); i++) { n     for (int j = i + 1; j < 8 && j < v.size(); j++) { n       ans = max( n           ans, u + v[i].first + v[j].first + xgood - n                    (child[v[i].second] == good[v[i].second] ? child[v[i].second] n                                                             : 0) - n                    (child[v[j].second] == good[v[j].second] ? child[v[j].second] n                                                             : 0)); n     } n   } n } n int param(int x) { n   int i, j, k; n   for (i = 0; i < n; i++) b[i] = a[i] >= x; n   ngood = count(b, b + n, 1); n   back(0, -1); n   ans = 0; n   back2(0, -1); n   return ans >= m; n } n int main() { n   int i, j, k; n   cin >> n >> m; n   for (i = 0; i < n; i++) scanf( %d , &a[i]); n   for (i = 0; i < n - 1; i++) { n     int x, y; n     scanf( %d%d , &x, &y), x--, y--; n     edge[x].push_back(y), edge[y].push_back(x); n   } n   int low = 0, high = 1000001, mid; n   while (low <= high) { n     mid = (low + high) / 2; n     if (param(mid)) n       low = mid + 1; n     else n       high = mid - 1; n   } n   cout << high; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int N = 5e4 + 10, max_node = N * 200; n int n, m, q, C, c[N], a[N], size[N], heavy[N], dfn[N], dfn_t, top[N], father[N], n     tt, lo[max_node], ro[max_node], addv[max_node]; n long long sum[max_node], sum2[max_node]; n vector<int> graph[N], nodes[N]; n void dfs1(int u) { n   size[u] = 1; n   for (auto v : graph[u]) { n     dfs1(v); n     size[u] += size[v]; n     if (size[v] > size[heavy[u]]) { n       heavy[u] = v; n     } n   } n } n void dfs2(int u, int t) { n   top[u] = t; n   dfn[u] = ++dfn_t; n   if (heavy[u]) { n     dfs2(heavy[u], t); n     for (auto v : graph[u]) { n       if (v != heavy[u]) { n         dfs2(v, v); n       } n     } n   } n } n void add(int l, int r, int o, int v) { n   addv[o] += v; n   sum2[o] += ((sum[o] << 1) + (r - l + 1) * v) * v; n   sum[o] += (r - l + 1) * v; n } n void push_down(int l, int r, int o) { n   if (addv[o]) { n     int mid = l + r >> 1; n     if (!lo[o]) { n       lo[o] = ++tt; n     } n     if (!ro[o]) { n       ro[o] = ++tt; n     } n     add(l, mid, lo[o], addv[o]); n     add(mid + 1, r, ro[o], addv[o]); n     addv[o] = 0; n   } n } n void push_up(int o) { n   sum[o] = sum[lo[o]] + sum[ro[o]]; n   sum2[o] = sum2[lo[o]] + sum2[ro[o]]; n } n void modify(int l, int r, int& o, int ql, int qr, int v) { n   if (!o) { n     o = ++tt; n   } n   if (ql <= l && r <= qr) { n     return add(l, r, o, v); n   } else { n     int mid = l + r >> 1; n     push_down(l, r, o); n     if (ql <= mid) { n       modify(l, mid, lo[o], ql, qr, v); n     } n     if (qr > mid) { n       modify(mid + 1, r, ro[o], ql, qr, v); n     } n     push_up(o); n   } n } n struct info_t { n   int root; n   void init(vector<int>& nodes) { n     for (auto v : nodes) { n       for (int x = v; x; x = father[top[x]]) { n         modify(1, n, root, dfn[top[x]], dfn[x], 1); n       } n     } n   } n   void update(int u, int type) { n     for (int x = u; x; x = father[top[x]]) { n       modify(1, n, root, dfn[top[x]], dfn[x], type); n     } n   } n   double get_answer(int c) { n     double result = (double)C * C; n     result -= 2.0 * C * c * sum[root] / n; n     result += 1.0 * c * c * sum2[root] / n; n     return result; n   } n } info[N]; n int main() { n   scanf( %d%d%d%d , &n, &m, &q, &C); n   for (int i = 1; i <= n; ++i) { n     scanf( %d , &a[i]); n     nodes[a[i]].push_back(i); n   } n   for (int i = 2; i <= n; ++i) { n     scanf( %d , &father[i]); n     graph[father[i]].push_back(i); n   } n   for (int i = 1; i <= m; ++i) { n     scanf( %d , &c[i]); n   } n   dfs1(1); n   dfs2(1, 1); n   for (int i = 1; i <= m; ++i) { n     info[i].init(nodes[i]); n   } n   while (q--) { n     int type, x, w; n     scanf( %d , &type); n     if (type == 1) { n       scanf( %d%d , &x, &w); n       info[a[x]].update(x, -1); n       a[x] = w; n       info[a[x]].update(x, 1); n     } else { n       scanf( %d , &x); n       printf( %.12lf n , info[x].get_answer(c[x])); n     } n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n const long long int mod = 1000000007; n const long long int AM = 2e6 + 5; n using namespace std; n long long int powm(long long int a, long long int b, long long int n) { n   long long int x = 1, y = a; n   while (b > 0) { n     if (b % 2 == 1) { n       x = (x * y) % n; n     } n     y = (y * y) % n; n     b /= 2; n   } n   return x % n; n } n long long int pow(long long int x, long long int y) { n   long long int res = 1; n   while (y > 0) { n     if (y & 1) res = ((res) * (x)); n     y = y >> 1; n     x = ((x) * (x)); n   } n   return res; n } n long long int fact(long long int n) { n   long long int ans = 1; n   for (long long int i = 1; i <= n; i++) ans *= i; n   return ans; n } n long long int nCr(long long int n, long long int r) { n   if (r > n - r) r = n - r; n   long long int ans = 1, i; n   for (i = 1; i <= r; i++) { n     ans *= n - r + i; n     ans /= i; n   } n   return ans; n } n bool isPrime(long long int n) { n   if (n <= 1) return false; n   for (long long int i = 2; i < n; i++) n     if (n % i == 0) return false; n   return true; n } n int main() { n   ios_base::sync_with_stdio(false); n   cin.tie(NULL); n   ; n   long long int n; n   cin >> n; n   long long int s = sqrt(n), f1, f2; n   if (s * s >= n) { n     f1 = s; n     f2 = s; n   } else if (s * (s + 1) >= n) { n     f1 = s; n     f2 = s + 1; n   } else { n     f1 = s + 1; n     f2 = s + 1; n   } n   cout << f1 + f2; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int f[305][305], rf[305][305], g[305][305], rg[305][305]; n int a[305][305]; n int n, m, s, t1, t2, t3; n int ans1, ans2, ans3, ans4, Min = 1999999999; n set<pair<int, int> > S; n int C(int first, int second) { n   if (first < second) return t2; n   if (first == second) return t1; n   return t3; n } n int G(int i, int j, int k, int l) { n   int ans = (f[i][l] - f[i][k]) + (rf[j][l] - rf[j][k]); n   ans += (g[l][j] - g[l][i]); n   return ans; n } n int main() { n   scanf( %d %d %d , &n, &m, &s); n   scanf( %d %d %d , &t1, &t2, &t3); n   for (int i = 1; i <= n; i++) n     for (int j = 1; j <= m; j++) scanf( %d , &a[i][j]); n   for (int i = 1; i <= n; i++) { n     f[i][1] = 0; n     for (int j = 2; j <= m; j++) n       f[i][j] = f[i][j - 1] + C(a[i][j - 1], a[i][j]); n     rf[i][1] = 0; n     for (int j = 2; j <= m; j++) n       rf[i][j] = rf[i][j - 1] + C(a[i][j], a[i][j - 1]); n   } n   for (int i = 1; i <= m; i++) { n     g[i][1] = 0; n     for (int j = 2; j <= n; j++) n       g[i][j] = g[i][j - 1] + C(a[j - 1][i], a[j][i]); n     rg[i][1] = 0; n     for (int j = 2; j <= n; j++) n       rg[i][j] = rg[i][j - 1] + C(a[j][i], a[j - 1][i]); n   } n   for (int i = 1; i <= n; i++) n     for (int j = i + 2; j <= n; j++) { n       S.clear(); n       for (int k = m; k >= 1; k--) { n         if (k <= m - 2) S.insert(make_pair(G(i, j, 1, k + 2), k + 2)); n         if (S.empty()) continue; n         int tmp = s + f[i][k] + rf[j][k] - rg[k][j] + rg[k][i]; n         set<pair<int, int> >::iterator it = S.upper_bound(make_pair(tmp, 0)); n         if (it != S.end()) { n           pair<int, int> tmpg = *it; n           if (abs(tmpg.first - tmp) < Min) { n             Min = abs(tmpg.first - tmp); n             ans1 = i, ans2 = j, ans3 = k, ans4 = tmpg.second; n           } n         } n         if (it == S.begin()) continue; n         it--; n         pair<int, int> tmpg = *it; n         if (abs(tmpg.first - tmp) < Min) { n           Min = abs(tmpg.first - tmp); n           ans1 = i, ans2 = j, ans3 = k, ans4 = tmpg.second; n         } n       } n     } n   printf( %d %d %d %d n , ans1, ans3, ans2, ans4); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n template <class T> n T abs(T x) { n   return x > 0 ? x : -x; n } n const int MAXINT = 1111 * 1111 * 1111; n const long long MAXLINT = MAXINT * 1ll * MAXINT; n const long double EPS = 1e-10; n using namespace std; n int n, m, x, y, z, p; n int a, b; n void reverse_left() { n   int aa = a, bb = b; n   a = m - b + 1; n   b = aa; n   swap(n, m); n } n void reverse_middle() { b = m - b + 1; } n void reverse_right() { n   int aa = a, bb = b; n   b = n - a + 1; n   a = bb; n   swap(n, m); n } n void solve() { n   cin >> n >> m >> x >> y >> z >> p; n   int N = n, M = m; n   x %= 4; n   z %= 4; n   y %= 2; n   while (p--) { n     n = N; n     m = M; n     cin >> a >> b; n     for (int i = 0; i < x; i++) reverse_right(); n     for (int i = 0; i < y; i++) reverse_middle(); n     for (int i = 0; i < z; i++) reverse_left(); n     cout << a <<     << b << endl; n   } n } n int main() { solve(); } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n set<long long> s; n map<long long, long long> m; n vector<long long> v; n long long n, a[100010], b[100010], dp[100010], mx = 0; n bool mark[100010]; n int main() { n   ios_base::sync_with_stdio(false); n   cin >> n; n   for (long long i = 1; i <= n; i++) { n     cin >> a[i]; n     if (i == 1) n       dp[i] = a[i]; n     else n       dp[i] = dp[i - 1] + a[i]; n   } n   for (long long i = 1; i <= n; i++) cin >> b[i]; n   for (long long i = n; i > 0; i--) { n     v.push_back(mx); n     long long r, l; n     mark[b[i]] = 1; n     if (b[i] < n) { n       if (mark[b[i] + 1] == 1) { n         set<long long>::iterator it = s.lower_bound(b[i]); n         r = *it; n       } else n         r = b[i]; n     } else n       r = b[i]; n     s.insert(r); n     if (b[i] > 1) { n       if (mark[b[i] - 1] == 1) { n         s.erase(b[i] - 1); n       } n     } n     m[r] = m[b[i] - 1] + dp[r] - dp[b[i] - 1]; n     if (m[r] > mx) mx = m[r]; n   } n   for (long long i = v.size() - 1; i >= 0; i--) cout << v[i] << endl; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n void _print(long long t) { cerr << t; } n void _print(int t) { cerr << t; } n void _print(string t) { cerr << t; } n void _print(char t) { cerr << t; } n void _print(long double t) { cerr << t; } n void _print(double t) { cerr << t; } n void _print(unsigned long long t) { cerr << t; } n template <class T, class V> n void _print(pair<T, V> p); n template <class T> n void _print(vector<T> v); n template <class T> n void _print(vector<vector<T>> v); n template <class T> n void _print(set<T> v); n template <class T, class V> n void _print(map<T, V> v); n template <class T> n void _print(multiset<T> v); n template <class T, class V> n void _print(pair<T, V> p) { n   cerr <<  { ; n   _print(p.first); n   cerr <<  , ; n   _print(p.second); n   cerr <<  } ; n } n template <class T> n void _print(vector<T> v) { n   cerr <<  [  ; n   for (T i : v) { n     _print(i); n     cerr <<    ; n   } n   cerr <<  ] ; n } n template <class T> n void _print(vector<vector<T>> v) { n   cerr <<  ==>  << endl; n   for (vector<T> vec : v) { n     for (T i : vec) { n       _print(i); n       cerr <<    ; n     } n     cerr << endl; n   } n } n template <class T> n void _print(set<T> v) { n   cerr <<  [  ; n   for (T i : v) { n     _print(i); n     cerr <<    ; n   } n   cerr <<  ] ; n } n template <class T> n void _print(multiset<T> v) { n   cerr <<  [  ; n   for (T i : v) { n     _print(i); n     cerr <<    ; n   } n   cerr <<  ] ; n } n template <class T, class V> n void _print(map<T, V> v) { n   cerr <<  [  ; n   for (auto i : v) { n     _print(i); n     cerr <<    ; n   } n   cerr <<  ] ; n } n mt19937_64 rang( n     chrono::high_resolution_clock::now().time_since_epoch().count()); n int rng(int lim) { n   uniform_int_distribution<int> uid(0, lim - 1); n   return uid(rang); n } n const int INF = 0x3f3f3f3f; n const int mod = 1e9 + 7; n long long mod_exp(long long a, long long b) { n   a %= mod; n   if (a == 0) return 0LL; n   long long res = 1LL; n   while (b > 0) { n     if (b & 1) res = (res * a) % mod; n     a = (a * a) % mod; n     b >>= 1; n   } n   return res; n } n long long mod_inv(long long a) { return mod_exp(a, mod - 2); } n long long GCD(long long a, long long b) { return (b == 0) ? a : GCD(b, a % b); } n void solve() { n   long long a1, a2, a3, a4, a5, a6; n   cin >> a1 >> a2 >> a3 >> a4 >> a5 >> a6; n   cout << ((a1 + a2 + a3) * (a1 + a2 + a3)) - (a1 * a1) - (a3 * a3) - (a5 * a5); n } n int main() { n   ios_base::sync_with_stdio(false), cin.tie(nullptr), cout.tie(nullptr); n   srand(chrono::high_resolution_clock::now().time_since_epoch().count()); n   int t = 1; n   while (t--) { n     solve(); n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n char s[1005]; n char t[1000005]; n int main() { n   scanf( %s , s); n   scanf( %s , t); n   int len1 = strlen(s); n   int len2 = strlen(t); n   int le = 0x3f3f3f3f; n   int ri = 0x3f3f3f3f; n   for (int i = 0, j = 0; j < len2; j++) { n     if (s[i] == t[j]) i++; n     if (i == len1) { n       le = j; n       break; n     } n   } n   for (int i = len1 - 1, j = len2 - 1; j >= 0; j--) { n     if (s[i] == t[j]) i--; n     if (i == -1) { n       ri = j; n       break; n     } n   } n   if ((le - ri) == (len1 - 1)) n     cout <<  0  << endl; n   else { n     int ans = ri - le; n     cout << ans << endl; n   } n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n int N, K; n std::string S; n int main() { n   std::cin >> N >> K; n   std::cin >> S; n   std::string t = S; n   std::string s =   ; n   for (int l = 1; l < N; ++l) { n     if (S.substr(0, l) == S.substr(N - l, l)) { n       t = S.substr(0, N - l); n       s = S.substr(N - l, l); n     } n   } n   while (K--) std::cout << t; n   std::cout << s <<   n ; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n void solve() { n   int n; n   cin >> n; n   vector<int> candies(n); n   for (int i = 0; i < n; i++) cin >> candies[i]; n   int i = 0, j = n - 1; n   int store_a = 0, store_b = 0; n   int turn = 0, sum_a = 0, sum_b = 0; n   while (i <= j) { n     if (turn % 2 == 0) { n       int str_temp = 0; n       while ((str_temp <= store_b) && (i <= j)) { n         str_temp += candies[i]; n         i++; n       } n       store_a = str_temp; n       sum_a += store_a; n     } else { n       int str_tem = 0; n       while ((str_tem <= store_a) && (i <= j)) { n         str_tem += candies[j]; n         j--; n       } n       store_b = str_tem; n       sum_b += store_b; n     } n     turn++; n   } n   cout << turn <<     << sum_a <<     << sum_b <<   n ; n } n int main() { n   int t; n   cin >> t; n   while (t) { n     solve(); n     t--; n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n #pragma GCC optimize( Ofast ,  unroll-loops ,  no-stack-protector ) n using namespace std; n using ll = long long; n using ld = double; n using pii = pair<int, int>; n using uint = unsigned int; n using ull = unsigned long long; n mt19937 rnd(chrono::steady_clock::now().time_since_epoch().count()); n default_random_engine generator; n void solve(); n int main() { n   ios_base::sync_with_stdio(false); n   cin.tie(0); n   cout.tie(0); n   cout << setprecision(16) << fixed; n   cerr << setprecision(16) << fixed; n   int tests = 1; n   for (int test = 1; test <= tests; ++test) { n     solve(); n   } n } n const int INF = 1e9; n struct Point { n   int x, y; n }; n void solve() { n   int n; n   cin >> n; n   vector<Point> p(n); n   for (int i = 0; i < n; ++i) { n     string s; n     cin >> s; n     int a = 0, b = 0; n     for (char c : s) { n       a += c ==  B ; n       b += c ==  N ; n     } n     p[i] = {a, b}; n   } n   int minx = INF, maxx = -INF; n   int miny = INF, maxy = -INF; n   int l = INF, r = -INF; n   for (auto [x, y] : p) { n     minx = min(minx, x); n     maxx = max(maxx, x); n     miny = min(miny, y); n     maxy = max(maxy, y); n     l = min(l, x - y); n     r = max(r, x - y); n   } n   int res = 0; n   res = max(res, (maxx - minx + 1) / 2); n   res = max(res, (maxy - miny + 1) / 2); n   res = max(res, (minx - miny) - l); n   res = max(res, r - (minx - miny)); n   Point best = {minx + res, miny + res}; n   for (int op = 0; op < 2; ++op) { n     int xx = miny + l; n     int yy = miny; n     int cur = 0; n     cur = max(cur, (maxx - xx + 2) / 3); n     cur = max(cur, (maxy - yy + 1) / 2); n     cur = max(cur, (r - l + 1) / 2); n     if (cur < res && cur <= minx - xx) { n       res = cur; n       best = {xx + 2 * res, yy + res}; n       if (op) { n         swap(best.x, best.y); n       } n     } n     for (int i = 0; i < n; ++i) { n       swap(p[i].x, p[i].y); n     } n     swap(minx, miny); n     swap(maxx, maxy); n     r *= -1; n     l *= -1; n     swap(l, r); n   } n   cout << res << endl; n   string ans; n   for (int i = 0; i < best.x; ++i) { n     ans +=  B ; n   } n   for (int i = 0; i < best.y; ++i) { n     ans +=  N ; n   } n   cout << ans << endl; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n signed main() { n   ios_base::sync_with_stdio(false); n   cin.tie(NULL); n   cout.tie(NULL); n   string s; n   cin >> s; n   long long w = 0, o = 0; n   for (long long i = 0; i < s.length() - 1; i++) { n     if (s[i] ==  v  && s[i + 1] ==  v ) n       w++; n     else { n       if (s[i] ==  o ) o++; n     } n   } n   if (s[s.length() - 1] ==  o ) o++; n   long long x = 0, ans = 0; n   for (long long i = 0; i < s.length() - 1; i++) { n     if (s[i] ==  v  && s[i + 1] ==  v ) n       x++; n     else { n       if (s[i] ==  o ) { n         ans += x * (w - x); n       } n     } n   } n   cout << ans; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int main(void) { n   int lins, cols; n   cin >> lins >> cols; n   for (int i(0); i < lins; i++) { n     if (i % 2 == 0) { n       for (int j(0); j < cols; j++) { n         cout <<  # ; n       } n       cout << endl; n     } else if ((i + 1) % 4 == 0) { n       cout <<  # ; n       for (int j(0); j < cols - 1; j++) { n         cout <<  . ; n       } n       cout << endl; n     } else { n       for (int j(0); j < cols - 1; j++) { n         cout <<  . ; n       } n       cout <<  # ; n       cout << endl; n     } n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n void solve() { n   int n; n   cin >> n; n   int arr[n]; n   for (int i = 0; i < n; i++) cin >> arr[i]; n   int ans = 0; n   while (1) { n     int maxi = 0; n     for (int i = 0; i < n; i++) { n       if (arr[i] >= arr[maxi]) maxi = i; n     } n     if (maxi == 0) break; n     ans++; n     arr[0]++; n     arr[maxi]--; n   } n   cout << ans <<   n ; n } n int main() { n   ios_base::sync_with_stdio(false); n   cin.tie(0); n   int t; n   t = 1; n   while (t--) solve(); n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int main() { n   ios::sync_with_stdio(false); n   cin.tie(0); n   cout.tie(0); n   long long n, m, l = 0, p = 0, i, flag = 0, k, j, r = 0, q = 0, t, curr = 0, d, n                   x; n   cin >> n >> x >> k; n   long long a[n]; n   for (long long i = 0; i < n; i++) { n     cin >> a[i]; n   } n   sort(a, a + n); n   for (long long i = 0; i < n; i++) { n     long long r1 = a[i] + (x * k); n     if (a[i] % x == 0) { n       r1--; n     } n     r1 -= r1 % x; n     long long r2 = r1 + x - 1; n     r1 = max(a[i], r1); n     auto it = upper_bound(a, a + n, r2); n     auto it1 = lower_bound(a, a + n, r1); n     p += it - it1; n   } n   cout << p; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n template <typename T, typename T1> n T amax(T &a, T1 b) { n   if (b > a) a = b; n   return a; n } n template <typename T, typename T1> n T amin(T &a, T1 b) { n   if (b < a) a = b; n   return a; n } n bool isPrime(long long x) { n   if (x == 1) return false; n   for (long long i = 2; i * i <= x; i++) { n     if (x % i == 0) { n       return false; n     } n   } n   return true; n } n bool isPowerOfTwo(long long n) { n   if (n == 0) return false; n   return (ceil(log2(n)) == floor(log2(n))); n } n long long gcdByBit(long long a, long long b) { n   if (!a || !b) return a | b; n   unsigned shift = __builtin_ctz(a | b); n   a >>= __builtin_ctzl(a); n   do { n     b >>= __builtin_ctzl(b); n     if (a > b) { n       swap(a, b); n     } n     b -= a; n   } while (b); n   return a << shift; n } n long long powerMod(long long n, long long p) { n   long long res = 1; n   while (p) { n     if (p % 2 == 0) { n       n = n * 1ll * n % 1000000007; n       p /= 2; n     } else { n       res = res * 1ll * n % 1000000007; n       p--; n     } n   } n   return res; n } n long long powerMod2(long long b, long long p, long long m) { n   if (p == 0) return 1; n   return (b * powerMod2(b, p - 1, m) % m) % m; n } n long long fact(long long n) { n   long long res = 1; n   for (long long i = 1; i <= n; i++) { n     res = res * 1ll * i % 1000000007; n   } n   return res; n } n long long nCr(long long n, long long r) { n   return fact(n) * 1ll * powerMod(fact(r), 1000000007 - 2) % 1000000007 * 1ll * n          powerMod(fact(n - r), 1000000007 - 2) % 1000000007; n } n long long arr[300005]; n long long ans[300005]; n long long parent(long long x) { n   if (arr[x] != x) arr[x] = parent(arr[x]); n   return arr[x]; n } n void Chaliye_Shuru_Karte_Hai() { n   for (long long i = 0; i < 300005; i++) arr[i] = i; n   long long n, m; n   cin >> n >> m; n   for (long long i = 0; i < m; i++) { n     long long a, b, c; n     cin >> a >> b >> c; n     for (long long j = parent(a); j <= b; j = parent(j + 1)) { n       if (j != c) ans[j] = c, arr[j] = j + 1; n     } n   } n   for (long long i = 1; i < n + 1; i++) cout << ans[i] <<    ; n } n signed main() { n   ios::sync_with_stdio(0); n   cin.tie(0); n   cout.tie(0); n   long long tc = 1; n   while (tc--) { n     Chaliye_Shuru_Karte_Hai(); n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int N = 2005; n const int M = 101; n const double EPS = 1e-9; n const int INF = 1e9; n long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); } n long long lcm(long long a, long long b) { return a * b / gcd(a, b); } n double getDist(complex<double> a, complex<double> b) { n   return sqrt((a.real() - b.real()) * (a.real() - b.real()) + n               (a.imag() - b.imag()) * (a.imag() - b.imag())); n } n int dcmp(double x, double y) { return fabs(x - y) <= EPS ? 0 : x < y ? -1 : 1; } n long long mod = 1000000007, fib[N], dp[N][N]; n long long power(long long base, int p) { n   if (!p) return 1; n   long long ret = power(base, p / 2); n   ret *= ret; n   ret %= mod; n   if (p & 1) ret *= base, ret %= mod; n   return ret; n } n long long modInverse(int a) { return power(a, mod - 2); } n long long ncr(int n, int r) { n   return (((fib[n] * modInverse(fib[r])) % mod) * modInverse(fib[n - r])) % mod; n } n bool emty[N], taken[N]; n long long solve(int n, int k) { n   if (k == 0) return fib[n]; n   if (k == 1) return (fib[n] * n) % mod; n   if (dp[n][k] != -1) return dp[n][k]; n   long long ret = n       (solve(n, k - 1) * n) % mod + (solve(n + 1, k - 2) * (k - 1)) % mod; n   return dp[n][k] = ret % mod; n } n int main() { n   fib[0] = fib[1] = 1; n   for (int i = 2; i < N; i++) fib[i] = (fib[i - 1] * i) % mod; n   int n, free = 0, k = 0; n   scanf( %d , &n); n   for (int i = 1; i <= n; i++) { n     int a; n     scanf( %d , &a); n     if (a == -1) n       emty[i] = 1; n     else n       taken[a] = 1; n   } n   for (int i = 1; i <= n; i++) { n     if (emty[i] == 1) { n       if (taken[i] == 1) n         free++; n       else n         k++; n     } n   } n   memset(dp, -1, sizeof(dp)); n   cout << solve(free, k); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int main() { n   int n, tmp, sum = 1; n   int map[200000] = {0}; n   cin >> n; n   for (int i = 0; i < n; i++) { n     cin >> tmp; n     if (map[tmp] == 0) { n       map[tmp]++; n     } else n       sum++; n   } n   cout << sum; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n long long N; n long long i, j; n vector<long long> v; n map<long long, long long> mp; n long long arr[200]; n int main() { n   scanf( %lld , &N); n   for (i = 0; i < N; i++) scanf( %lld , &arr[i]); n   sort(arr, arr + N); n   long long ans = 0; n   for (i = 0; i < N; i++) { n     long long get = arr[i]; n     if (mp[arr[i]] == 1) { n       continue; n     } else { n       ans++; n       for (j = 1; j < 200; j++) { n         mp[get * j] = 1; n       } n     } n   } n   cout << ans; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int maxd = 1e6 + 10; n int a[maxd]; n long long sum, ans = 1e18; n vector<long long> b; n int main() { n   int n; n   scanf( %d , &n); n   for (int i = 1; i <= n; i++) scanf( %d , &a[i]); n   for (int i = 1; i <= n; i++) sum += a[i]; n   if (sum == 1) { n     printf( -1 n ); n     return 0; n   } n   for (long long i = 2; i * i <= sum; i++) { n     if (sum % i == 0) { n       b.push_back(i); n       sum /= i; n       i--; n     } n   } n   b.push_back(sum); n   for (auto x : b) { n     long long res = 0; n     sum = 0; n     for (int i = 1; i <= n; i++) { n       sum += a[i]; n       sum %= x; n       res += min(sum, x - sum); n     } n     ans = min(res, ans); n   } n   printf( %lld n , ans); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int n, a; n vector<int> q; n int main() { n   scanf( %d , &n); n   for (int i = 0; i < n; i++) { n     bool w = true; n     for (int j = 0; j < n; j++) { n       scanf( %d , &a); n       if (a == 1 || a == 3) w = false; n     } n     if (w) q.push_back(i + 1); n   } n   printf( %d n , q.size()); n   for (int i = 0; i < q.size(); i++) printf( %d  , q[i]); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n bool can(bool print, int t, long long S, const vector<pair<int, int> >& bugs, n          const vector<pair<int, pair<int, int> > >& st) { n   priority_queue<pair<int, int>, vector<pair<int, int> >, n                  greater<pair<int, int> > > n       pq; n   int ind = bugs.size() - 1; n   int stind = st.size() - 1; n   vector<int> ans(bugs.size()); n   long long cost = 0; n   while (ind >= 0) { n     while (stind >= 0 and st[stind].first >= bugs[ind].first) { n       pq.push(pair<int, int>(st[stind].second.first, st[stind].second.second)); n       --stind; n     } n     if (pq.empty()) return false; n     long long c = pq.top().first; n     int indans = pq.top().second; n     pq.pop(); n     cost += c; n     if (cost > S) return false; n     for (int i = 0; ind >= 0 and i < t; ++i) { n       ans[bugs[ind].second] = indans; n       --ind; n     } n   } n   if (print) { n     for (int i = 0; i < int(bugs.size()); ++i) cout << (i ?     :   ) << ans[i]; n     cout << endl; n   } n   return true; n } n int main() { n   int n, m, s; n   cin >> n >> m >> s; n   vector<pair<int, int> > bugs(m); n   for (int i = 0; i < m; ++i) { n     cin >> bugs[i].first; n     bugs[i].second = i; n   } n   vector<pair<int, pair<int, int> > > st(n); n   for (int i = 0; i < n; ++i) cin >> st[i].first; n   for (int i = 0; i < n; ++i) { n     cin >> st[i].second.first; n     st[i].second.second = i + 1; n   } n   sort(bugs.begin(), bugs.end()); n   sort(st.begin(), st.end()); n   int low = 1, hi = m + 1; n   while (low < hi) { n     int mid = (low + hi) / 2; n     if (can(false, mid, s, bugs, st)) n       hi = mid; n     else n       low = mid + 1; n   } n   if (low == m + 1) n     cout <<  NO  << endl; n   else { n     cout <<  YES  << endl; n     can(true, low, s, bugs, st); n   } n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int MAX = 1e6 + 10; n int n, m, q, pos[MAX], bit[MAX], res[MAX], XOR[MAX]; n pair<int, int> cache[MAX], a[MAX], b[MAX]; n struct Node { n   int lef, rig, tt; n   bool operator<(const Node& other) const { return this->lef < other.lef; } n }; n Node query[MAX]; n void up(int i) { n   int val = a[i].first; n   while (i <= n) { n     bit[i] ^= val; n     i += i & (-i); n   } n } n int get(int i) { n   int res = 0; n   while (i) { n     res ^= bit[i]; n     i -= i & (-i); n   } n   return res; n } n int main() { n   scanf( %d , &n); n   for (int i = 1; i <= n; ++i) { n     scanf( %d , &cache[i].first); n     a[i].first = cache[i].first; n     cache[i].second = i; n   } n   sort(cache + 1, cache + 1 + n); n   for (int i = 1; i <= n; ++i) { n     if (i == 1 || cache[i].first > cache[i - 1].first) ++m; n     a[cache[i].second].second = m; n   } n   for (int i = 1; i <= n; ++i) { n     b[i] = pair<int, int>(pos[a[i].second], i); n     pos[a[i].second] = i; n     XOR[i] = XOR[i - 1] ^ a[i].first; n   } n   sort(b + 1, b + 1 + n); n   scanf( %d , &q); n   for (int i = 1; i <= q; ++i) { n     scanf( %d %d , &query[i], &query[i].rig); n     query[i].tt = i; n   } n   sort(query + 1, query + 1 + q); n   int j = 1; n   for (int i = 1; i <= q; ++i) { n     while (j <= n && b[j].first < query[i].lef) up(b[j++].second); n     res[query[i].tt] = XOR[query[i].rig] ^ XOR[query[i].lef - 1]; n     res[query[i].tt] ^= get(query[i].rig) ^ get(query[i].lef - 1); n   } n   for (int i = 1; i <= q; ++i) printf( %d n , res[i]); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int main() { n   int n, a[100], b[100], i, c = 0; n   cin >> n; n   for (i = 0; i < n; i++) { n     cin >> a[i] >> b[i]; n     if ((b[i] - a[i]) >= 2) c++; n   } n   cout << c; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int main() { n   int n, a = 0, l[101], r[101], k; n   cin >> n; n   for (int i = 0; i < n; i++) { n     cin >> l[i] >> r[i]; n   } n   cin >> k; n   for (int i = 0; i < n; i++) { n     if (k <= r[i]) { n       a++; n     } n   } n   cout << a; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int main(void) { n   int t; n   cin >> t; n   while (t--) { n     int n; n     cin >> n; n     vector<int> ans1, ans2; n     string a, b; n     cin >> a >> b; n     a = a +  0 ; n     b = b +  0 ; n     for (int i = 0; i < n; i++) { n       if (a[i] != a[i + 1]) ans1.push_back(i); n     } n     for (int i = 0; i < n; i++) { n       if (b[i] != b[i + 1]) ans2.push_back(i); n     } n     cout << ans1.size() + ans2.size() <<    ; n     for (int i = 0; i < ans1.size(); i++) cout << ans1[i] + 1 <<    ; n     for (int i = ans2.size() - 1; i >= 0; i--) cout << ans2[i] + 1 <<    ; n     cout <<   n ; n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n long long p, x, a, b, ni, ans; n void e_gcd(long long a, long long b, long long &x, long long &y) { n   if (b == 0) { n     x = 1; n     y = 0; n     return; n   } n   e_gcd(b, a % b, x, y); n   int tmp = x; n   x = y; n   y = tmp - (a / b) * y; n   return; n } n int main() { n   cin >> a >> b >> p >> x; n   long long i, j, s; n   e_gcd(a, p, ni, s); n   a = 1; n   for (j = 1; j <= p - 1; j++) { n     a = a * ni % p; n     i = (j - b * a % p + p) % p; n     long long n = i * (p - 1) + j; n     if (n <= x) ans += (x - n) / (p * (p - 1)) + 1; n   } n   cout << ans << endl; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int main() { n   int n; n   scanf( %d , &n); n   int *a = new int[n]; n   for (int i = 0; i < n; i++) { n     scanf( %d , &a[i]); n   } n   int m; n   scanf( %d , &m); n   int bred[10000]; n   for (int i = 0; i < 10000; i++) bred[i] = 0; n   for (int i = 0; i < m; i++) { n     int b; n     scanf( %d , &b); n     for (int j = 0; j < n; j++) { n       if (b % a[j] != 0) continue; n       bred[b / a[j]]++; n     } n   } n   for (int i = 9999; i >= 0; i--) { n     if (bred[i] != 0) { n       printf( %d , bred[i]); n       break; n     } n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n inline int rd(int f = 1, int x = 0, char ch =    ) { n   while (!isdigit(ch = getchar())) n     if (ch ==  - ) f = -1; n   while (isdigit(ch)) x = x * 10 + ch -  0 , ch = getchar(); n   return f * x; n } n const int N = 1e5 + 5; n int n, a[N], ans; n int main() { n   for (int T = rd(); T--;) { n     n = rd(), ans = 0; n     for (int i = 1; i <= n; ++i) a[i] = rd(); n     for (int i = 2; i <= n; ++i) ans |= a[i - 1] <= a[i]; n     puts(ans ?  YES  :  NO ); n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n long long n, k, q, a[200005], f[200005]; n int main() { n   cin >> n >> k >> q; n   for (int i = 1; i <= n; i++) { n     long long l, r; n     cin >> l >> r; n     a[l]++; n     a[r + 1]--; n   } n   for (int i = 1; i <= 200000; i++) a[i] += a[i - 1]; n   for (int i = 1; i <= 200000; i++) { n     f[i] += f[i - 1]; n     if (a[i] >= k) { n       f[i]++; n     } n   } n   for (int i = 1; i <= q; i++) { n     long long l, r; n     cin >> l >> r; n     cout << f[r] - f[l - 1] << endl; n   } n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n constexpr int INF = 2e9; n int main() { n   int t; n   t = 1; n   while (t--) { n     int n; n     string s; n     cin >> n; n     cin >> s; n     int res = 0; n     for (int d = 25; d >= 0; d--) { n       string tmp =   ; n       for (int i = 0; i < s.size(); i++) { n         int now = s[i] -  a ; n         if (now != d) { n           tmp += s[i]; n         } else { n           if (tmp.back() -  a  == d - 1) { n             res++; n           } else { n             tmp += s[i]; n           } n         } n       } n       swap(s, tmp); n       tmp =   ; n       for (int i = s.size() - 1; i >= 0; i--) { n         int now = s[i] -  a ; n         if (now != d) { n           tmp += s[i]; n         } else { n           if (tmp.back() -  a  == d - 1) { n             res++; n           } else { n             tmp += s[i]; n           } n         } n       } n       reverse(tmp.begin(), tmp.end()); n       swap(s, tmp); n     } n     cout << res << endl; n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int INF = 0x3f3f3f3f; n const int MAXN = 2e5 + 5; n int n, k, d, ansL = 1, ansR = 1, top1, top2; n int a[MAXN], st1[MAXN], st2[MAXN]; n map<int, int> lst; n namespace SegmentTree { n struct Tree { n   int l, r; n   int w, tag; n } tree[MAXN << 2]; n void update(int k) { tree[k].w = min(tree[k << 1].w, tree[k << 1 | 1].w); } n void apply(int k, int val) { n   tree[k].w += val; n   tree[k].tag += val; n } n void down(int k) { n   if (tree[k].tag != 0) { n     apply(k << 1, tree[k].tag); n     apply(k << 1 | 1, tree[k].tag); n     tree[k].tag = 0; n   } n } n void Build(int k, int l, int r) { n   tree[k].l = l; n   tree[k].r = r; n   if (l == r) { n     tree[k].w = l; n     return; n   } n   int mid = (l + r) >> 1; n   Build(k << 1, l, mid); n   Build(k << 1 | 1, mid + 1, r); n   update(k); n } n void Modify(int k, int l, int r, int val) { n   if (tree[k].l >= l && tree[k].r <= r) { n     apply(k, val); n     return; n   } n   down(k); n   int mid = (tree[k].l + tree[k].r) >> 1; n   if (l <= mid) Modify(k << 1, l, r, val); n   if (r > mid) Modify(k << 1 | 1, l, r, val); n   update(k); n } n void Delete(int k, int x) { n   if (tree[k].l == tree[k].r) { n     tree[k].w = INF; n     return; n   } n   down(k); n   int mid = (tree[k].l + tree[k].r) >> 1; n   if (x <= mid) n     Delete(k << 1, x); n   else n     Delete(k << 1 | 1, x); n   update(k); n } n int Query(int k, int l, int r, int x) { n   if (tree[k].w > x) return INF; n   if (tree[k].l == tree[k].r) return tree[k].l; n   if (tree[k].l >= l && tree[k].r <= r) { n     down(k); n     if (tree[k << 1].w <= x) n       return Query(k << 1, l, r, x); n     else n       return Query(k << 1 | 1, l, r, x); n   } else { n     down(k); n     int mid = (tree[k].l + tree[k].r) >> 1; n     int res; n     if (l <= mid) { n       res = Query(k << 1, l, r, x); n       if (res != INF) return res; n     } n     if (r > mid) { n       res = Query(k << 1 | 1, l, r, x); n       if (res != INF) return res; n     } n     return -1; n   } n } n }  // namespace SegmentTree n int main() { n   scanf( %d%d%d , &n, &k, &d); n   for (int i = 1; i <= n; i++) { n     scanf( %d , &a[i]); n     a[i] += INF; n   } n   if (d == 0) { n     for (int i = 1; i <= n; i++) { n       int l = i; n       while (a[i] == a[i + 1] && i < n) i += 1; n       if (i - l + 1 > ansR - ansL + 1) { n         ansL = l; n         ansR = i; n       } n     } n     printf( %d %d n , ansL, ansR); n     return 0; n   } n   SegmentTree::Build(1, 1, n); n   int L = 1; n   for (int R = 1; R <= n; R++) { n     int tmp = L; n     if (a[R] % d == a[R - 1] % d) n       L = max(lst[a[R]] + 1, L); n     else n       L = R; n     lst[a[R]] = R; n     while (tmp < L) { n       SegmentTree::Delete(1, tmp); n       tmp += 1; n     } n     while (top1 && st1[top1] >= L && a[st1[top1]] >= a[R]) { n       SegmentTree::Modify(1, max(L, st1[top1 - 1] + 1), st1[top1], n                           a[st1[top1]] / d); n       top1 -= 1; n     } n     SegmentTree::Modify(1, max(L, st1[top1] + 1), R, -a[R] / d); n     st1[++top1] = R; n     while (top2 && st2[top2] >= L && a[st2[top2]] <= a[R]) { n       SegmentTree::Modify(1, max(L, st2[top2 - 1] + 1), st2[top2], n                           -a[st2[top2]] / d); n       top2 -= 1; n     } n     SegmentTree::Modify(1, max(L, st2[top2] + 1), R, a[R] / d); n     st2[++top2] = R; n     int pos = SegmentTree::Query(1, L, R, k + R); n     if (R - pos + 1 > ansR - ansL + 1) { n       ansL = pos; n       ansR = R; n     } n   } n   printf( %d %d n , ansL, ansR); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n long long add(long long a, long long b, long long mod) { n   return (a % mod + b % mod) % mod; n } n long long sub(long long a, long long b, long long mod) { n   return (a % mod - b % mod + mod) % mod; n } n long long mul(long long a, long long b, long long mod) { n   return (a % mod * b % mod) % mod; n } n long long sumodd(long long num, long long mod) { return mul(num, num, mod); } n long long sumeven(long long num, long long mod) { n   return mul(num, num + 1, mod); n } n long long sumrange(long long st, long long en, long long num) { n   return (num * (st + en) / 2); n } n long long gcd(long long a, long long b) { n   while (b != 0) { n     long long a2 = a; n     a = b; n     b = a2 % b; n   } n   return a; n } n long long lcm(long long a, long long b) { return a / gcd(a, b) * b; } n string makeitbinary(long long n) { n   string s; n   while (n) { n     s = s + (char)((n % 2) +  0 ); n     n /= 2; n   } n   reverse(s.begin(), s.end()); n   return s; n } n bool bit(int num, int i) { return ((num >> i) & 1); } n long long fastpowermod(long long b, long long p, long long mod) { n   long long ans = 1; n   while (p) { n     if (p % 2) { n       ans = mul(ans, b, mod); n     } n     b = mul(b, b, mod); n     p /= 2; n   } n   return ans; n } n long long fastpower(long long b, long long p) { n   long long ans = 1; n   while (p) { n     if (p % 2) { n       ans = ans * b; n     } n     b = b * b; n     p /= 2; n   } n   return ans; n } n double fastpower_double(double b, long long p) { n   double ans = 1; n   while (p) { n     if (p % 2) { n       ans = ans * b; n     } n     b = b * b; n     p /= 2; n   } n   return ans; n } n long long summation_formula(long long n) { return (n * (n + 1) / 2); } n bool lower_vowel(char c) { n   return (c ==  i  || c ==  o  || c ==  u  || c ==  a  || c ==  e ); n } n string bigint_mini(string s1, string s2) { n   if (s1.size() > s2.size()) { n     return s2; n   } else if (s2.size() > s1.size()) { n     return s1; n   } n   for (int i = 0; i < s1.size(); i++) { n     if ((s1[i] -  0 ) > (s2[i] -  0 )) { n       return s2; n     } else if ((s2[i] -  0 ) > (s1[i] -  0 )) { n       return s1; n     } n   } n   return s1; n } n double polygon_area(int n, vector<double> X, vector<double> Y) { n   double area = 0.0; n   int j = n - 1; n   for (int i = 0; i < n; i++) { n     area += (X[j] + X[i]) * (Y[j] - Y[i]); n     j = i; n   } n   return abs(area / 2.0); n } n long long sum_of_digits(string s) { n   long long sum = 0; n   for (int i = 0; i < s.size(); i++) { n     sum += s[i] -  0 ; n   } n   return sum; n } n string makeitbase(long long num, long long base) { n   string s; n   while (num) { n     long long mod = num % base; n     s += (mod +  0 ); n     num /= base; n   } n   reverse(s.begin(), s.end()); n   return s; n } n bool intersect(long long l1, long long r1, long long l2, long long r2) { n   return (max(l1, l2) <= min(r1, r2)); n } n pair<long long, long long> find_intersection(long long l1, long long r1, n                                              long long l2, long long r2) { n   return {max(l1, l2), min(r1, r2)}; n } n long long sum_ranges(long long l, long long r) { n   return summation_formula(r) - summation_formula(l); n } n double power_2(double num) { return num * num; } n struct point { n   int x, y; n }; n long long dist(point p1, point p2) { n   return (p1.x - p2.x) * (p1.x - p2.x) + (p1.y - p2.y) * (p1.y - p2.y); n } n bool square(point p1, point p2, point p3, point p4) { n   long long d2 = dist(p1, p2); n   long long d3 = dist(p1, p3); n   long long d4 = dist(p1, p4); n   if (d2 == d3 && 2 * d2 == d4 && 2 * dist(p2, p4) == dist(p2, p3)) { n     return true; n   } n   if (d3 == d4 && 2 * d3 == d2 && 2 * dist(p3, p2) == dist(p3, p4)) { n     return true; n   } n   if (d2 == d4 && 2 * d2 == d3 && 2 * dist(p2, p3) == dist(p2, p4)) { n     return true; n   } n   return false; n } n const int sz = 1e6 + 1; n long long M = 1e9 + 7; n int main() { n   ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0); n   int n, k, m, t; n   cin >> n >> k >> m >> t; n   while (t--) { n     int x, y; n     cin >> x >> y; n     if (x == 1) { n       if (y <= k) { n         k++; n       } n       n++; n     } else { n       if (k >= 1 && k <= y) { n         n -= (n - y); n       } else { n         n -= y; n         k -= y; n       } n     } n     cout << n <<     << k << endl; n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int main() { n   int n; n   cin >> n; n   int f = n * 1.0 / 3 + 0.5; n   cout << f / 12 <<     << f % 12 << endl; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const long long MAX1 = 3e5 + 10; n long long a, b, c, d, e, cnt, x, y, z, l, r, flag, num[MAX1], mod = 1e10 + 7; n string s; n char p[MAX1]; n long long sta(long long n) { n   for (int i = 1; i < 1000000; ++i) { n     if (i * (i - 1) / 2 == n) return i; n   } n   return 0; n } n int main() { n   cin >> a >> b >> c >> d; n   x = sta(a); n   y = sta(d); n   if (a == 0) { n     if (b == 0 && c == 0 && x && y) { n       for (int i = 0; i < y; ++i) cout << 1; n       return 0; n     } else n       x = 1; n   } n   if (d == 0) { n     if (b == 0 && c == 0 && x && y) { n       for (int i = 0; i < x; ++i) cout << 0; n       return 0; n     } else n       y = 1; n   } n   if (x == 0 || y == 0) { n     cout <<  Impossible ; n     return 0; n   } n   if (x * y != b + c) { n     cout <<  Impossible ; n     return 0; n   } n   cnt = b / y; n   b -= cnt * y; n   x -= cnt; n   for (long long i = 0; i < cnt; ++i) cout << 0; n   for (long long i = 0; i < y - b; ++i) cout << 1; n   y -= y - b; n   if (x && b) cout << 0, --x; n   for (long long i = 0; i < y; ++i) cout << 1; n   for (long long i = 0; i < x; ++i) cout << 0; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n long long bigpow(long long x, long long n) { n   if (n == 0) return 1; n   long long temp = bigpow(x, n / 2); n   return n % 2 == 0 ? (temp * temp) % 1000000009 n                     : (x * ((temp * temp) % 1000000009)) % 1000000009; n } n int main() { n   long long n, m, k, x, t, p, q, gaps, groups; n   cin >> n >> m >> k; n   gaps = n - m; n   groups = m % (k - 1) == 0 ? m / (k - 1) : m / (k - 1) + 1; n   if (gaps >= groups - 1) n     cout << m << endl; n   else { n     x = n - gaps * k; n     t = 2 * (bigpow(2, x / k) - 1) * k + x % k; n     t += gaps * (k - 1); n     cout << t % 1000000009 << endl; n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n inline long long read() { n   long long x = 0, f = 1; n   char s = getchar(); n   while (s <  0  || s >  9 ) { n     if (s ==  - ) f *= -1; n     s = getchar(); n   } n   while (s >=  0  && s <=  9 ) { n     x = (x << 1) + (x << 3) + s -  0 ; n     s = getchar(); n   } n   return x * f; n } n int n = read(), w[5], dp[1005][630], s[15], n     c[15] = {0, 125, 25, 5, 1, 300, 60, 12, 465, 93, 624}; n bool p[6][1005]; n int main() { n   for (int i = 1; i < 5; i++) w[i] = read(); n   char ss = getchar(); n   for (int i = 1; i < 5; i++) n     for (int j = 1; j <= n; j++) { n       while (ss !=  .  && ss !=  * ) ss = getchar(); n       p[i][j] = (ss ==  * ); n       ss = getchar(); n     } n   memset(dp, 0x3f3f3f3f, sizeof(dp)); n   dp[1][0] = 0; n   int b[5] = {0, 125, 25, 5, 1}; n   for (int i = 1; i < 11; i++) { n     if (i < 5) n       s[i] = w[1]; n     else if (i > 4 && i < 8) n       s[i] = w[2]; n     else if (i > 7 && i < 10) n       s[i] = w[3]; n     else n       s[i] = w[4]; n   } n   for (int i = 1; i <= n; i++) { n     for (int j = 0; j < 625; j++) { n       int a[5] = {0, j / 125, j / 25 % 5, j / 5 % 5, j % 5}; n       if (max(max(a[1], a[2]), max(a[3], a[4])) > n - i + 1) continue; n       for (int o = 1; o < 5; o++) n         if (a[o] > 0 && !p[o][i + a[o] - 1]) n           dp[i][j] = min(dp[i][j], dp[i][j - b[o]]); n       if (min(min(a[1], a[2]), min(a[3], a[4])) > 0) n         dp[i + 1][j - 156] = min(dp[i + 1][j - 156], dp[i][j]); n       for (int k = 1; k < 11; k++) { n         int b[5] = {0, c[k] / 125, c[k] / 25 % 5, c[k] / 5 % 5, c[k] % 5}, n             l = 0; n         for (int o = 1; o < 5; o++) l = l * 5 + max(a[o], b[o]); n         dp[i][l] = min(dp[i][l], dp[i][j] + s[k]); n       } n     } n   } n   printf( %d n , dp[n + 1][0]); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int inf = 1e9; n const int MOD = 1e9 + 7; n const int N = 0; n int a[5], m; n long long sum(int len, int x) { n   return 1LL * len * x - 1LL * (x + 1) * x / 2 + x; n } n long long cal(int x, int y, int bar, int len) { n   if (len < 0) return 0; n   int R = min(bar - y, len), L = min(len - (bar - x), R); n   long long ans = 0; n   if (L >= 0) n     ans += 1LL * (L + 1) * (bar - x + 1); n   else n     L = -1; n   ans += sum(len, R) - sum(len, L); n   return ans; n } n long long solve(int x, int y, int z, int len) { n   int tmp = max(max(y, z) + 1, x); n   len -= tmp - x; n   x = tmp; n   long long ans = 0; n   for (auto i = 0; i <= len; i++) { n     int cur = x + i, rem = min(2 * (cur - 1) - y - z, len - i); n     if (rem > cur - y - z) n       ans += cal(y, z, cur - 1, rem) - cal(y, z, cur - 1, (cur - y - z)); n   } n   return ans; n } n long long solve2(int x, int y, int z, int len) { n   int tmp = max(x, y); n   len -= 2 * tmp - x - y; n   x = tmp; n   if (x <= z) len -= 2 * (z + 1 - x), x = z + 1; n   long long ans = 0; n   if (len >= 0) n     for (auto i = 0; i <= len / 2; i++) { n       int rem = len - 2 * i; n       ans += min(x + i - 1 - z, rem) + 1; n     } n   return ans; n } n int main() { n   for (auto i = 0; i <= 2; i++) cin >> a[i]; n   cin >> m; n   long long ans = 0; n   for (auto i = 0; i <= 2; i++) n     ans += solve(a[i], a[(i + 1) % 3], a[(i + 2) % 3], m); n   for (auto i = 0; i <= 2; i++) n     ans += solve2(a[i], a[(i + 1) % 3], a[(i + 2) % 3], m); n   int tmp = *max_element(a, a + 3), v = 0; n   for (auto i = 0; i <= 2; i++) v += tmp - a[i]; n   if (v <= m) ans += (m - v) / 3 + 1; n   cout << ans; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int main() { n   int n, k; n   cin >> n >> k; n   int a[k]; n   for (int i = 0; i < k; i++) cin >> a[i]; n   list<int> leader; n   for (int i = 1; i <= n; i++) leader.insert(leader.end(), i); n   int l = 1; n   int i = 0; n   int begin = 0; n   while (k--) { n     l = (leader.size() + a[i] + begin) % leader.size(); n     list<int>::iterator pnlist = leader.begin(); n     advance(pnlist, l); n     if (k == 0) n       cout << *pnlist << endl; n     else n       cout << *pnlist <<    ; n     leader.erase(pnlist); n     begin = l; n     i++; n   } n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n long long gcd(long long a, long long b) { n   while (b) { n     a %= b; n     swap(a, b); n   } n   return a; n } n int main() { n   int n; n   cin >> n; n   vector<int> q(n); n   for (int i = 0; i < n; ++i) cin >> q[i]; n   vector<int> cost(n, -1); n   int m; n   cin >> m; n   for (int i = 0; i < m; ++i) { n     int a, b, c; n     cin >> a >> b >> c; n     if (cost[b - 1] == -1 || cost[b - 1] > c) { n       cost[b - 1] = c; n     } n   } n   int ans = 0, head = 0; n   for (int i = 0; i < n; ++i) { n     if (cost[i] != -1) n       ans += cost[i]; n     else n       head++; n   } n   if (head > 1) n     cout << -1 << endl; n   else { n     if (!head) { n       int maxx = cost[0]; n       for (int i = 1; i < n; ++i) maxx = max(maxx, cost[i]); n       ans -= maxx; n     } n     cout << ans << endl; n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int n, m; n vector<int> g[200002]; n vector<pair<int, pair<int, int> > > first[200002]; n int lvl[200002]; n int p[20][200002]; n int h[20][200002]; n int d[200002][2]; n inline int lca(int v1, int v2) { n   if (lvl[v1] < lvl[v2]) swap(v1, v2); n   for (int i = 20 - 1; i >= 0; --i) { n     if (lvl[p[i][v1]] >= lvl[v2]) { n       v1 = p[i][v1]; n     } n   } n   if (v1 == v2) return v1; n   for (int i = 20 - 1; i >= 0; --i) { n     if (p[i][v1] != p[i][v2]) { n       v1 = p[i][v1]; n       v2 = p[i][v2]; n     } n   } n   return p[0][v1]; n } n void dfs(int v = 0, int level = 0, int pr = 0) { n   lvl[v] = level; n   p[0][v] = pr; n   for (int i = 1; i < 20; ++i) p[i][v] = p[i - 1][p[i - 1][v]]; n   for (const int& v2 : g[v]) { n     dfs(v2, level + 1, v); n   } n } n inline int getit(int v, int k) { n   if (h[k][v] != -1) return h[k][v]; n   return h[k][v] = getit(p[k - 1][v], k - 1) + getit(v, k - 1); n } n inline int get(int v, int k) { n   if (k < 0) return 0; n   int res = 0; n   for (int i = 20 - 1; i >= 0; --i) { n     if ((k & (1 << i)) > 0) { n       res += getit(v, i); n       k ^= (1 << i); n       v = p[i][v]; n     } n   } n   return res; n } n void go(int v = 0) { n   for (const int& v2 : g[v]) { n     go(v2); n     d[v][0] += max(d[v2][0], d[v2][1]); n   } n   for (const int& v2 : g[v]) { n     h[0][v2] = d[v][0] - max(d[v2][0], d[v2][1]); n   } n   for (const auto& t : first[v]) { n     int cost = t.first; n     int v1 = t.second.first; n     int v2 = t.second.second; n     int w = -d[v][0] + get(v1, lvl[v1] - lvl[v]) + get(v2, lvl[v2] - lvl[v]) + n             d[v1][0] + d[v2][0] + cost; n     d[v][1] = max(d[v][1], w); n   } n } n int main() { n   memset(h, -1, sizeof(h)); n   scanf( %d%d , &n, &m); n   for (int i = 0; i < n - 1; ++i) { n     int t; n     scanf( %d , &t); n     --t; n     g[t].push_back(i + 1); n   } n   dfs(); n   for (int i = 0; i < m; ++i) { n     int v1, v2, cost; n     scanf( %d%d%d , &v1, &v2, &cost); n     --v1, --v2; n     int lcav = lca(v1, v2); n     first[lcav].push_back(make_pair(cost, make_pair(v1, v2))); n   } n   go(); n   printf( %d n , max(d[0][0], d[0][1])); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int t[2000002]; n int longestPrefix(string &s) { n   t[0] = 0; n   for (int pos = 1; pos < s.length(); ++pos) { n     int prev = t[pos - 1]; n     while (prev > 0 && s[pos] != s[prev]) { n       prev = t[prev - 1]; n     } n     if (s[pos] == s[prev]) { n       t[pos] = prev + 1; n     } else { n       t[pos] = prev; n     } n   } n   return t[s.length() - 1]; n } n int main() { n   int t; n   cin >> t; n   while (t-- > 0) { n     string s; n     cin >> s; n     int lindex = 0, rindex = s.length(); n     while (lindex < rindex && s[lindex] == s[rindex - 1]) { n       ++lindex; n       --rindex; n     } n     if (lindex >= rindex) { n       cout << s << endl; n       continue; n     } n     string mid = s.substr(lindex, rindex - lindex); n     string rmid = mid; n     reverse(rmid.begin(), rmid.end()); n     string pre = mid +  *  + rmid; n     string suf = rmid +  *  + mid; n     int pref = longestPrefix(pre); n     int suff = longestPrefix(suf); n     int len = max(pref, suff); n     for (int i = 0; i < lindex; ++i) { n       cout << s[i]; n     } n     if (pref >= suff) { n       for (int i = lindex; i < lindex + pref; ++i) { n         cout << s[i]; n       } n     } else { n       for (int i = rindex - suff; i < rindex; ++i) { n         cout << s[i]; n       } n     } n     for (int i = rindex; i < s.length(); ++i) { n       cout << s[i]; n     } n     cout << endl; n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int V[200010]; n char vowel[] =  aeiouAEIOU ; n int v(int a, int k) { n   if (k == 0) return 0; n   int x = V[a + k - 1]; n   if (a > 0) x -= V[a - 1]; n   return x; n } n int f(int a, int k) { return 2 * k - 3 * v(a, k); } n int g(int k) { return f(0, k); } n bool Good(int a, int k) { return f(a, k) >= 0; } n bool is_vowel(char c) { n   for (int i = 0; i < 10; i++) { n     if (vowel[i] == c) return true; n   } n   return false; n } n bool sf(const int& a, const int& b) { n   if (g(a) < g(b)) return true; n   if (g(a) > g(b)) return false; n   return a < b; n } n int Q[200010]; n vector<int> P; n int R[200010]; n int my_bin_search(int s, string S) { n   int a = 0; n   int b = P.size() - 1; n   while (a <= b) { n     int k = (a + b) / 2; n     if (P[k] == s) n       return k; n     else if (sf(P[k], s)) n       a = k + 1; n     else n       b = k - 1; n   } n   throw  element not found ; n } n void create_data(string S) { n   int N = S.length(); n   for (int a = 0; a <= N; a++) { n     P.push_back(a); n   } n   sort(P.begin(), P.end(), sf); n   for (int x = 0; x < P.size(); x++) { n     R[P[x]] = x; n   } n   Q[0] = P[0]; n   for (unsigned int x = 1; x < P.size(); x++) { n     Q[x] = min(Q[x - 1], P[x]); n   } n } n int main() { n   string S; n   cin >> S; n   int N = S.length(); n   V[0] = 0; n   for (unsigned int i = 0; i < S.length(); i++) { n     if (i > 0) V[i] = V[i - 1]; n     if (is_vowel(S[i])) V[i]++; n   } n   create_data(S); n   int bestk = 0; n   for (int a = 0; a <= N; a++) { n     int x = R[a]; n     int b = Q[x]; n     bestk = max(bestk, a - b); n   } n   if (bestk == 0) { n     cout <<  No solution  << endl; n     return 0; n   } n   int found = 0; n   for (int a = 0; (a + bestk) <= N; a++) { n     if (Good(a, bestk)) { n       found++; n     } n   } n   cout << bestk <<     << found << endl; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const double PI = acos(-1); n void read(int& x) { n   x = 0; n   int f = 1; n   char ch = getchar(); n   while ((ch <  0  || ch >  9 ) && ch !=  - ) ch = getchar(); n   if (ch ==  - ) f = -1, ch = getchar(); n   while (ch >=  0  && ch <=  9 ) x = x * 10 + ch -  0 , ch = getchar(); n   x *= f; n } n int n, f[200005], g[200005], els[200005]; n vector<int> E[200005]; n int power(int a, int b, int p) { n   int s = 1, w = a; n   while (b) { n     if (b & 1) s = (long long)s * w % p; n     w = (long long)w * w % p; n     b >>= 1; n   } n   return s; n } n vector<int> F[200005], B[200005]; n void dfs(int now) { n   f[now] = 1; n   for (int i = (0); i < (E[now].size()); i++) { n     dfs(E[now][i]), n         f[now] = (long long)f[now] * (f[E[now][i]] + 1) % 1000000007; n     F[now].push_back(f[E[now][i]] + 1), B[now].push_back(f[E[now][i]] + 1); n   } n   for (int i = (1); i < (E[now].size()); i++) n     F[now][i] = (long long)F[now][i - 1] * F[now][i] % 1000000007; n   for (int i = (E[now].size() - 2); i >= (0); i--) n     B[now][i] = (long long)B[now][i + 1] * B[now][i] % 1000000007; n   if (E[now].size() == 1) { n     els[E[now][0]] = 1; n     return; n   } n   for (int i = (0); i < (E[now].size()); i++) { n     if (i == 0) n       els[E[now][i]] = B[now][i + 1]; n     else if (i + 1 == E[now].size()) n       els[E[now][i]] = F[now][i - 1]; n     else n       els[E[now][i]] = (long long)B[now][i + 1] * F[now][i - 1] % 1000000007; n   } n } n void work(int now) { n   for (int i = (0); i < (E[now].size()); i++) { n     g[E[now][i]] = ((long long)g[now] * els[E[now][i]] + 1) % 1000000007; n     work(E[now][i]); n   } n } n int main() { n   read(n); n   for (int i = (2); i <= (n); i++) { n     int x; n     read(x); n     E[x].push_back(i); n   } n   dfs(1); n   g[1] = 1; n   work(1); n   for (int i = (1); i <= (n); i++) n     printf( %lld  , (long long)f[i] * g[i] % 1000000007); n   printf(  n ); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n string n; n int i, j, a[9][7], x, y; n int main() { n   cin >> n; n   for (i = n.size() - 1; i >= 0; i--) { n     x = n[i] - 48; n     y = max(y, x); n     for (j = 0; j < x; j++) a[j][7 + i - n.size()] = 1; n   } n   cout << y << endl; n   for (i = 0; i < y; cout <<    , i++) n     for (j = 0, x = 0; j < 7; j++) { n       if (a[i][j] != 0) x = 1; n       if (x != 0) cout << a[i][j]; n     } n   cout << endl; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n inline long long read() { n   long long s = 0, w = 1; n   register char ch = getchar(); n   while (ch <  0  || ch >  9 ) { n     if (ch ==  - ) w = -1; n     ch = getchar(); n   } n   while (ch >=  0  && ch <=  9 ) n     s = (s << 3) + (s << 1) + (ch ^ 48), ch = getchar(); n   return s * w; n } n long long n; n string s; n signed main() { n   n = read(); n   cin >> s; n   for (register long long i = 2; i <= n; i++) { n     if (n % i) continue; n     for (register long long j = 0; j < i / 2; j++) swap(s[j], s[i - j - 1]); n   } n   cout << s << endl; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int D = 505; n const int N = 5005; n pair<int, int> pre[D][N]; n int ans[D][N]; n void solve() { n   memset(pre, -1, sizeof(pre)); n   memset(ans, -1, sizeof(ans)); n   int d, s; n   cin >> d >> s; n   queue<pair<int, int> > que; n   que.push(pair<int, int>(0, 0)); n   vector<int> vec; n   while (!que.empty()) { n     pair<int, int> u = que.front(); n     que.pop(); n     if (u.first == 0 && u.second == s) { n       pair<int, int> cur = u; n       while (!(cur.first == 0 && cur.second == 0)) { n         vec.push_back(ans[cur.first][cur.second]); n         cur = pre[cur.first][cur.second]; n       } n       break; n     } n     for (int i = 0; i <= 9; i++) { n       pair<int, int> v = pair<int, int>((u.first * 10 + i) % d, u.second + i); n       if (v.second <= s && ans[v.first][v.second] == -1) { n         ans[v.first][v.second] = i; n         pre[v.first][v.second] = u; n         que.push(v); n       } n     } n   } n   if (!vec.size()) n     printf( -1 n ); n   else { n     reverse(vec.begin(), vec.end()); n     for (auto i : vec) putchar(i +  0 ); n     printf(  n ); n   } n } n int main() { n   solve(); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const long long N = 1e6 + 5, MOD = 998244353; n int m, n, k; n long long res; n int free_Row, free_Col, line_vert, line_hori; n int Num_Row[N], Num_Row2[N][2], Num_Col[N], Num_Col2[N][2]; n int c[2][2]; n map<pair<int, int>, int> M; n long long power(long long x, int k) { n   long long ans = 1; n   while (k) { n     if (k & 1) ans = ans * x % MOD; n     x = x * x % MOD; n     k >>= 1; n   } n   return ans; n } n void Calculate() { n   res = 0; n   if (line_vert && line_hori) return; n   if (!line_vert) (res += power(2, free_Row)) %= MOD; n   if (!line_hori) (res += power(2, free_Col)) %= MOD; n   if (!line_vert && !line_vert) { n     if (c[0][0] == 0 && c[1][1] == 0) (res += MOD - 1) %= MOD; n     if (c[0][1] == 0 && c[1][0] == 0) (res += MOD - 1) %= MOD; n   } n } n void Delete(int x, int y) { n   if (!M.count({x, y})) return; n   int z = M[{x, y}]; n   M.erase({x, y}); n   --c[z][(x + y) & 1]; n   if (--Num_Row[x] == 0) ++free_Row; n   if (--Num_Row2[x][z ^ (y & 1)] == 0 && Num_Row[x]) --line_vert; n   if (--Num_Col[y] == 0) ++free_Col; n   if (--Num_Col2[y][z ^ (x & 1)] == 0 && Num_Col[y]) --line_hori; n } n void Add(int x, int y, int z) { n   M[{x, y}] = z; n   ++c[z][(x + y) & 1]; n   if (Num_Row[x]++ == 0) --free_Row; n   if (Num_Row2[x][z ^ (y & 1)]++ == 0 && Num_Row[x] > 1) ++line_vert; n   if (Num_Col[y]++ == 0) --free_Col; n   if (Num_Col2[y][z ^ (x & 1)]++ == 0 && Num_Col[y] > 1) ++line_hori; n } n int main() { n   ios_base::sync_with_stdio(false); n   cin.tie(NULL); n   cout.tie(NULL); n   cin >> m >> n >> k; n   free_Row = m; n   free_Col = n; n   line_hori = 0; n   line_vert = 0; n   int x, y, z; n   while (k--) { n     cin >> x >> y >> z; n     Delete(x, y); n     if (z >= 0) Add(x, y, z); n     Calculate(); n     cout << res <<   n ; n   } n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int N = 10000; n vector<int> vec(N); n int main() { n   int n, m; n   cin >> n >> m; n   for (int i = 0; i < n; i++) { n     cin >> vec[i]; n   } n   sort(vec.begin(), vec.begin() + n); n   int sum = 0; n   for (int i = 0; i < m; i++) { n     sum += vec[i]; n   } n   cout << sum << endl; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n namespace algo { n using std::swap; n const long double PI = 3.141592653589793238462643383279502884L; n const long double E = 2.718281828459045235360287471352662498L; n const long double EPS = 1e-12L; n template <typename T1, typename T2> n T1 bin_pow(T1 a, T2 n) { n   T1 r{1}; n   while (n > 0) { n     if (n % 2 == 1) r *= a; n     a *= a; n     n /= 2; n   } n   return r; n } n template <typename T1, typename T2> n T1 bin_pow(T1 a, T2 n, const T1& m) { n   if (m == 1) return 0; n   T1 r{1}; n   while (n > 0) { n     if (n % 2 == 1) { n       r *= a; n       r %= m; n     } n     a *= a; n     a %= m; n     n /= 2; n   } n   return r; n } n template <typename T> n T gcd(const T& a, const T& b) { n   if (b == 0) return a < 0 ? -a : a; n   return gcd(b, a % b); n } n template <typename T> n T gcd(const T& a, const T& b, T& x, T& y) { n   if (b == 0) { n     x = a < 0 ? -1 : 1; n     y = 0; n     return x * a; n   } n   T d{gcd(b, a % b, y, x)}; n   y -= (a / b) * x; n   return d; n } n template <typename T> n T lcm(const T& a, const T& b) { n   T r{a / gcd(a, b) * b}; n   return r < 0 ? -r : r; n } n template <typename T> n T mod_add(const T& a, const T& b, const T& m) { n   if (a < m - b) return a + b; n   return a - (m - b); n } n template <typename T> n T mod_sub(const T& a, const T& b, const T& m) { n   if (a < b) return a + (m - b); n   return a - b; n } n template <typename T> n T mod_mul(T a, T b, const T& m) { n   if (b > a) swap(a, b); n   T r{0}; n   while (b > 0) { n     if (b % 2 == 1) r = mod_add(r, a, m); n     a = mod_add(a, a, m); n     b /= 2; n   } n   return r; n } n template <typename T1, typename T2> n T1 mod_pow(T1 a, T2 n, const T1& m) { n   if (m == 1) return 0; n   T1 r{1}; n   while (n > 0) { n     if (n % 2 == 1) r = mod_mul(r, a, m); n     a = mod_mul(a, a, m); n     n /= 2; n   } n   return r; n } n template <typename T> n T mod_inv(const T& a, const T& m) { n   T x, y; n   T d{gcd(a, m, x, y)}; n   if (d != 1) return 0; n   if (x < 0) x += m; n   return x; n } n template <typename T> n T phi(T n) { n   T t = std::sqrt(n) + EPS; n   T r = n; n   for (T i = 2; i <= t; ++i) { n     if (n % i == 0) { n       r -= r / i; n       do { n         n /= i; n       } while (n % i == 0); n       t = std::sqrt(n) + EPS; n     } n   } n   if (n > 1) r -= r / n; n   return r; n } n class LinearPhi { n  public: n   LinearPhi(uint32_t n = 1 << 20) : size_{n} { n     assert(size_ > 0 &&  Size should be nonzero ); n     assert(size_ <= INT32_MAX &&  Size should fit into an 32-bit signed int ); n     uint32_t sz = (size_ + 1) / 2; n     phi_ = new int32_t[sz]; n     mark_.assign(sz, false); n     phi_[0] = 1; n     if (size_ > 1) primes_.push_back(2); n     for (uint32_t i = 1; i < sz; ++i) { n       uint32_t val = i << 1 | 1; n       if (!mark_[i]) { n         phi_[i] = val - 1; n         primes_.push_back(val); n       } n       if (val < sz) { n         for (uint32_t j = 1; j < primes_.size(); ++j) { n           uint32_t t = val * primes_[j]; n           if (t > size_) break; n           mark_[t >> 1] = true; n           if (val % primes_[j] == 0) { n             phi_[t >> 1] = phi_[i] * primes_[j]; n             break; n           } n           phi_[t >> 1] = phi_[i] * (primes_[j] - 1); n         } n       } n     } n   } n   LinearPhi(const LinearPhi&) = delete; n   LinearPhi& operator=(const LinearPhi&) = delete; n   ~LinearPhi() { n     delete[] phi_; n     phi_ = nullptr; n   } n   const uint32_t& size() const { return size_; } n   int32_t phi(int32_t i) const { n     int32_t r = 1; n     int k = __builtin_ctz(i); n     if (k > 0) { n       i >>= k; n       r <<= k - 1; n     } n     return r * phi_[i >> 1]; n   } n   int32_t operator[](int32_t i) const { return phi(i); } n   const std::vector<int32_t>& primes() const { return primes_; } n  n  private: n   int32_t* phi_ = nullptr; n   std::vector<bool> mark_; n   uint32_t size_; n   std::vector<int32_t> primes_; n }; n class Sieve { n  public: n   Sieve(uint32_t n = 1 << 20) : size_{n} { n     assert(size_ > 0 &&  Size should be nonzero ); n     assert(size_ <= INT32_MAX &&  Size should fit into an 32-bit signed int ); n     uint32_t sz = (size_ + 1) / 2; n     prime_.assign(sz, true); n     prime_[0] = false; n     for (uint32_t i = 1; i < sz; ++i) { n       uint32_t val = i << 1 | 1; n       if (prime_[i] && val * 1ULL * val <= size_) n         for (uint32_t j = val * val; j <= size_; j += 2 * val) n           prime_[j >> 1] = false; n     } n   } n   Sieve(const Sieve&) = delete; n   Sieve& operator=(const Sieve&) = delete; n   const uint32_t& size() const { return size_; } n   bool isPrime(const int32_t& i) const { n     if (i % 2 == 0) return i == 2; n     return prime_[i >> 1]; n   } n   bool operator[](const int32_t& i) const { return isPrime(i); } n  n  private: n   uint32_t size_; n   std::vector<bool> prime_; n }; n class LinearSieve { n  public: n   LinearSieve(uint32_t n = 1 << 20) : size_{n} { n     assert(size_ > 0 &&  Size should be nonzero ); n     assert(size_ <= INT32_MAX &&  Size should fit into an 32-bit signed int ); n     uint32_t sz = (size_ + 1) / 2; n     lpf_ = new uint16_t[sz]; n     std::fill(lpf_, lpf_ + sz, 0); n     lpf_[0] = 1; n     if (size_ > 1) primes_.push_back(2); n     for (uint32_t i = 1; i < sz; ++i) { n       uint32_t val = i << 1 | 1; n       if (!lpf_[i]) primes_.push_back(val); n       if (val < sz) { n         for (uint32_t j = 1; j < primes_.size(); ++j) { n           uint32_t t = val * primes_[j]; n           if (t > size_) break; n           lpf_[t >> 1] = static_cast<uint16_t>(primes_[j]); n           if (lpf_[t >> 1] == (lpf_[i] ? lpf_[i] : val)) break; n         } n       } n     } n   } n   LinearSieve(const LinearSieve&) = delete; n   LinearSieve& operator=(const LinearSieve&) = delete; n   ~LinearSieve() { n     delete[] lpf_; n     lpf_ = nullptr; n   } n   const uint32_t& size() const { return size_; } n   bool isPrime(const int32_t& i) const { n     if (i % 2 == 0) return i == 2; n     return !lpf_[i >> 1]; n   } n   bool operator[](const int32_t& i) const { return isPrime(i); } n   int32_t lpf(const int32_t& i) const { n     if (i % 2 == 0) return 2; n     if (!lpf_[i >> 1]) return i; n     return lpf_[i >> 1]; n   } n   int32_t phi(int32_t i) const { n     int32_t r = 1; n     int k = __builtin_ctz(i); n     if (k > 0) { n       i >>= k; n       r <<= k - 1; n     } n     int32_t n, t = lpf_[i >> 1] ? lpf_[i >> 1] : i; n     while (t != 1) { n       r *= (t - 1); n       i /= t; n       n = lpf_[i >> 1] ? lpf_[i >> 1] : i; n       while (n == t) { n         r *= n; n         i /= t; n         n = lpf_[i >> 1] ? lpf_[i >> 1] : i; n       } n       t = n; n     } n     return r; n   } n   const std::vector<int32_t>& primes() const { return primes_; } n  n  private: n   uint16_t* lpf_ = nullptr; n   uint32_t size_; n   std::vector<int32_t> primes_; n }; n }  // namespace algo n using namespace std; n using namespace algo; n namespace task { n int x1, y1, x2, y2, x3, y3; n int main() { n   cin >> x1 >> y1 >> x2 >> y2 >> x3 >> y3; n   cout << 3 <<   n ; n   cout << x3 - x1 + x2 <<     << y3 - y1 + y2 <<   n ; n   cout << x1 - x2 + x3 <<     << y1 - y2 + y3 <<   n ; n   cout << x2 - x3 + x1 <<     << y2 - y3 + y1 <<   n ; n   return 0; n } n }  // namespace task n int main() { n   ios_base::sync_with_stdio(false); n   cin.tie(nullptr); n   cout.precision(11); n   cout.setf(ios::fixed); n   return task::main(); n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int main() { n   int t, i; n   string s; n   cin >> t; n   while (t--) { n     cin >> s; n     int cap = 0, sm = 0, dig = 0; n     for (i = 0; i < s.size(); i++) { n       if (s[i] >= 65 && s[i] <= 90) { n         cap++; n       } else if (s[i] >= 97 && s[i] <= 122) { n         sm++; n       } else if (s[i] >= 48 && s[i] <= 57) { n         dig++; n       } n     } n     if (sm == 0) { n       if (cap > 1) { n         for (i = 0; i < s.size(); i++) { n           if (s[i] >= 65 && s[i] <= 90) { n             s[i] =  a ; n             break; n           } n         } n       } else if (dig > 1) { n         for (i = 0; i < s.size(); i++) { n           if (s[i] >= 48 && s[i] <= 57) { n             s[i] =  a ; n             break; n           } n         } n       } else { n         s = s +  a ; n       } n     } n     if (cap == 0) { n       if (sm > 1) { n         for (i = 0; i < s.size(); i++) { n           if (s[i] >= 97 && s[i] <= 122) { n             s[i] =  A ; n             break; n           } n         } n       } else if (dig > 1) { n         for (i = 0; i < s.size(); i++) { n           if (s[i] >= 48 && s[i] <= 57) { n             s[i] =  A ; n             break; n           } n         } n       } else { n         s = s +  A ; n       } n     } n     if (dig == 0) { n       if (cap > 1) { n         for (i = 0; i < s.size(); i++) { n           if (s[i] >= 65 && s[i] <= 90) { n             s[i] =  1 ; n             break; n           } n         } n       } else if (sm > 1) { n         for (i = 0; i < s.size(); i++) { n           if (s[i] >= 97 && s[i] <= 122) { n             s[i] =  1 ; n             break; n           } n         } n       } else { n         s = s +  1 ; n       } n     } n     cout << s << endl; n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n bool BeauYear(int y) { n   int a = y % 10; n   int b = (y / 10) % 10; n   int c = (y / 100) % 10; n   int d = (y / 1000) % 10; n   if (a != b && a != c && a != d && b != c && b != d && c != d) return true; n   return false; n } n int main() { n   ios_base::sync_with_stdio(false); n   cin.tie(0); n   cout.tie(0); n   int year; n   cin >> year; n   for (int i = year + 1; i <= 9012; i++) { n     if (BeauYear(i) == true) { n       cout << i; n       i = 9013; n     } n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int N = 100005; n int n, a, b, q, p[N], d[N]; n vector<pair<int, int> > g[N]; n int dp[N][17], v, ud[N], ans[N]; n bool vis[N]; n void dfs(int u) { n   vis[u] = 1; n   for (int i = 0; i < (int)g[u].size(); ++i) { n     v = g[u][i].first; n     if (!vis[v]) { n       p[v] = u; n       d[v] = d[u] + 1; n       dfs(v); n     } n   } n } n int lca(int a, int b) { n   if (d[a] < d[b]) swap(a, b); n   int log = 0; n   for (; (1 << log) <= d[a]; ++log) n     ; n   --log; n   for (int i = log; i >= 0; --i) { n     if (d[a] - (1 << i) >= d[b]) a = dp[a][i]; n   } n   if (a == b) return a; n   for (int i = log; i >= 0; --i) { n     if (dp[a][i] != dp[b][i]) { n       a = dp[a][i]; n       b = dp[b][i]; n     } n   } n   return p[a]; n } n int DFS(int u) { n   vis[u] = 1; n   for (int i = 0; i < (int)g[u].size(); ++i) { n     int v = g[u][i].first; n     if (!vis[v]) { n       ud[u] += DFS(v); n       ans[g[u][i].second] = ud[v]; n     } n   } n   return ud[u]; n } n int main(int argc, char **argv) { n   scanf( %d , &n); n   for (int i = 1; i < n; ++i) { n     scanf( %d%d , &a, &b); n     g[a].push_back(make_pair(b, i)); n     g[b].push_back(make_pair(a, i)); n   } n   memset(p, -1, sizeof p); n   memset(dp, -1, sizeof dp); n   dfs(1); n   for (int i = 0; i <= n; ++i) dp[i][0] = p[i]; n   for (int j = 1; (1 << j) <= n; ++j) { n     for (int i = 0; i <= n; ++i) { n       if (dp[i][j - 1] != -1) dp[i][j] = dp[dp[i][j - 1]][j - 1]; n     } n   } n   scanf( %d , &q); n   int LCA; n   while (q--) { n     scanf( %d%d , &a, &b); n     LCA = lca(a, b); n     ++ud[a], ++ud[b], ud[LCA] -= 2; n   } n   memset(vis, 0, sizeof vis); n   DFS(1); n   for (int i = 1; i < n; ++i) { n     if (i > 1) printf(   ); n     printf( %d , ans[i]); n   } n   puts(  ); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n string tobinary(long long x) { n   string ret; n   char ch; n   while (x) ch =  0  + (x % 2), ret = ch + ret, x /= 2; n   return ret; n } n long long todecimal(string s) { n   int sz = s.size(); n   long long ret = 0; n   for (int i = 0; i < sz; i++) ret = 2 * ret + (s[i] -  0 ); n   return ret; n } n bool _greater(string s, string t) { n   int n = s.size(), m = t.size(); n   if (n > m) return true; n   if (n < m) return false; n   for (int i = 0; i < n; i++) { n     if (s[i] > t[i]) n       return true; n     else if (s[i] < t[i]) n       return false; n   } n   return false; n } n long long eval(long long l, long long r) { n   string s = tobinary(l), t = tobinary(r), ret = s; n   while (1) { n     if (_greater(s, t)) break; n     ret = s; n     int sz = s.size(); n     bool ok = false; n     for (int i = sz - 1; i >= 0; i--) n       if (s[i] ==  0 ) { n         s[i] =  1 ; n         ok = true; n         break; n       } n     if (!ok) { n       s =  1  + s; n       int n = s.size(), m = t.size(); n       if (n > m) break; n     } n   } n   return todecimal(ret); n } n int main() { n   ios_base::sync_with_stdio(false); n   cin.tie(NULL); n   int n; n   cin >> n; n   while (n--) { n     long long l, r; n     cin >> l >> r; n     cout << eval(l, r) << endl; n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n vector<pair<int, int> > points; n pair<int, int> dif(pair<int, int> pa, pair<int, int> pb) { n   pair<int, int> res; n   res.first = pb.first - pa.first; n   res.second = pb.second - pa.second; n   return res; n } n int dot(pair<int, int> a, pair<int, int> b) { n   return a.first * b.first + a.second * b.second; n } n double dist(pair<int, int> a, pair<int, int> b) { n   return ((double)((a.first - b.first) * (a.first - b.first) + n                    (a.second - b.second) * (a.second - b.second))); n } n double len(pair<int, int> a) { return dist(a, make_pair(0, 0)); } n int main() { n   for (int i = 0; i < 8; i++) { n     int x, y; n     cin >> x >> y; n     points.push_back(make_pair(x, y)); n   } n   vector<int> perm; n   for (int i = 0; i < 8; i++) perm.push_back(i); n   int cnt = 0; n   bool found = false; n   do { n     cnt++; n     bool fs = false, ss = false; n     bool fis = true, sif = true; n     pair<int, int> a = points[perm[0]]; n     pair<int, int> b = points[perm[1]]; n     pair<int, int> c = points[perm[2]]; n     pair<int, int> d = points[perm[3]]; n     pair<int, int> e = points[perm[4]]; n     pair<int, int> f = points[perm[5]]; n     pair<int, int> g = points[perm[6]]; n     pair<int, int> h = points[perm[7]]; n     pair<int, int> ab = dif(a, b); n     pair<int, int> bc = dif(b, c); n     pair<int, int> cd = dif(c, d); n     pair<int, int> da = dif(d, a); n     fs = (dot(ab, bc) == 0 && dot(bc, cd) == 0 && dot(cd, da) == 0 && n           dot(da, ab) == 0 && fabs(len(ab) - len(bc)) < 0.01 && n           fabs(len(bc) - len(cd)) < 0.01 && fabs(len(cd) - len(da)) < 0.01); n     pair<int, int> ef = dif(e, f); n     pair<int, int> fg = dif(f, g); n     pair<int, int> gh = dif(g, h); n     pair<int, int> he = dif(h, e); n     ss = (dot(ef, fg) == 0 && dot(fg, gh) == 0 && dot(gh, he) == 0 && n           dot(he, ef) == 0 && fabs(len(ef) - len(gh)) < 0.01 && n           fabs(len(fg) - len(he)) < 0.01); n     if (ss && fs) { n       found = true; n       break; n     } n   } while (next_permutation(perm.begin(), perm.end())); n   if (found) { n     cout <<  YES  << endl; n     for (int i = 0; i < 4; i++) { n       if (i != 0) cout <<    ; n       cout << perm[i] + 1; n     } n     cout << endl; n     for (int i = 4; i < 8; i++) { n       if (i != 4) cout <<    ; n       cout << perm[i] + 1; n     } n     cout << endl; n   } else n     cout <<  NO  << endl; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int mod = 1e9 + 7; n int n; n char s[5001]; n int dp[5001][5001]; n int main() { n   scanf( %d , &n); n   for (int i = 1; i <= n; ++i) { n     scanf(  n%c , &s[i]); n   } n   dp[1][0] = 1; n   for (int j = 1; j <= n; ++j) { n     dp[1][j] = 0; n   } n   for (int i = 2; i <= n; ++i) { n     if (s[i - 1] ==  f ) { n       for (int j = 1; j <= n; ++j) { n         dp[i][j] = dp[i - 1][j - 1]; n       } n     } else { n       int x = 0; n       for (int j = n; j >= 0; --j) { n         x += dp[i - 1][j]; n         if (x >= mod) { n           x -= mod; n         } n         dp[i][j] = x; n       } n     } n   } n   int res = 0; n   for (int i = 0; i <= n; ++i) { n     res += dp[n][i]; n     if (res >= mod) { n       res -= mod; n     } n   } n   cout << res <<   n ; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n using lli = long long; n using Double = long double; n int main() { n   ios_base::sync_with_stdio(false); n   cin.tie(0); n   cout.tie(0); n   string s[9][3]; n   for (int i = 0; i < 9; ++i) { n     for (int j = 0; j < 3; ++j) { n       cin >> s[i][j]; n     } n   } n   int x, y, cnt = 0; n   cin >> x >> y, --x, --y; n   for (auto c : s[x % 3 * 3][y % 3]) cnt += c ==  . ; n   for (auto c : s[x % 3 * 3 + 1][y % 3]) cnt += c ==  . ; n   for (auto c : s[x % 3 * 3 + 2][y % 3]) cnt += c ==  . ; n   if (cnt == 0) { n     for (int i = 0; i < 9; ++i) { n       for (int j = 0; j < 3; ++j) { n         for (auto c : s[i][j]) { n           cout << (c ==  .  ?  !  : c); n         } n         cout <<    n [j == 2]; n       } n       if (i % 3 == 2) cout <<   n ; n     } n   } else { n     for (int i = 0; i < 9; ++i) { n       for (int j = 0; j < 3; ++j) { n         for (auto c : s[i][j]) { n           cout << (c ==  .  and i / 3 == x % 3 and j == y % 3 ?  !  : c); n         } n         cout <<    n [j == 2]; n       } n       if (i % 3 == 2) cout <<   n ; n     } n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n char str[606]; n long long tmp[80]; n long long mat[2000][32]; n int see[2000]; n int main() { n   int M; n   scanf( %d , &M); n   for (int i = 0; i < M; i++) { n     scanf( %s , str); n     int len = 0; n     while (str[len]) len++; n     for (int j = 0; j < 80; j++) tmp[j] = 0; n     for (int j = 0; j < len; j++) { n       long long &t = tmp[(len - j - 1) / 8]; n       t = t * 10 + str[j] -  0 ; n     } n     for (int j = 0; j < 250; j++) { n       long long t = tmp[0] & 255; n       for (int k = 0; k < 8; k++) n         if (t & (1 << k)) mat[j * 8 + k][i / 64] |= 1ll << (i % 64); n       for (int k = 79; k; k--) { n         tmp[k - 1] += (tmp[k] & 255) * 100000000ll; n         tmp[k] >>= 8; n       } n       tmp[0] >>= 8; n     } n   } n   for (int i = 0, j = 0; i < 2000 && j < M; j++) { n     bool seen = false; n     for (int k = i; k < 2000; k++) { n       if (mat[k][j / 64] & (1ll << (j % 64))) { n         for (int l = j / 64; l < 32; l++) { n           swap(mat[i][l], mat[k][l]); n         } n         seen = true; n         break; n       } n     } n     if (!seen) { n       int cnt = 0; n       for (int k = 0; k < i; k++) n         if (mat[k][j / 64] & (1ll << (j % 64))) cnt++; n       printf( %d , cnt); n       for (int k = 0; k < i; k++) n         if (mat[k][j / 64] & (1ll << (j % 64))) printf(  %d , see[k]); n       puts(  ); n       continue; n     } n     see[i] = j; n     printf( 0 n ); n     for (int k = 0; k < 2000; k++) n       if (k != i && (mat[k][j / 64] & (1ll << (j % 64)))) { n         for (int l = j / 64; l < 32; l++) mat[k][l] ^= mat[i][l]; n       } n     i++; n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int maxm = 2e5 + 10; n set<int> g; n queue<set<int> > q; n int m, n, x, y; n int dfs(int top) { n   if (abs(top) <= 1) return 0; n   int now = 0; n   if ((-top) % 2 == 0) n     now = top / 2; n   else n     now = (top + 1) / 2; n   if (g.find(now) == g.end()) { n     g.erase(top); n     g.insert(now); n     return 1; n   } else n     return dfs(now); n } n int main() { n   cin >> m; n   for (int i = 1; i <= m; i++) { n     cin >> x; n     g.insert(-x); n   } n   for (;;) { n     int top = *g.begin(); n     if (!dfs(top)) break; n   } n   for (auto e : g) cout << -e <<    ; n   cout << endl; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n vector<int> v; n int qtd[100001]; n int main() { n   int n; n   scanf( %d , &n); n   for (int i = 0; i < n; i++) { n     int a; n     scanf( %d , &a); n     v.push_back(a); n   } n   sort(v.begin(), v.end()); n   int cont = 0; n   for (int i = 1, tmp = 0; i < n; i++) { n     if (v[i] > v[i - 1]) { n       cont += i - tmp; n       tmp = i; n     } n     qtd[i] = cont; n   } n   int ans = 0; n   int used = 0; n   for (int i = 0; i < n; i++) { n     if (qtd[i] > used) { n       used++; n       ans++; n     } n   } n   printf( %d n , ans); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n struct W { n   int t, l, r; n } w[100010]; n int n, m, s, f; n int main() { n   while (cin >> n >> m >> s >> f) { n     for (int i = (0); i < (m); i++) { n       cin >> w[i].t >> w[i].l >> w[i].r; n     } n     int t = 1, p = 0; n     int dir = f > s ? 1 : -1; n     while (s != f) { n       if (p < m && w[p].t == t && n           ((w[p].l <= s && s <= w[p].r) || n            (w[p].l <= s + dir && s + dir <= w[p].r))) { n         cout <<  X ; n       } else { n         s += dir; n         cout << (dir == 1 ?  R  :  L ); n       } n       if (++t > w[p].t) p++; n     } n     cout << endl; n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int inf = 1e9; n int n, d, p[30005], dp1[60005][700]; n int occ[30005]; n int main() { n   scanf( %d%d , &n, &d); n   int xb, x2, x3; n   for (xb = 0; xb < n; xb++) { n     scanf( %d , &p[xb]); n     p[xb]--; n     occ[p[xb]]++; n   } n   d--; n   int res = 0; n   for (xb = 0; xb < 60005; xb++) { n     for (x3 = 0; x3 < 700; x3++) dp1[xb][x3] = -inf; n   } n   dp1[d][350] = 0; n   for (xb = d; xb < 30000; xb++) { n     for (x3 = 0; x3 < 700; x3++) { n       if (dp1[xb][x3] == -inf) continue; n       int tv = d + x3 - 349, adg = occ[xb]; n       if (tv > 0) n         res = (((res) > (adg + dp1[xb][x3])) ? (res) : (adg + dp1[xb][x3])); n       if (tv > 1) n         dp1[xb + tv - 1][x3 - 1] = n             (((dp1[xb + tv - 1][x3 - 1]) > (dp1[xb][x3] + adg)) n                  ? (dp1[xb + tv - 1][x3 - 1]) n                  : (dp1[xb][x3] + adg)); n       if (tv > 0) n         dp1[xb + tv][x3] = n             (((dp1[xb + tv][x3]) > (dp1[xb][x3] + adg)) ? (dp1[xb + tv][x3]) n                                                         : (dp1[xb][x3] + adg)); n       if (tv > -1) n         dp1[xb + tv + 1][x3 + 1] = n             (((dp1[xb + tv + 1][x3 + 1]) > (dp1[xb][x3] + adg)) n                  ? (dp1[xb + tv + 1][x3 + 1]) n                  : (dp1[xb][x3] + adg)); n     } n   } n   printf( %d n , res); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int N = 1e6 + 100; n int t, cnt[N]; n int mx; n int check(int row, int col, int n, int m) { n   if (row < 0 || row >= n || col < 0 || col >= m) return 0; n   int i = 0, j = 0, ok = 1; n   for (; i < n; i++) { n     for (j = 0; j < m; j++) { n       if (!cnt[abs(row - i) + abs(col - j)]--) { n         ok = 0; n         break; n       } n     } n     if (!ok) break; n   } n   if (ok) { n     cout << n <<     << m << endl; n     cout << row + 1 <<     << col + 1 << endl; n     return 1; n   } n   for (int a = 0; a <= i; a++) n     for (int b = 0; b < m && (a != i || b <= j); b++) n       ++cnt[abs(row - a) + abs(col - b)]; n   return 0; n } n bool solve(int row, int n, int m, int mxi, int mxj) { n   if (check(row, mxj - (mx - abs(row - mxi)), n, m)) return 1; n   return check(row, mxj + (mx - abs(row - mxi)), n, m); n } n int main() { n   scanf( %d , &t); n   for (int i = 0; i < t; ++i) { n     int v; n     scanf( %d , &v); n     ++cnt[v]; n     mx = max(mx, v); n   } n   if (cnt[0] != 1) return puts( -1 ); n   int a; n   if (cnt[1] != 4) n     a = 0; n   else { n     a = 1; n     while (cnt[a + 1] == (a + 1) * 4) a++; n   } n   for (int n = 1; n * n <= t; n++) { n     if (t % n) continue; n     int m = t / n; n     if (solve(a, n, m, 0, 0)) return 0; n     if (solve(a, n, m, 0, m - 1)) return 0; n     if (solve(a, n, m, n - 1, 0)) return 0; n     if (solve(a, n, m, n - 1, m - 1)) return 0; n     if (solve(a, m, n, 0, 0)) return 0; n     if (solve(a, m, n, 0, n - 1)) return 0; n     if (solve(a, m, n, m - 1, 0)) return 0; n     if (solve(a, m, n, m - 1, n - 1)) return 0; n   } n   return puts( -1 ); n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n int main() { n   int i, j; n   int str[6]; n   int num[6]; n   char ch; n   for (i = 0; i < 6; i++) { n     str[i] = 0; n     num[i] = 0; n   } n   for (i = 0; i < 6; i++) { n     scanf( %c , &ch); n     switch (ch) { n       case  R : n         str[0]++; n         break; n       case  O : n         str[1]++; n         break; n       case  Y : n         str[2]++; n         break; n       case  G : n         str[3]++; n         break; n       case  B : n         str[4]++; n         break; n       case  V : n         str[5]++; n         break; n     } n   } n   for (j = 0; j < 6; j++) { n     num[str[j]]++; n   } n   switch (num[0]) { n     case 0: n       printf( 30 n ); n       break; n     case 1: n       printf( 15 n ); n       break; n     case 2: n       switch (num[1]) { n         case 2: n           printf( 8 n ); n           break; n         case 3: n           printf( 5 n ); n           break; n       } n       break; n     case 3: n       switch (num[1]) { n         case 2: n           printf( 2 n ); n           break; n         case 1: n           printf( 3 n ); n           break; n         case 0: n           printf( 6 n ); n           break; n       } n       break; n     case 4: n       switch (num[1]) { n         case 1: n           printf( 1 n ); n           break; n         case 0: n           printf( 2 n ); n           break; n       } n       break; n     case 5: n       printf( 1 n ); n       break; n   } n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int Head[1000010], Next[1000010], Go[1000010], Val[1000010], iscut[1000010], n     Len[1000010], Dep[1000010], Fa[400010][21], Cnt = 1, n, m, q; n int Head2[1000010], Next2[1000010], Go2[1000010], Val2[1000010], Cnt2 = 1; n int DFN[1000010], MIN[1000010], ins[1000010], Bel[1000010], vis[1000010], n     tim = 0, tt = 0; n vector<int> S; n void addedge(int x, int y) { n   Go[++Cnt] = y; n   Next[Cnt] = Head[x]; n   Head[x] = Cnt; n } n void addedge2(int x, int y, int v) { n   Go2[++Cnt2] = y; n   Next2[Cnt2] = Head2[x]; n   Head2[x] = Cnt2; n   Val2[Cnt2] = v; n } n void Tarjan(int x, int f = 0) { n   ins[x] = 1; n   S.push_back(x); n   DFN[x] = ++tim; n   MIN[x] = DFN[x]; n   int las = x; n   for (int T = Head[x]; T; T = Next[T]) n     if (Go[T] != f) { n       if (!DFN[Go[T]]) { n         Tarjan(Go[T], x); n         MIN[x] = min(MIN[x], MIN[Go[T]]); n         if (DFN[x] <= MIN[Go[T]]) { n           tt++; n           for (;;) { n             if (S.back() == las) break; n             addedge2(tt + n + 1, S.back(), 1); n             addedge2(S.back(), tt + n + 1, 1); n             S.pop_back(); n           } n           addedge2(x, tt + n + 1, 1); n           addedge2(tt + n + 1, x, 1); n         } else n           las = S.back(); n       } else if (ins[Go[T]]) n         MIN[x] = min(MIN[x], DFN[Go[T]]); n     } n   ins[x] = 0; n } n void DFS2(int x, int dep = 1, int len = 0) { n   vis[x] = 1; n   Len[x] = len; n   Dep[x] = dep; n   for (int T = Head[x]; T; T = Next[T]) n     if (!vis[Go[T]]) { n       Fa[Go[T]][0] = x; n       DFS2(Go[T], dep + 1, len + Val[T]); n     } n } n int lca(int x, int y) { n   if (Dep[x] < Dep[y]) swap(x, y); n   int det = Dep[x] - Dep[y]; n   for (int i = 18; i >= 0; i--) n     if ((det >> i) & 1) x = Fa[x][i]; n   if (x == y) return x; n   for (int i = 18; i >= 0; i--) n     if (Fa[x][i] != Fa[y][i]) x = Fa[x][i], y = Fa[y][i]; n   return Fa[x][0]; n } n int main() { n   scanf( %d%d%d , &n, &m, &q); n   for (int i = 1; i <= m; i++) { n     int a, b; n     scanf( %d%d , &a, &b); n     addedge(a, b); n     addedge(b, a); n   } n   for (int i = 1; i <= n; i++) n     if (!DFN[i]) Tarjan(i); n   memcpy(Head, Head2, sizeof Head); n   memcpy(Next, Next2, sizeof Next); n   memcpy(Go, Go2, sizeof Go); n   memcpy(Val, Val2, sizeof Val); n   for (int i = 1; i <= n + tt + 1; i++) n     if (!vis[i]) DFS2(i); n   for (int i = 1; i <= 20; i++) n     for (int j = 1; j <= n + tt + 1; j++) Fa[j][i] = Fa[Fa[j][i - 1]][i - 1]; n   for (int i = 1; i <= q; i++) { n     int a, b; n     scanf( %d%d , &a, &b); n     printf( %d n , (Len[a] + Len[b] - 2 * Len[lca(a, b)]) / 2); n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n inline int read() { n   char ch = getchar(); n   int x = 0, f = 1; n   while (ch <  0  || ch >  9 ) { n     if (ch ==  - ) f = -1; n     ch = getchar(); n   } n   while (ch >=  0  && ch <=  9 ) { n     x = (x << 1) + (x << 3) -  0  + ch; n     ch = getchar(); n   } n   return x * f; n } n int main() { n   priority_queue<int> q; n   int n = read(), T = read(); n   int ans = 0; n   for (int i = 1; i <= n; i++) { n     int x = read(); n     x = max(x, i); n     while (!q.empty() && q.top() >= T - i) { n       q.pop(); n     } n     if (x < T) q.push(x - i); n     ans = max(ans, (int)q.size()); n   } n   printf( %d n , ans); n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int a[1005]; n int b[1005]; n int h; n bool cmp(int x, int y) { return x > y; } n bool check(int x) { n   for (int i = 1; i <= x; i++) { n     b[i] = a[i]; n   } n   sort(b + 1, b + x + 1, cmp); n   long long sum = 0; n   for (int i = 1; i <= x; i += 2) { n     sum += (long long)(b[i]); n   } n   if (sum <= h) { n     return 1; n   } else { n     return 0; n   } n } n int main() { n   int n; n   cin >> n >> h; n   for (int i = 1; i <= n; i++) { n     cin >> a[i]; n   } n   int l = 1, r = n, mid; n   while (l < r) { n     mid = (l + r + 1) / 2; n     if (check(mid)) { n       l = mid; n     } else { n       r = mid - 1; n     } n   } n   cout << l; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n inline int in() { n   int x; n   scanf( %d , &x); n   return x; n } n template <typename T> n inline istream& operator>>(istream& i, vector<T>& v) { n   for (int j = 0; j < ((int)(v).size()); ++j) i >> v[j]; n   return i; n } n template <typename T> n string join(const vector<T>& v) { n   stringstream s; n   for (int i = 0; i < ((int)(v).size()); ++i) s <<     << v[i]; n   return s.str().substr(1); n } n template <typename T> n inline ostream& operator<<(ostream& o, const vector<T>& v) { n   if ((int)(v).size()) o << join(v); n   return o; n } n template <typename T1, typename T2> n inline istream& operator>>(istream& i, pair<T1, T2>& v) { n   return i >> v.first >> v.second; n } n template <typename T1, typename T2> n inline ostream& operator<<(ostream& o, const pair<T1, T2>& v) { n   return o << v.first <<  ,  << v.second; n } n template <typename T> n inline long long int suma(const vector<T>& a) { n   long long int res(0); n   for (auto&& x : a) res += x; n   return res; n } n const double eps = 1e-10; n const long long int LINF = 1001002003004005006ll; n const int INF = 1001001001; n const int MX = 200005; n int n, m; n int dp[55][55][55]; n struct Q { n   int l, r, x, c; n   int cost(int i, int h) { n     if (l <= i && i < r && h > x) return c; n     return 0; n   } n }; n vector<Q> q; n int dfs(int l, int r, int h) { n   if (l == r) return 0; n   int& now = dp[l][r][h]; n   if (now != -1) return now; n   now = 0; n   if (h) now = dfs(l, r, h - 1); n   for (int i = l; i < r; ++i) { n     int c = h * h; n     for (int k = 0; k < (m); ++k) { n       if (l <= q[k].l && q[k].r <= r) c -= q[k].cost(i, h); n     } n     c += dfs(l, i, h) + dfs(i + 1, r, h); n     (now = max(now, c)); n   } n   return now; n } n int main() { n   int h; n   cin >> n >> h >> m; n   q = vector<Q>(m); n   for (int i = 0; i < (m); ++i) { n     int l, r, x, c; n     scanf( %d%d%d%d , &l, &r, &x, &c); n     --l; n     q[i] = (Q){l, r, x, c}; n   } n   for (int i = 0; i < (n); ++i) n     for (int j = 0; j < (n + 1); ++j) n       for (int k = 0; k < (h + 1); ++k) dp[i][j][k] = -1; n   int ans = dfs(0, n, h); n   cout << ans << endl; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n struct node { n   int x, y; n } p[8]; n int cmp(node a, node b) { n   if (a.x == b.x) return (a.y < b.y); n   return a.x < b.x; n } n int main() { n   while (scanf( %d %d , &p[0].x, &p[0].y) != EOF) { n     int cnt1 = 0; n     int cnt2 = 0; n     int cnt3 = 0; n     int cnt4 = 0; n     for (int i = 1; i < 8; i++) { n       scanf( %d %d , &p[i].x, &p[i].y); n     } n     sort(p, p + 8, cmp); n     node zuoshang = p[0]; n     node youxia = p[7]; n     for (int i = 1; i < 7; i++) { n       if (p[i].x == zuoshang.x) cnt1++; n       if (p[i].y == zuoshang.y) cnt2++; n       if (p[i].x == youxia.x) cnt3++; n       if (p[i].y == youxia.y) cnt4++; n     } n     if (cnt1 == 2 && cnt2 == 2 && cnt3 == 2 && cnt4 == 2 && p[1].y == p[6].y && n         p[4].x == p[3].x) n       puts( respectable ); n     else n       puts( ugly ); n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int main() { n   int n; n   cin >> n; n   for (int i = 0; i < n; i++) { n     double x, y, z, a, b, c, sq; n     cin >> x; n     a = 1.0, b = x, c = x; n     z = (b * b) - (4 * a * c); n     if (z < 0) { n       cout <<  N  << endl; n       continue; n     } n     y = ((-b + (sqrt((b * b) - (4 * a * c)))) / 2 * a); n     if (y != 0) y = -1 * y; n     cout << fixed << setprecision(9) <<  Y   << (x - y) <<     << y << endl; n   } n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int r1, r2; n int c1, c2; n int b, e, k; n int main() { n   ios_base::sync_with_stdio(0); n   b = e = k = 0; n   cin >> r1 >> c1; n   cin >> r2 >> c2; n   if (r1 > r2) { n     swap(r1, r2); n     swap(c1, c2); n   } n   b = (r1 == r2 || c1 == c2) ? 1 : 2; n   e = ((((r1 & 1) == (c1 & 1)) && ((r2 & 1) == (c2 & 1))) || n        (((r1 & 1) != (c1 & 1)) && ((r2 & 1) != (c2 & 1)))) n           ? 2 n           : 0; n   e = (abs(r1 - r2) == abs(c1 - c2) && e != 0) ? 1 : e; n   k = min(abs(r1 - r2), abs(c1 - c2)) + max(abs(r1 - r2), abs(c1 - c2)) - n       min(abs(r1 - r2), abs(c1 - c2)); n   cout << b <<     << e <<     << k << endl; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int N = 2e3 + 789; n const int M = 2e5 + 5; n const int NN = 1e5 + 55; n const long long mod = 1e9 + 7; n const long long inf = 0x3f3f3f3f; n const long long INF = 1LL << 62; n bitset<2000> P[N], S[N], T; n char ms[N][N]; n int main() { n   ios::sync_with_stdio(0); n   cin.tie(0); n   int n, m; n   cin >> n >> m; n   P[0].reset(); n   for (int i = 0; i < n; i++) { n     cin >> ms[i]; n     if (i) P[i] = P[i - 1]; n     for (int j = 0; j < m; j++) { n       if (ms[i][j] ==  1 ) P[i][j] = 1; n     } n   } n   for (int i = n - 1; i >= 0; i--) { n     if (i != n - 1) S[i] = S[i + 1]; n     for (int j = 0; j < m; j++) { n       if (ms[i][j] ==  1 ) S[i][j] = 1; n     } n   } n   bool f = 0; n   for (int i = 0; i < n; i++) { n     T.reset(); n     if (i - 1 >= 0) T |= P[i - 1]; n     if (i + 1 < n) T |= S[i + 1]; n     if (T.count() == m) f = 1; n   } n   if (f) n     cout <<  YES  << endl; n   else n     cout <<  NO  << endl; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n inline void Boost() { n   ios::sync_with_stdio(false); n   cin.tie(NULL); n   cout.tie(NULL); n } n const int NMax = 1e6 + 50; n string convert(const string &s) { n   string ret =  @ ; n   for (int i = 0; i < (int)s.size(); ++i) { n     ret +=  #  + s.substr(i, 1); n   } n   ret +=  #$ ; n   return ret; n } n int P[NMax * 2]; n void Solve() { n   string s; n   cin >> s; n   int n = (int)s.size(); n   int a = 0; n   int b = n - 1; n   while (a <= b) { n     if (a == b) { n       cout << s <<   n ; n       return; n     } n     if (s[a] == s[b]) { n       ++a; n       --b; n       if (a > b) { n         cout << s <<   n ; n         return; n       } n     } else { n       string nw = convert(s); n       int cen = 0, r = 0; n       for (int i = 0; i < (int)nw.size(); ++i) P[i] = 0; n       for (int i = 1; i < (int)nw.size() - 1; ++i) { n         int mir = cen - (i - cen); n         if (r > i) { n           P[i] = min(r - i, P[mir]); n         } n         while (nw[i + 1 + P[i]] == nw[i - 1 - P[i]]) { n           P[i]++; n         } n         if (i + P[i] > r) { n           cen = i; n           r = i + P[i]; n         } n       } n       int best = 0; n       int pos = 0; n       for (int i = 1; i < (int)nw.size() - 1; i++) { n         int start = (i - 1 - P[i]) / 2; n         int fin = start + P[i] - 1; n         if (start < a) { n           int mv = a - start; n           start += mv; n           fin -= mv; n         } n         if (fin > b) { n           int mv = fin - b; n           start += mv; n           fin -= mv; n         } n         if (start != a && fin != b) continue; n         if (start <= fin && (fin - start + 1) > best) { n           best = fin - start + 1; n           pos = start; n         } n       } n       for (int i = 0; i < a; ++i) cout << s[i]; n       for (int i = pos; i < pos + best; ++i) cout << s[i]; n       for (int i = a - 1; i >= 0; --i) cout << s[i]; n       cout <<   n ; n       return; n     } n   } n } n int main() { n   Boost(); n   int t; n   cin >> t; n   while (t--) { n     Solve(); n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n bool is_prefix(string s, string comp) { n   bool res = false; n   int sz = s.size(); n   int comp_sz = comp.size(); n   if (sz > comp_sz) n     return res; n   else { n     res = true; n     for (int i = 0; i < sz; i++) { n       if (s[i] != comp[i]) { n         res = false; n         break; n       } n     } n   } n   return res; n } n int main(int argc, char* argv[]) { n   int n; n   string s; n   vector<string> res; n   cin >> s; n   cin >> n; n   for (int i = 0; i < n; i++) { n     string t; n     cin >> t; n     if (is_prefix(s, t)) res.push_back(t); n   } n   if (res.size() == 0) { n     cout << s; n   } else { n     sort(res.begin(), res.end()); n     cout << res[0]; n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n int du[100010], fa[100010], s1[100010], s2[100010]; n int find(int x) { n   if (x != fa[x]) fa[x] = find(fa[x]); n   return fa[x]; n } n int main() { n   int n, m, x, y, i, j, k, sum; n   scanf( %d%d , &n, &m); n   for (i = 1; i <= n; i++) fa[i] = i; n   memset(du, 0, sizeof(du)); n   memset(s1, 0, sizeof(s1)); n   memset(s2, 0, sizeof(s2)); n   for (i = 1; i <= m; i++) { n     scanf( %d%d , &x, &y); n     j = find(x); n     k = find(y); n     du[x]++; n     du[y]++; n     if (j != k) { n       if (j < k) n         fa[k] = j; n       else n         fa[j] = k; n     } n   } n   for (i = 1; i <= n; i++) { n     j = find(i); n     s1[j] = s1[j] + du[i]; n     s2[j]++; n   } n   sum = 0; n   for (i = 1; i <= n; i++) n     if (s2[i] != 0) { n       j = s1[i] / 2; n       if (j < s2[i]) sum = sum + s2[i] - j; n     } n   printf( %d n , sum); n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n const int maxn = 100001; n int n, val[maxn], cL[maxn], cR[maxn], ord[maxn], tot, in[maxn], out[maxn], n     bit[maxn], ans; n bool vis[maxn]; n void dfs(int u) { n   if (u == -1) return; n   in[u] = ++tot; n   dfs(cL[u]); n   dfs(cR[u]); n   out[u] = tot; n } n void bit_add(int x, int v) { n   for (; x <= n; x += x & -x) bit[x] += v; n } n int bit_sum(int x) { n   int ret = 0; n   for (; x > 0; x -= x & -x) ret += bit[x]; n   return ret; n } n bool cmp(int const &x, int const &y) { return val[x] < val[y]; } n int main() { n   scanf( %d , &n); n   for (int i = 1; i <= n; ++i) { n     scanf( %d%d%d , val + i, cL + i, cR + i); n     if (cL[i] != -1) vis[cL[i]] = 1; n     if (cR[i] != -1) vis[cR[i]] = 1; n     ord[i] = i; n   } n   std::sort(ord + 1, ord + n + 1, cmp); n   for (int i = 1; i <= n; ++i) n     if (!vis[i]) dfs(i); n   for (int i = 1; i <= n; ++i) n     if (cR[i] != -1) { n       bit_add(in[cR[i]], 1); n       bit_add(out[cR[i]] + 1, -1); n     } n   for (int i = 1, j = 1; i <= n;) { n     for (; j <= n && val[ord[j]] <= val[ord[i]]; ++j) { n       int u = ord[j]; n       if (cL[u] != -1) { n         bit_add(in[cL[u]], 1); n         bit_add(out[cL[u]] + 1, -1); n       } n       if (cR[u] != -1) { n         bit_add(in[cR[u]], -1); n         bit_add(out[cR[u]] + 1, 1); n       } n     } n     int cnt = 0, flg = 0; n     for (int v = val[ord[i]]; i <= n && val[ord[i]] == v; ++i, ++cnt) n       flg |= !bit_sum(in[ord[i]]); n     if (!flg) ans += cnt; n   } n   printf( %d n , ans); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int maxn = 210; n int n, m, x; n long long dp[maxn][maxn], v[maxn], ans = -1; n void read_and_parse() { n   scanf( %d%d%d , &n, &m, &x); n   for (int i = 1; i <= n; i++) scanf( %d , &v[i]); n } n void solve() { n   memset(dp, 0xcf, sizeof(dp)); n   dp[0][0] = 0; n   for (int i = 1; i <= n; i++) n     for (int j = 1; j <= x; j++) n       for (int k = max(0, i - m); k < i; k++) n         dp[i][j] = max(dp[i][j], dp[k][j - 1] + v[i]); n   for (int i = n - m + 1; i <= n; i++) ans = max(ans, dp[i][x]); n   printf( %lld n , ans); n } n int main() { n   read_and_parse(); n   solve(); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n void checkDefine(); n string x; n string y; n string z; n int main() { n   cin >> x >> y; n   long long int n = x.size(); n   for (int i = (0), _b = (n - 1); i <= _b; i++) { n     if (x[i] < y[i]) { n       cout << -1; n       return 0; n     } n   } n   cout << y; n   return 0; n } n void checkDefine() { n   long long int n, a[200005]; n   map<long long int, long long int> m; n   cin >> n; n   for (int i = (0), _b = (n - 1); i <= _b; i++) { n     cin >> a[i]; n     m[a[i]]++; n   } n   string s; n   cin >> s; n   { n     cout <<  s  n          <<   =  ; n     cout << (s) << endl; n   }; n   { n     cout <<  a  n          <<   =  ; n     for (int _ = 0, _a = (n); _ < _a; _++) cout << a[_] <<    ; n     cout << endl; n   }; n   { n     cout <<   ------------   n          <<   =  ; n     cout << ( ------------ ) << endl; n   }; n   for (__typeof(m.begin()) it = m.begin(); it != m.end(); ++it) { n     cout << it->first <<     << it->second << endl; n   } n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n template <class L, class R> n ostream &operator<<(ostream &os, map<L, R> P) { n   for (auto const &vv : P) os <<  (  << vv.first <<  ,  << vv.second <<  ) ; n   return os; n } n template <class T> n ostream &operator<<(ostream &os, set<T> V) { n   os <<  [ ; n   for (auto const &vv : V) os << vv <<  , ; n   os <<  ] ; n   return os; n } n template <class T> n ostream &operator<<(ostream &os, vector<T> V) { n   os <<  [ ; n   for (auto const &vv : V) os << vv <<  , ; n   os <<  ] ; n   return os; n } n template <class L, class R> n ostream &operator<<(ostream &os, pair<L, R> P) { n   os <<  (  << P.first <<  ,  << P.second <<  ) ; n   return os; n } n inline int fstoi(const string &str) { n   auto it = str.begin(); n   bool neg = 0; n   int num = 0; n   if (*it ==  - ) n     neg = 1; n   else n     num = *it -  0 ; n   ++it; n   while (it < str.end()) num = num * 10 + (*it++ -  0 ); n   if (neg) num *= -1; n   return num; n } n inline void getch(char &x) { n   while (x = getchar_unlocked(), x < 33) { n     ; n   } n } n inline void getstr(string &str) { n   str.clear(); n   char cur; n   while (cur = getchar_unlocked(), cur < 33) { n     ; n   } n   while (cur > 32) { n     str += cur; n     cur = getchar_unlocked(); n   } n } n template <typename T> n inline bool sc(T &num) { n   bool neg = 0; n   int c; n   num = 0; n   while (c = getchar_unlocked(), c < 33) { n     if (c == EOF) return false; n   } n   if (c ==  - ) { n     neg = 1; n     c = getchar_unlocked(); n   } n   for (; c > 47; c = getchar_unlocked()) num = num * 10 + c - 48; n   if (neg) num *= -1; n   return true; n } n template <typename T, typename... Args> n inline void sc(T &num, Args &...args) { n   bool neg = 0; n   int c; n   num = 0; n   while (c = getchar_unlocked(), c < 33) { n     ; n   } n   if (c ==  - ) { n     neg = 1; n     c = getchar_unlocked(); n   } n   for (; c > 47; c = getchar_unlocked()) num = num * 10 + c - 48; n   if (neg) num *= -1; n   sc(args...); n } n int getsum(int a, int b) { n   int oor, oand; n   cout <<  and   << a <<     << b << endl; n   cin >> oand; n   cout <<  or   << a <<     << b << endl; n   cin >> oor; n   return oor + oand; n } n int main() { n   int n, k; n   cin >> n >> k; n   int cr; n   int x, y, z; n   x = getsum(1, 2); n   y = getsum(1, 3); n   z = getsum(2, 3); n   int a[n + 1]; n   a[3] = (y + z - x) / 2; n   a[2] = (-y + z + x) / 2; n   a[1] = (y - z + x) / 2; n   for (auto i = (4); i <= (n); ++i) { n     int wh = getsum(1, i); n     a[i] = wh - a[1]; n   } n   sort(a + 1, a + n + 1); n   cout <<  finish   << a[k] << endl; n   cout << a[k] << endl; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int INF = 0x3f3f3f3f; n const long long LINF = 0x3f3f3f3f3f3f3f3fll; n const long double pi = acos(-1); n const int MOD = 1e9 + 7; n const int N = 2e5 + 100; n int tr_min[4 * N][1 << 5]; n int tr_max[4 * N][1 << 5]; n vector<int> cara[N]; n int n, k; n void build(int node, int b, int e) { n   if (b == e) { n     for (int cord = 0; cord < (1 << k); cord++) { n       long long x = 0; n       for (int i = 0; i < k; i++) { n         if (cord & (1 << i)) n           x += cara[b][i]; n         else n           x -= cara[b][i]; n       } n       tr_max[node][cord] = tr_min[node][cord] = x; n     } n   } else { n     int mid = (b + e) / 2; n     build(2 * node, b, mid); n     build(2 * node + 1, mid + 1, e); n     for (int i = 0; i < (1 << k); i++) { n       tr_max[node][i] = max(tr_max[2 * node][i], tr_max[2 * node + 1][i]); n       tr_min[node][i] = min(tr_min[2 * node][i], tr_min[2 * node + 1][i]); n     } n   } n } n void update(int node, int b, int e, int i, vector<int> &cara) { n   if (e < i or b > i) return; n   if (b == e and b == i) { n     for (int cord = 0; cord < (1 << k); cord++) { n       long long x = 0; n       for (int i = 0; i < k; i++) { n         if (cord & (1 << i)) n           x += cara[i]; n         else n           x -= cara[i]; n       } n       tr_max[node][cord] = tr_min[node][cord] = x; n     } n     return; n   } n   int mid = (b + e) / 2; n   update(2 * node, b, mid, i, cara); n   update(2 * node + 1, mid + 1, e, i, cara); n   for (int i = 0; i < (1 << k); i++) { n     tr_max[node][i] = max(tr_max[2 * node][i], tr_max[2 * node + 1][i]); n     tr_min[node][i] = min(tr_min[2 * node][i], tr_min[2 * node + 1][i]); n   } n } n int query(int node, int b, int e, int i, int j, int cord) { n   if (e < i or b > j) return -INF; n   if (i <= b and j >= e) { n     return tr_max[node][cord]; n   } n   int mid = (b + e) / 2; n   return max(query(2 * node, b, mid, i, j, cord), n              query(2 * node + 1, mid + 1, e, i, j, cord)); n } n int query2(int node, int b, int e, int i, int j, int cord) { n   if (e < i or b > j) return INF; n   if (i <= b and j >= e) { n     return tr_min[node][cord]; n   } n   int mid = (b + e) / 2; n   return min(query2(2 * node, b, mid, i, j, cord), n              query2(2 * node + 1, mid + 1, e, i, j, cord)); n } n int proc(int cord, int l, int r) { n   int maxi = query(1, 1, n, l, r, cord); n   int mini = query2(1, 1, n, l, r, cord); n   return abs(mini - maxi); n } n int main() { n   scanf( %d %d , &n, &k); n   for (int i = 1; i <= n; i++) { n     for (int j = 0; j < k; j++) { n       int x; n       scanf( %d , &x); n       cara[i].push_back(x); n     } n   } n   int q; n   build(1, 1, n); n   scanf( %d , &q); n   while (q--) { n     int op; n     scanf( %d , &op); n     if (op == 1) { n       int idx; n       scanf( %d , &idx); n       vector<int> val; n       for (int j = 0; j < k; j++) { n         int x; n         scanf( %d , &x); n         val.push_back(x); n       } n       update(1, 1, n, idx, val); n     } else { n       int l, r; n       scanf( %d %d , &l, &r); n       int resp = 0; n       for (int i = 0; i < (1 << k); i++) resp = max(proc(i, l, r), resp); n       printf( %d n , resp); n     } n   } n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int MAXN = 100010; n bool operator<(pair<int, int> lhs, pair<int, int> rhs) { n   return (lhs.first != rhs.first) ? (lhs.first < rhs.first) n                                   : (lhs.second < rhs.second); n } n set<pair<int, int> > inqUp, inqDown, pendUp, pendDown; n int N, M, prsis, rci; n long long T, Ans[MAXN]; n struct User { n   int id, ar, f, t; n }; n bool cmp_Useraraz(User lhs, User rhs) { return lhs.ar < rhs.ar; } n User u[MAXN], ru[MAXN]; n int Where; n void Unload() { n   while ((inqUp.size()) && (inqUp.begin()->first == Where)) { n     Ans[inqUp.begin()->second] = T; n     inqUp.erase(inqUp.begin()); n     rci++; n   } n   while (((inqDown.size()) && (--inqDown.end())->first == Where)) { n     Ans[(--inqDown.end())->second] = T; n     inqDown.erase(--inqDown.end()); n     rci++; n   } n } n void Request() { n   while ((prsis != N) && (u[prsis + 1].ar == T)) { n     prsis++; n     if (u[prsis].f >= Where) n       pendUp.insert(make_pair(u[prsis].f, u[prsis].id)); n     else n       pendDown.insert(make_pair(u[prsis].f, u[prsis].id)); n   } n } n void Load(int id) { n   if (ru[id].t >= Where) n     inqUp.insert(make_pair(ru[id].t, id)); n   else n     inqDown.insert(make_pair(ru[id].t, id)); n } n void Load() { n   while ((pendUp.size()) && (pendUp.begin()->first == Where)) { n     Load(pendUp.begin()->second); n     pendUp.erase(pendUp.begin()); n   } n   while ((pendDown.size()) && ((--pendDown.end())->first == Where)) { n     Load((--pendDown.end())->second); n     pendDown.erase(--pendDown.end()); n   } n } n int main() { n   scanf( %d%d , &N, &M); n   int i; n   for (i = 1; i <= N; i++) { n     scanf( %d%d%d , &u[i].ar, &u[i].f, &u[i].t); n     u[i].id = i; n     ru[i] = u[i]; n   } n   sort(u + 1, u + N + 1, cmp_Useraraz); n   inqUp.clear(); n   inqDown.clear(); n   pendUp.clear(); n   pendDown.clear(); n   Where = 1; n   T = 0; n   prsis = rci = 0; n   while (rci < N) { n     Unload(); n     Request(); n     Load(); n     int pUp = inqUp.size() + pendUp.size(); n     int pDown = inqDown.size() + pendDown.size(); n     int Action = (pUp + pDown) ? ((pUp >= pDown) ? 1 : -1) : 0; n     int timePass = (prsis == N) ? M : (u[prsis + 1].ar - T); n     if (Action == 1) { n       if (pendUp.size()) n         timePass = min(timePass, pendUp.begin()->first - Where); n       if (inqUp.size()) timePass = min(timePass, inqUp.begin()->first - Where); n     } n     if (Action == -1) { n       if (pendDown.size()) n         timePass = min(timePass, Where - (--pendDown.end())->first); n       if (inqDown.size()) n         timePass = min(timePass, Where - (--inqDown.end())->first); n     } n     T += timePass; n     Where += timePass * Action; n   } n   for (i = 1; i <= N; i++) printf( %I64d n , Ans[i]); n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n map<char, char> mp; n string check(string s) { n   for (int i = 0; i <= s.size() / 2; i++) n     if (s[i] != mp[s[s.size() - 1 - i]]) return  NIE ; n   return  TAK ; n } n int main() { n   mp[ A ] =  A ; n   mp[ b ] =  d ; n   mp[ d ] =  b ; n   mp[ H ] =  H ; n   mp[ I ] =  I ; n   mp[ M ] =  M ; n   mp[ O ] =  O ; n   mp[ o ] =  o ; n   mp[ p ] =  q ; n   mp[ q ] =  p ; n   mp[ T ] =  T ; n   mp[ U ] =  U ; n   mp[ V ] =  V ; n   mp[ v ] =  v ; n   mp[ W ] =  W ; n   mp[ w ] =  w ; n   mp[ X ] =  X ; n   mp[ x ] =  x ; n   mp[ Y ] =  Y ; n   string s; n   cin >> s; n   cout << check(s) << endl; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int main() { n   int a[3][3], b[3][3]; n   for (int i = 0; i < 3; i++) { n     for (int j = 0; j < 3; j++) { n       cin >> a[i][j]; n       a[i][j] %= 2; n       b[i][j] = 0; n     } n   } n   pair<int, int> f[] = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}, {0, 0}}; n   for (int i = 0; i < 3; i++) { n     for (int j = 0; j < 3; j++) { n       for (auto m : f) { n         if (i + m.first < 3 && i + m.first > -1) { n           if (j + m.second < 3 && j + m.second > -1) { n             if (a[i + m.first][j + m.second] % 2) { n               b[i][j]++; n               b[i][j] %= 2; n             } n           } n         } n       } n     } n   } n   for (int i = 0; i < 3; i++) { n     for (int j = 0; j < 3; j++) { n       cout << (b[i][j] ^ 1); n     } n     cout <<   n ; n   } n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int maxn = 200000; n const long long mod = 1e9 + 7; n long long fac[maxn + 5], inv[maxn + 5]; n long long f[2005]; n struct node { n   long long x, y; n } data[2005]; n long long qmod(long long a, long long b) { n   long long ans = 1; n   a = a % mod; n   while (b) { n     if (b & 1) { n       ans = (ans * a) % mod; n     } n     b = b / 2; n     a = (a * a) % mod; n   } n   return ans; n } n void init() { n   fac[0] = 1; n   for (long long i = 1; i <= maxn; i++) { n     fac[i] = (fac[i - 1] * i) % mod; n   } n } n long long com(long long n, long long m) { n   if (n < m) n     return 0; n   else if (n == m) n     return 1; n   else n     return (fac[n] * qmod(fac[m] * fac[n - m], mod - 2)) % mod; n } n long long Lucas(long long n, long long m) { n   if (m == 0) n     return 1; n   else n     return (com(n % mod, m % mod) * Lucas(n / mod, m / mod)) % mod; n } n bool cmp(node a, node b) { n   if (a.x < b.x) n     return true; n   else if (a.x == b.x) { n     if (a.y < b.y) n       return true; n     else n       return false; n   } else n     return false; n } n int main(int argc, char const *argv[]) { n   long long h, w, n; n   init(); n   scanf( %lld %lld %lld , &h, &w, &n); n   for (int i = 1; i <= n; i++) { n     scanf( %lld %lld , &data[i].x, &data[i].y); n   } n   sort(data + 1, data + 1 + n, cmp); n   memset(f, 0, sizeof(f)); n   n++; n   data[n].x = h; n   data[n].y = w; n   for (int i = 1; i <= n; i++) { n     long long dx, dy; n     dx = data[i].x - 1; n     dy = data[i].y - 1; n     f[i] = Lucas(dx + dy, dx); n     for (int j = 1; j < i; j++) { n       if (data[i].x >= data[j].x && data[i].y >= data[j].y) { n         dx = data[i].x - data[j].x; n         dy = data[i].y - data[j].y; n         f[i] = f[i] - (f[j] * Lucas(dx + dy, dx)) % mod; n         f[i] = (f[i] + mod) % mod; n       } n     } n   } n   cout << (f[n] + mod) % mod << endl; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int n, x[100], s[100]; n struct par { n   int v, id; n   bool operator<(const par &r) const { return v < r.v; } n }; n vector<par> v; n int main() { n   scanf( %d , &n); n   for (int i = 0; i < n; i++) { n     scanf( %d , &x[i]); n     v.push_back({x[i], i}); n   } n   sort(v.begin(), v.end()); n   vector<par> v1 = v; n   rotate(v1.begin(), v1.begin() + 1, v1.end()); n   for (int i = 0; i < (int)v.size(); i++) s[v[i].id] = v1[i].v; n   for (int i = 0; i < n; i++) { n     printf( %d , s[i]); n     i == n - 1 ? printf(  n ) : printf(   ); n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int oo = 3e5 + 7; n unordered_map<int, vector<int>> values[2]; n int t, n, q, a[oo], p[oo]; n vector<int> ans; n int psum(int l, int r) { return p[r] - (l ? p[l - 1] : 0); } n int first(vector<int>& list, int val) { n   int l = 0, r = list.size(); n   while (l < r) { n     int s = (l + r) / 2; n     if (list[s] >= val) n       r = s; n     else n       l = s + 1; n   } n   if (l == list.size()) return n * 2; n   return list[l]; n } n void problem(int l, int r) { n   int sum = psum(l, r); n   if (sum == 0) return; n   if (sum % 2 == 0) { n     ans.push_back(r); n     problem(l, r - 1); n     return; n   } n   int pl = p[l] - a[l]; n   int vals[2] = {pl + (sum + 1) / 2 - 1, pl + (sum - 1) / 2 + 1}; n   for (int i = 0; i < 2; i++) { n     int pans = first(values[i][vals[i]], l); n     if (pans <= r) { n       ans.push_back(pans); n       return; n     } n   } n   throw 69; n } n void solve() { n   cin >> n >> q; n   string ss; n   cin >> ss; n   for (int i = 0; i < n; i++) n     a[i] = (ss[i] ==  +  ? 1 : -1) * (i % 2 == 0 ? -1 : 1); n   p[0] = a[0]; n   for (int i = 1; i < n; i++) p[i] = p[i - 1] + a[i]; n   for (int i = 0; i < n; i++) values[(a[i] + 1) / 2][p[i]].push_back(i); n   while (q--) { n     int l, r; n     cin >> l >> r; n     l--, r--; n     problem(l, r); n     cout << ans.size() << endl; n     for (int e : ans) cout << e + 1 <<    ; n     cout << endl; n     ans.clear(); n   } n   values[0].clear(); n   values[1].clear(); n } n int main() { n   ios::sync_with_stdio(0); n   cin.tie(0); n   cin >> t; n   while (t--) solve(); n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int a[1050], b[1050]; n int main() { n   int n, m, s = 0, d = 0; n   cin >> n >> m; n   for (int i = 0; i < m; i++) { n     cin >> a[i]; n     b[i] = a[i]; n   } n   for (int i = 1; i <= n; i++) { n     sort(a, a + m); n     for (int j = 0; j < m; j++) { n       if (a[j] > 0) { n         s += a[j]; n         a[j]--; n         break; n       } n     } n   } n   for (int i = 1; i <= n; i++) { n     sort(b, b + m); n     for (int j = m - 1; j >= 0; j--) { n       if (b[j] > 0) { n         d += b[j]; n         b[j]--; n         break; n       } n     } n   } n   cout << d <<     << s; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n long long mx(long long a, long long b) { return a >= b ? a : b; } n long long mn(long long a, long long b) { return a <= b ? a : b; } n string a[3] = {( twone ), ( two ), ( one )}; n int main() { n   ios::sync_with_stdio(0); n   cin.tie(0); n   cout.tie(0); n   long long t, x; n   cin >> t; n   while (t--) { n     string str, str2; n     long long ans = 0; n     vector<long long> v; n     cin >> str; n     if (str.size() <= 2) { n       cout << 0 <<   n  n            <<   n ; n       continue; n     } n     for (long long i = 0; i < str.size() - 2; i++) { n       if (str[i] ==  t  and str[i + 1] ==  w  and str[i + 2] ==  o  and n           str[i + 3] ==  n  and str[i + 4] ==  e ) n         str[i + 2] =  l , ans++, v.push_back(i + 3); n       if (str[i] ==  t  and str[i + 1] ==  w  and str[i + 2] ==  o ) n         ans++, str[i + 1] =  l , v.push_back(i + 2); n       if (str[i] ==  o  and str[i + 1] ==  n  and str[i + 2] ==  e ) n         ans++, str[i + 1] =  l , v.push_back(i + 2); n     } n     cout << ans <<   n ; n     for (long long i = 0; i < v.size(); i++) cout << v[i] <<    ; n     cout <<   n ; n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int main() { n   int a; n   cin >> a; n   int max = 0; n   vector<int> b; n   int x; n   for (int i = 0; i < a; i++) { n     cin >> x; n     b.push_back(x); n   } n   sort(b.begin() + 1, b.end()); n   int count = 0; n   if (b[0] > b[b.size() - 1]) { n     cout <<  0 ; n   } else { n     while (1) { n       b[b.size() - 1]--; n       count++; n       b[0] = b[0] + 1; n       sort(b.begin() + 1, b.end()); n       if (b[0] > b[b.size() - 1]) { n         cout << count; n         break; n       } n     } n   } n   printf(  n ); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int vet[1010], dp[2][1010]; n const int mod = 998244353; n long long soma(long long x, long long y) { n   x += y; n   if (x >= mod) x -= mod; n   return x; n } n int main() { n   int n; n   cin >> n; n   for (int i = 0; i < n; i++) { n     cin >> vet[i]; n   } n   for (int i = 0; i < n; i++) { n     for (int j = 0; j < n; j++) { n       dp[1][j] = dp[0][j]; n     } n     if (vet[i] < n and vet[i] > 0) { n       dp[1][vet[i]] = soma(soma(dp[0][0], 1), dp[1][vet[i]]); n     } n     for (int k = 0; k < n; k++) { n       dp[1][k] = soma(dp[1][k], dp[0][k + 1]); n     } n     swap(dp[0], dp[1]); n   } n   cout << dp[0][0] << endl; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n template <class node> n struct link_cut_tree { n   bool connected(node* u, node* v) { return lca(u, v) != NULL; } n   int depth(node* u) { n     access(u); n     return get_sz(u->ch[0]); n   } n   node* get_root(node* u) { n     access(u); n     while (u->ch[0]) u = u->ch[0], u->push(); n     return access(u), u; n   } n   node* ancestor(node* u, int k) { n     k = depth(u) - k; n     for (;; u->push()) { n       int sz = get_sz(u->ch[0]); n       if (sz == k) return access(u), u; n       if (sz < k) n         k -= sz + 1, u = u->ch[1]; n       else n         u = u->ch[0]; n     } n   } n   node* lca(node* u, node* v) { n     if (u == v) return u; n     access(u); n     access(v); n     if (!u->p) return NULL; n     u->splay(); n     return u->p ?: u; n   } n   void link(node* u, node* v) { n     make_root(v); n     access(u); n     set_link(v, u, 0); n     v->update(); n   } n   void cut(node* u) { n     access(u); n     u->ch[0]->p = NULL; n     u->ch[0] = NULL; n     u->update(); n   } n   void cut(node* u, node* v) { cut(depth(u) > depth(v) ? u : v); } n   void make_root(node* u) { n     access(u); n     u->rev ^= 1; n     access(u); n   } n   void access(node* u) { n     for (node *v = u, *pre = NULL; v; v = v->p) { n       v->splay(); n       if (pre) v->update_vsub(pre, false); n       if (v->ch[1]) v->update_vsub(v->ch[1], true); n       v->ch[1] = pre; n       v->update(); n       pre = v; n     } n     u->splay(); n   } n   node* operator[](int i) { return &data[i]; } n   int operator[](node* i) { return i - &data[0]; } n   vector<node> data; n   link_cut_tree(int n) : data(n) {} n }; n template <typename pnode> n struct splay_tree { n   pnode ch[2], p; n   bool rev; n   int sz; n   splay_tree() { n     ch[0] = ch[1] = p = NULL; n     rev = 0; n     sz = 1; n   } n   friend int get_sz(pnode u) { return u ? u->sz : 0; } n   virtual void update() { n     if (ch[0]) ch[0]->push(); n     if (ch[1]) ch[1]->push(); n     sz = 1 + get_sz(ch[0]) + get_sz(ch[1]); n   } n   virtual void push() { n     if (rev) { n       if (ch[0]) ch[0]->rev ^= 1; n       if (ch[1]) ch[1]->rev ^= 1; n       swap(ch[0], ch[1]); n       rev = 0; n     } n   } n   int dir() { n     if (!p) return -2; n     if (p->ch[0] == this) return 0; n     if (p->ch[1] == this) return 1; n     return -1; n   } n   bool is_root() { return dir() < 0; } n   friend void set_link(pnode u, pnode v, int d) { n     if (v) v->p = u; n     if (d >= 0) u->ch[d] = v; n   } n   void rotate() { n     int x = dir(); n     pnode g = p; n     set_link(g->p, static_cast<pnode>(this), g->dir()); n     set_link(g, ch[x ^ 1], x); n     set_link(static_cast<pnode>(this), g, x ^ 1); n     g->update(); n     update(); n   } n   void splay() { n     while (!is_root() && !p->is_root()) { n       p->p->push(), p->push(), push(); n       dir() == p->dir() ? p->rotate() : rotate(); n       rotate(); n     } n     if (!is_root()) p->push(), push(), rotate(); n     push(); n   } n }; n struct node; n node* root; n bool capture; n vector<pair<int, int>> vec; n struct node : splay_tree<node*> { n   using splay_tree::ch; n   int val, lazy; n   node() : splay_tree() { n     val = -1e9; n     lazy = -1; n   } n   void update() override { splay_tree::update(); } n   void update_vsub(node* v, bool add) { n     if (!add && capture) vec.push_back({this - root, val}); n   } n   void push() override { n     splay_tree::push(); n     if (lazy != -1) { n       val = lazy; n       if (ch[0]) ch[0]->lazy = lazy; n       if (ch[1]) ch[1]->lazy = lazy; n       lazy = -1; n     } n   } n }; n int main() { n   ios_base::sync_with_stdio(0), cin.tie(0); n   int n, m; n   cin >> n >> m; n   vector<vector<pair<int, int>>> adj(n); n   for (int i = 1, u, v, w; i < n; ++i) { n     cin >> u >> v >> w; n     --u, --v; n     adj[u].push_back({v, w}); n   } n   vector<long long> dist(n); n   vec.reserve(n); n   link_cut_tree<node> lct(n); n   function<void(int)> dfs_access = [&](int u) { n     for (auto v : adj[u]) { n       dist[v.first] = dist[u] + v.second; n       lct.link(lct[u], lct[v.first]); n       dfs_access(v.first); n     } n   }; n   dfs_access(0); n   root = lct[0]; n   vector<pair<long long, long long>> s; n   for (int i = 0, d, t; i < m; ++i) { n     cin >> d >> t; n     --d; n     auto u = lct[d], v = u; n     while (!v->is_root()) v = v->p, v->push(); n     while (v->ch[1]) v = v->ch[1], v->push(); n     vec.clear(); n     capture = true; n     lct.access(u); n     capture = false; n     for (auto x : vec) n       s.push_back({dist[x.first] + x.second, dist[x.first] + t}); n     int val = u->val; n     u->lazy = t; n     u->push(); n     u->val = val; n     lct.access(v); n   } n   long long explosion = -1, changes = s.size(); n   sort(s.begin(), s.end()); n   priority_queue<long long, vector<long long>, greater<long long>> pq; n   for (long long t = 1, i = 0; i < s.size() || !pq.empty();) { n     if (pq.empty() && t <= s[i].first) t = s[i].first + 1; n     while (i < s.size() && s[i].first < t) pq.push(s[i].second), ++i; n     if (t > pq.top()) { n       explosion = t - 1; n       break; n     } n     pq.pop(); n     ++t; n   } n   if (explosion != -1) n     changes -= count_if(s.begin(), s.end(), [&](pair<long long, long long> x) { n       return x.second >= explosion; n     }); n   cout << explosion <<     << changes <<   n ; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n #pragma GCC optimize( O2 ) n using namespace std; n const int N = 1e5 + 10; n const long long mod = 1e9 + 7; n const long long mod2 = 998244353; n const int inf = 1e9; n const int LOG = 22; n long long pw(long long a, long long b, long long M) { n   return (!b ? 1 n              : (b & 1 ? (a * pw(a * a % M, b / 2, M)) % M n                       : pw(a * a % M, b / 2, M))); n } n struct node { n   int mx1, mx2, cnt, lz; n   long long sum; n   node(int m1 = -inf, int m2 = -inf, int c = 0, int l = inf, long long s = 0) { n     mx1 = m1, mx2 = m2, cnt = c, lz = l, sum = s; n   } n   friend node operator|(node L, node R) { n     if (L.mx1 < R.mx1) swap(L, R); n     if (L.mx1 == R.mx1) n       L.cnt += R.cnt; n     else n       L.mx2 = max(L.mx2, R.mx1); n     L.mx2 = max(L.mx2, R.mx2); n     L.sum += R.sum; n     L.lz = inf; n     return L; n   } n }; n struct segment_beats { n   node seg[N << 2]; n   void shift(int v, int lz) { n     seg[v].lz = min(seg[v].lz, lz); n     seg[v].sum -= 1ll * seg[v].cnt * max(0, seg[v].mx1 - lz); n     seg[v].mx1 = min(seg[v].mx1, lz); n   } n   void second(int v, int tl, int tr) { n     if (tl == tr) return; n     shift(v << 1, seg[v].lz); n     shift(v << 1 | 1, seg[v].lz); n   } n   void change(int p, int x, int v = 1, int tl = 1, int tr = N - 1) { n     second(v, tl, tr); n     if (p > tr || p < tl) return; n     if (tl == tr) { n       seg[v] = node(x, -inf, 1, inf, x); n       return; n     } n     int mid = (tl + tr) >> 1; n     change(p, x, v << 1, tl, mid), change(p, x, v << 1 | 1, mid + 1, tr); n     seg[v] = seg[v << 1] | seg[v << 1 | 1]; n   } n   void upd(int l, int r, int x, int v = 1, int tl = 1, int tr = N - 1) { n     second(v, tl, tr); n     if (l > tr || r < tl || l > r || seg[v].mx1 <= x) return; n     if (l <= tl && tr <= r && seg[v].mx2 < x) { n       shift(v, x); n       return; n     } n     int mid = (tl + tr) >> 1; n     upd(l, r, x, v << 1, tl, mid), upd(l, r, x, v << 1 | 1, mid + 1, tr); n     seg[v] = seg[v << 1] | seg[v << 1 | 1]; n   } n   long long get(int l, int r, int v = 1, int tl = 1, int tr = N - 1) { n     second(v, tl, tr); n     if (l > tr || r < tl || l > r) return 0ll; n     if (l <= tl && tr <= r) { n       return seg[v].sum; n     } n     int mid = (tl + tr) >> 1; n     return get(l, r, v << 1, tl, mid) + get(l, r, v << 1 | 1, mid + 1, tr); n   } n } seg1, seg2; n struct segment { n   int lz[N << 2]; n   segment() { n     for (int i = 0; i < N << 2; i++) lz[i] = inf; n   } n   void upd(int l, int r, int x, int v = 1, int tl = 1, int tr = N - 1) { n     if (l > tr || r < tl || l > r) return; n     if (l <= tl && tr <= r) { n       lz[v] = min(lz[v], x); n       return; n     } n     int mid = (tl + tr) >> 1; n     upd(l, r, x, v << 1, tl, mid), upd(l, r, x, v << 1 | 1, mid + 1, tr); n   } n   int ask(int p, int v = 1, int tl = 1, int tr = N - 1) { n     if (tl == tr) { n       return lz[v]; n     } n     int mid = (tl + tr) >> 1; n     if (p <= mid) { n       return min(lz[v], ask(p, v << 1, tl, mid)); n     } n     return min(lz[v], ask(p, v << 1 | 1, mid + 1, tr)); n   } n } Seg1, Seg2; n set<int> st1, st2; n int main() { n   for (int i = 1; i < N; i++) st1.insert(i), st2.insert(i); n   int n; n   scanf( %d , &n); n   for (int i = 1; i <= n; i++) { n     int tp, l, r; n     scanf( %d%d%d , &tp, &l, &r); n     r--; n     if (tp == 1) { n       int x; n       scanf( %d , &x); n       if (x < 0) { n         x = abs(x); n         seg1.upd(l, r, x); n         Seg1.upd(l, r, x); n         while (1) { n           auto it = st1.lower_bound(l); n           if (it == st1.end() || *it > r) break; n           int cu = *it; n           st1.erase(cu); n           if (st2.count(cu) == 0) { n             seg1.change(cu, x); n             seg2.change(cu, Seg2.ask(cu)); n           } n         } n       } else { n         seg2.upd(l, r, x); n         Seg2.upd(l, r, x); n         while (1) { n           auto it = st2.lower_bound(l); n           if (it == st2.end() || *it > r) break; n           int cu = *it; n           st2.erase(cu); n           if (st1.count(cu) == 0) { n             seg2.change(cu, x); n             seg1.change(cu, Seg1.ask(cu)); n           } n         } n       } n     } else { n       printf( %lld n , seg1.get(l, r) + seg2.get(l, r)); n     } n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const long long INF = 1LL << 60; n string operator*(const string& s, int k) { n   if (k == 0) return   ; n   string p = (s + s) * (k / 2); n   if (k % 2 == 1) p += s; n   return p; n } n template <class T> n inline bool chmin(T& a, T b) { n   if (a > b) { n     a = b; n     return true; n   } n   return false; n } n template <class T> n inline bool chmax(T& a, T b) { n   if (a < b) { n     a = b; n     return true; n   } n   return false; n } n struct Edge { n   long long to, cap, rev; n   Edge(long long _to, long long _cap, long long _rev) { n     to = _to; n     cap = _cap; n     rev = _rev; n   } n }; n void add_edge(vector<vector<Edge>>& G, long long from, long long to, n               long long cap, bool revFlag, long long revCap) { n   G[from].push_back(Edge(to, cap, (long long)G[to].size())); n   if (revFlag) n     G[to].push_back(Edge(from, revCap, (long long)G[from].size() - 1)); n } n long long max_flow_dfs(vector<vector<Edge>>& G, long long v, long long t, n                        long long f, vector<bool>& used) { n   if (v == t) return f; n   used[v] = true; n   for (int i = 0; i < G[v].size(); ++i) { n     Edge& e = G[v][i]; n     if (!used[e.to] && e.cap > 0) { n       long long d = max_flow_dfs(G, e.to, t, min(f, e.cap), used); n       if (d > 0) { n         e.cap -= d; n         G[e.to][e.rev].cap += d; n         return d; n       } n     } n   } n   return 0; n } n long long max_flow(vector<vector<Edge>>& G, long long s, long long t) { n   long long flow = 0; n   for (;;) { n     vector<bool> used(G.size()); n     for (int(i) = (int)(0); i < (int)(used.size()); i++) used[i] = false; n     long long f = max_flow_dfs(G, s, t, INF, used); n     if (f == 0) { n       return flow; n     } n     flow += f; n   } n } n void BellmanFord(vector<vector<Edge>>& G, long long s, vector<long long>& d, n                  vector<long long>& negative) { n   d.resize(G.size()); n   negative.resize(G.size()); n   for (int(i) = (int)(0); i < (int)(d.size()); i++) d[i] = INF; n   for (int(i) = (int)(0); i < (int)(d.size()); i++) negative[i] = false; n   d[s] = 0; n   for (int(k) = (int)(0); k < (int)(G.size() - 1); k++) { n     for (int(i) = (int)(0); i < (int)(G.size()); i++) { n       for (int(j) = (int)(0); j < (int)(G[i].size()); j++) { n         if (d[i] != INF && d[G[i][j].to] > d[i] + G[i][j].cap) { n           d[G[i][j].to] = d[i] + G[i][j].cap; n         } n       } n     } n   } n   for (int(k) = (int)(0); k < (int)(G.size() - 1); k++) { n     for (int(i) = (int)(0); i < (int)(G.size()); i++) { n       for (int(j) = (int)(0); j < (int)(G[i].size()); j++) { n         if (d[i] != INF && d[G[i][j].to] > d[i] + G[i][j].cap) { n           d[G[i][j].to] = d[i] + G[i][j].cap; n           negative[G[i][j].to] = true; n         } n         if (negative[i] == true) negative[G[i][j].to] = true; n       } n     } n   } n } n void Dijkstra(vector<vector<Edge>>& G, long long s, vector<long long>& d) { n   d.resize(G.size()); n   for (int(i) = (int)(0); i < (int)(d.size()); i++) d[i] = INF; n   d[s] = 0; n   priority_queue<pair<long long, long long>, vector<pair<long long, long long>>, n                  greater<pair<long long, long long>>> n       q; n   q.push(make_pair(0, s)); n   while (!q.empty()) { n     pair<long long, long long> a = q.top(); n     q.pop(); n     if (d[a.second] < a.first) continue; n     for (int(i) = (int)(0); i < (int)(G[a.second].size()); i++) { n       Edge e = G[a.second][i]; n       if (d[e.to] > d[a.second] + e.cap) { n         d[e.to] = d[a.second] + e.cap; n         q.push(make_pair(d[e.to], e.to)); n       } n     } n   } n } n void WarshallFloyd(vector<vector<Edge>>& G, vector<vector<long long>>& d) { n   d.resize(G.size()); n   for (int(i) = (int)(0); i < (int)(d.size()); i++) d[i].resize(G.size()); n   for (int(i) = (int)(0); i < (int)(d.size()); i++) { n     for (int(j) = (int)(0); j < (int)(d[i].size()); j++) { n       d[i][j] = INF; n     } n   } n   for (int(i) = (int)(0); i < (int)(G.size()); i++) { n     for (int(j) = (int)(0); j < (int)(G[i].size()); j++) { n       d[i][G[i][j].to] = G[i][j].cap; n     } n   } n   for (int(i) = (int)(0); i < (int)(G.size()); i++) { n     for (int(j) = (int)(0); j < (int)(G.size()); j++) { n       for (int(k) = (int)(0); k < (int)(G.size()); k++) { n         chmin(d[j][k], d[j][i] + d[i][k]); n       } n     } n   } n } n bool tsort(vector<vector<Edge>>& graph, vector<int>& order) { n   int n = graph.size(), k = 0; n   vector<long long> in(n); n   for (auto& es : graph) n     for (auto& e : es) in[e.to]++; n   priority_queue<long long, vector<long long>, greater<long long>> que; n   for (int(i) = (int)(0); i < (int)(n); i++) n     if (in[i] == 0) que.push(i); n   while (que.size()) { n     int v = que.top(); n     que.pop(); n     order.push_back(v); n     for (auto& e : graph[v]) n       if (--in[e.to] == 0) que.push(e.to); n   } n   if (order.size() != n) n     return false; n   else n     return true; n } n class lca { n  public: n   const int n = 0; n   const int log2_n = 0; n   std::vector<std::vector<int>> parent; n   std::vector<int> depth; n   lca() {} n   lca(const vector<vector<Edge>>& g, int root) n       : n(g.size()), n         log2_n(log2(n) + 1), n         parent(log2_n, std::vector<int>(n)), n         depth(n) { n     dfs(g, root, -1, 0); n     for (int k = 0; k + 1 < log2_n; k++) { n       for (int v = 0; v < (int)g.size(); v++) { n         if (parent[k][v] < 0) n           parent[k + 1][v] = -1; n         else n           parent[k + 1][v] = parent[k][parent[k][v]]; n       } n     } n   } n   void dfs(const vector<vector<Edge>>& g, int v, int p, int d) { n     parent[0][v] = p; n     depth[v] = d; n     for (auto& e : g[v]) { n       if (e.to != p) dfs(g, e.to, v, d + 1); n     } n   } n   int get(int u, int v) { n     if (depth[u] > depth[v]) std::swap(u, v); n     for (int k = 0; k < log2_n; k++) { n       if ((depth[v] - depth[u]) >> k & 1) { n         v = parent[k][v]; n       } n     } n     if (u == v) return u; n     for (int k = log2_n - 1; k >= 0; k--) { n       if (parent[k][u] != parent[k][v]) { n         u = parent[k][u]; n         v = parent[k][v]; n       } n     } n     return parent[0][u]; n   } n }; n class UnionFind { n   vector<int> data; n   long long num; n  n  public: n   UnionFind(int size) : data(size, -1), num(size) {} n   bool unite(int x, int y) { n     x = root(x); n     y = root(y); n     if (x != y) { n       if (data[y] < data[x]) swap(x, y); n       data[x] += data[y]; n       data[y] = x; n     } n     num -= (x != y); n     return x != y; n   } n   bool findSet(int x, int y) { return root(x) == root(y); } n   int root(int x) { return data[x] < 0 ? x : data[x] = root(data[x]); } n   int size(int x) { return -data[root(x)]; } n   int numSet() { return num; } n }; n class SumSegTree { n  private: n   long long _sum(long long a, long long b, long long k, long long l, n                  long long r) { n     if (r <= a || b <= l) return 0; n     if (a <= l && r <= b) n       return dat[k]; n     else { n       long long s1 = _sum(a, b, 2 * k + 1, l, (l + r) / 2); n       long long s2 = _sum(a, b, 2 * k + 2, (l + r) / 2, r); n       return s1 + s2; n     } n   } n  n  public: n   long long n, height; n   vector<long long> dat; n   SumSegTree(long long _n) { n     n = 1; n     height = 1; n     while (n < _n) { n       n *= 2; n       height++; n     } n     dat = vector<long long>(2 * n - 1, 0); n   } n   void add(long long i, long long x) { n     i += n - 1; n     dat[i] += x; n     while (i > 0) { n       i = (i - 1) / 2; n       dat[i] += x; n     } n   } n   long long sum(long long a, long long b) { return _sum(a, b, 0, 0, n); } n }; n class RmqTree { n  private: n   long long _find(long long a, long long b, long long k, long long l, n                   long long r) { n     if (r <= a || b <= l) return INF; n     if (a <= l && r <= b) n       return dat[k]; n     else { n       long long s1 = _find(a, b, 2 * k + 1, l, (l + r) / 2); n       long long s2 = _find(a, b, 2 * k + 2, (l + r) / 2, r); n       return min(s1, s2); n     } n   } n  n  public: n   long long n, height; n   vector<long long> dat; n   RmqTree(long long _n) { n     n = 1; n     height = 1; n     while (n < _n) { n       n *= 2; n       height++; n     } n     dat = vector<long long>(2 * n - 1, INF); n   } n   void update(long long i, long long x) { n     i += n - 1; n     dat[i] = x; n     while (i > 0) { n       i = (i - 1) / 2; n       dat[i] = min(dat[i * 2 + 1], dat[i * 2 + 2]); n     } n   } n   long long find(long long a, long long b) { return _find(a, b, 0, 0, n); } n }; n void divisor(long long n, vector<long long>& ret) { n   for (long long i = 1; i * i <= n; i++) { n     if (n % i == 0) { n       ret.push_back(i); n       if (i * i != n) ret.push_back(n / i); n     } n   } n   sort(ret.begin(), ret.end()); n } n vector<long long> lis_fast(const vector<long long>& a) { n   const long long n = a.size(); n   vector<long long> A(n, INT_MAX); n   vector<long long> id(n); n   for (int i = 0; i < n; ++i) { n     id[i] = distance(A.begin(), lower_bound(A.begin(), A.end(), a[i])); n     A[id[i]] = a[i]; n   } n   long long m = *max_element(id.begin(), id.end()); n   vector<long long> b(m + 1); n   for (int i = n - 1; i >= 0; --i) n     if (id[i] == m) b[m--] = a[i]; n   return b; n } n bool z_algorithm(string& str, vector<int>& z, long long s) { n   const int L = str.size(); n   z.resize(str.size()); n   for (int i = 1, left = 0, right = 0; i < L; i++) { n     if (i > right) { n       left = right = i; n       for (; right < L && str[right - left] == str[right]; right++) n         ; n       z[i] = right - left; n       right--; n     } else { n       int k = i - left; n       if (z[k] < right - i + 1) { n         z[i] = z[k]; n       } else { n         left = i; n         for (; right < L && str[right - left] == str[right]; right++) n           ; n         z[i] = right - left; n         right--; n       } n     } n     if (z[i] == s) return true; n   } n   return false; n } n bool z_algorithm(string& str, vector<int>& z) { n   const int L = str.size(); n   z.resize(str.size()); n   for (int i = 1, left = 0, right = 0; i < L; i++) { n     if (i > right) { n       left = right = i; n       for (; right < L && str[right - left] == str[right]; right++) n         ; n       z[i] = right - left; n       right--; n     } else { n       int k = i - left; n       if (z[k] < right - i + 1) { n         z[i] = z[k]; n       } else { n         left = i; n         for (; right < L && str[right - left] == str[right]; right++) n           ; n         z[i] = right - left; n         right--; n       } n     } n   } n   return true; n } n struct RollingHash { n   static const int base1 = 1007, base2 = 2009; n   static const int mod1 = 1000000007, mod2 = 1000000009; n   vector<long long> hash1, hash2, power1, power2; n   RollingHash(const string& S) { n     int n = (int)S.size(); n     hash1.assign(n + 1, 0); n     hash2.assign(n + 1, 0); n     power1.assign(n + 1, 1); n     power2.assign(n + 1, 1); n     for (int i = 0; i < n; ++i) { n       hash1[i + 1] = (hash1[i] * base1 + S[i]) % mod1; n       hash2[i + 1] = (hash2[i] * base2 + S[i]) % mod2; n       power1[i + 1] = (power1[i] * base1) % mod1; n       power2[i + 1] = (power2[i] * base2) % mod2; n     } n   } n   inline pair<long long, long long> get(int l, int r) const { n     long long res1 = hash1[r] - hash1[l] * power1[r - l] % mod1; n     if (res1 < 0) res1 += mod1; n     long long res2 = hash2[r] - hash2[l] * power2[r - l] % mod2; n     if (res2 < 0) res2 += mod2; n     return {res1, res2}; n   } n   inline int getLCP(int a, int b) const { n     int len = min((int)hash1.size() - a, (int)hash1.size() - b); n     int low = 0, high = len; n     while (high - low > 1) { n       int mid = (low + high) >> 1; n       if (get(a, a + mid) != get(b, b + mid)) n         high = mid; n       else n         low = mid; n     } n     return low; n   } n }; n long long mod_pow(long long x, long long n, long long mod) { n   long long res = 1LL; n   while (n > 0) { n     if (n & 1) res = res * x % mod; n     x = x * x % mod; n     n >>= 1; n   } n   return res; n } n long long mod_inv(long long x, long long mod) { n   return mod_pow(x, mod - 2, mod); n } n class Combination { n  public: n   vector<long long> fact; n   vector<long long> inv; n   long long mod; n   long long mod_inv(long long x) { n     long long n = mod - 2LL; n     long long res = 1LL; n     while (n > 0) { n       if (n & 1) res = res * x % mod; n       x = x * x % mod; n       n >>= 1; n     } n     return res; n   } n   long long nCr(long long n, long long r) { n     return ((fact[n] * inv[r] % mod) * inv[n - r]) % mod; n   } n   long long nPr(long long n, long long r) { n     return (fact[n] * inv[n - r]) % mod; n   } n   long long nHr(long long n, long long r) { return nCr(r + n - 1, r); } n   Combination(long long n, long long _mod) { n     mod = _mod; n     fact.resize(n + 1); n     fact[0] = 1; n     for (int(i) = (int)(0); i < (int)(n); i++) { n       fact[i + 1] = (fact[i] * (i + 1LL)) % mod; n     } n     inv.resize(n + 1); n     for (int(i) = (int)(0); i < (int)(n + 1); i++) { n       inv[i] = mod_inv(fact[i]); n     } n   } n }; n long long gcd(long long m, long long n) { n   if (n == 0) return m; n   return gcd(n, m % n); n } n long long lcm(long long m, long long n) { return m / gcd(m, n) * n; } n vector<vector<long long>> mIdentity(long long n) { n   vector<vector<long long>> A(n, vector<long long>(n)); n   for (int i = 0; i < n; ++i) A[i][i] = 1; n   return A; n } n vector<vector<long long>> mMul(const vector<vector<long long>>& A, n                                const vector<vector<long long>>& B) { n   vector<vector<long long>> C(A.size(), vector<long long>(B[0].size())); n   for (int i = 0; i < C.size(); ++i) n     for (int j = 0; j < C[i].size(); ++j) n       for (int k = 0; k < A[i].size(); ++k) n         (C[i][j] += (A[i][k] % 1000000007) * (B[k][j] % 1000000007)) %= n             1000000007; n   return C; n } n vector<vector<long long>> mPow(const vector<vector<long long>>& A, n                                long long e) { n   return e == 0       ? mIdentity(A.size()) n          : e % 2 == 0 ? mPow(mMul(A, A), e / 2) n                       : mMul(A, mPow(A, e - 1)); n } n template <class T> n class RectangleSum { n  public: n   vector<vector<T>> sum; n   T GetSum(int left, int right, int top, int bottom) { n     T res = sum[bottom][right]; n     if (left > 0) res -= sum[bottom][left - 1]; n     if (top > 0) res -= sum[top - 1][right]; n     if (left > 0 && top > 0) res += sum[top - 1][left - 1]; n     return res; n   } n   RectangleSum(const vector<vector<T>>& s, int h, int w) { n     sum.resize(h); n     for (int i = 0; i < h; i++) sum[i].resize(w, 0); n     for (int y = 0; y < h; y++) { n       for (int x = 0; x < w; x++) { n         sum[y][x] = s[y][x]; n         if (y > 0) sum[y][x] += sum[y - 1][x]; n         if (x > 0) sum[y][x] += sum[y][x - 1]; n         if (y > 0 && x > 0) sum[y][x] -= sum[y - 1][x - 1]; n       } n     } n   } n }; n long long _garner(vector<long long>& xs, vector<long long>& mods) { n   int M = xs.size(); n   vector<long long> coeffs(M, 1), constants(M, 0); n   for (int i = 0; i < M - 1; ++i) { n     long long mod_i = mods[i]; n     long long v = (xs[i] - constants[i] + mod_i) % mod_i; n     v = (v * mod_pow(coeffs[i], mod_i - 2, mod_i)) % mod_i; n     for (int j = i + 1; j < M; j++) { n       long long mod_j = mods[j]; n       constants[j] = (constants[j] + coeffs[j] * v) % mod_j; n       coeffs[j] = (coeffs[j] * mod_i) % mod_j; n     } n   } n   return constants.back(); n } n template <typename T> n inline void bit_reverse(vector<T>& a) { n   int n = a.size(); n   int i = 0; n   for (int j = 1; j < n - 1; ++j) { n     for (int k = n >> 1; k > (i ^= k); k >>= 1) n       ; n     if (j < i) swap(a[i], a[j]); n   } n } n template <long long mod, long long primitive_root> n class NTT { n  public: n   long long get_mod() { return mod; } n   void _ntt(vector<long long>& a, int sign) { n     const int n = a.size(); n     assert((n ^ (n & -n)) == 0); n     const long long g = primitive_root; n     long long tmp = (mod - 1) * mod_pow(n, mod - 2, mod) % mod; n     long long h = mod_pow(g, tmp, mod); n     if (sign == -1) h = mod_pow(h, mod - 2, mod); n     bit_reverse(a); n     for (int m = 1; m < n; m <<= 1) { n       const int m2 = 2 * m; n       long long _base = mod_pow(h, n / m2, mod); n       long long _w = 1; n       for (int x = 0; x < m; ++x) { n         for (int s = x; s < n; s += m2) { n           long long u = a[s]; n           long long d = (a[s + m] * _w) % mod; n           a[s] = (u + d) % mod; n           a[s + m] = (u - d + mod) % mod; n         } n         _w = (_w * _base) % mod; n       } n     } n   } n   void ntt(vector<long long>& input) { _ntt(input, 1); } n   void intt(vector<long long>& input) { n     _ntt(input, -1); n     const long long n_inv = mod_pow(input.size(), mod - 2, mod); n     for (auto& x : input) x = (x * n_inv) % mod; n   } n   vector<long long> convolution(const vector<long long>& a, n                                 const vector<long long>& b) { n     int result_size = a.size() + b.size() - 1; n     int n = 1; n     while (n < result_size) n <<= 1; n     vector<long long> _a = a, _b = b; n     _a.resize(n, 0); n     _b.resize(n, 0); n     ntt(_a); n     ntt(_b); n     for (int i = 0; i < n; ++i) _a[i] = (_a[i] * _b[i]) % mod; n     intt(_a); n     _a.resize(result_size); n     return _a; n   } n }; n vector<long long> convolution_ntt(vector<long long>& a, vector<long long>& b, n                                   long long mod = 1224736769LL) { n   for (auto& x : a) x %= mod; n   for (auto& x : b) x %= mod; n   long long maxval = max(a.size(), b.size()) * n                      *max_element(a.begin(), a.end()) * n                      *max_element(b.begin(), b.end()); n   if (maxval < 1224736769) { n     NTT<1224736769, 3> ntt3; n     return ntt3.convolution(a, b); n   } n   NTT<167772161, 3> ntt1; n   NTT<469762049, 3> ntt2; n   NTT<1224736769, 3> ntt3; n   vector<long long> x1 = ntt1.convolution(a, b); n   vector<long long> x2 = ntt2.convolution(a, b); n   vector<long long> x3 = ntt3.convolution(a, b); n   vector<long long> ret(x1.size()); n   vector<long long> mods{167772161, 469762049, 1224736769, mod}; n   for (int i = 0; i < x1.size(); ++i) { n     vector<long long> xs{x1[i], x2[i], x3[i], 0}; n     ret[i] = _garner(xs, mods); n   } n   return ret; n } n int main() { n   ios::sync_with_stdio(false); n   cin.tie(0); n   long long n, k; n   cin >> n >> k; n   long long mi = (n + 1) * n / 2; n   long long ma = mi * 2 - (n / 2 + 1) * (n / 2); n   if (n % 2 == 1) ma -= n / 2 + 1; n   if (k < mi) { n     cout << -1 << endl; n     return 0; n   } n   cout << min(k, ma) << endl; n   for (int(i) = (int)(0); i < (int)(n); i++) cout << i + 1 <<    ; n   cout << endl; n   if (k >= ma) { n     for (int(i) = (int)(0); i < (int)(n); i++) cout << n - i <<    ; n     cout << endl; n     return 0; n   } n   long long rest = k - mi; n   vector<long long> ans(n); n   for (int(i) = (int)(0); i < (int)(n); i++) ans[i] = i + 1; n   long long now = 0; n   for (int i = n - 1; i >= 0; i--) { n     if (rest >= i - now) { n       swap(ans[i], ans[now]); n       rest -= i - now; n     } else { n       swap(ans[i], ans[i - rest]); n       break; n     } n     now++; n   } n   for (int(i) = (int)(0); i < (int)(n); i++) cout << ans[i] <<    ; n   cout << endl; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int vis[100005], mark[100005]; n vector<int> g[100005]; n int prob = 0; n void dfs(int node, int k) { n   mark[node] = k; n   vis[node] = 1; n   for (auto i : g[node]) { n     if (!vis[i]) { n       dfs(i, 1 - k); n     } else { n       if (mark[i] == k) { n         prob = 1; n       } n     } n   } n } n int main() { n   int n, m; n   cin >> n >> m; n   for (int i = 0; i < m; i++) { n     int u, v; n     scanf( %d , &u); n     scanf( %d , &v); n     g[u].push_back(v); n     g[v].push_back(u); n   } n   for (int i = 1; i <= n; i++) { n     if (!vis[i]) dfs(i, 0); n   } n   if (prob) { n     cout <<  -1 ; n     return 0; n   } n   int k = 0; n   for (int i = 1; i <= n; i++) { n     if (mark[i] == 1) k++; n   } n   cout << k <<   n ; n   for (int i = 1; i <= n; i++) { n     if (mark[i] == 1) cout << i <<    ; n   } n   cout <<   n ; n   k = 0; n   for (int i = 1; i <= n; i++) { n     if (mark[i] == 0) k++; n   } n   cout << k <<   n ; n   for (int i = 1; i <= n; i++) { n     if (mark[i] == 0) cout << i <<    ; n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int n, pd[4][10100], x, y, gox[4] = {1, 0, -1, 0}, goy[4] = {0, 1, 0, -1}, n                            w[16], dp[10100][8], mo = 1000000007; n char getin() { n   char ch = getchar(); n   while (ch !=  .  && ch !=  X  && ch !=  O ) ch = getchar(); n   return ch; n } n int check(int k1, int k2, int k3) { n   for (int i = 0; i < 3; i++) { n     if (pd[i + 1][k1]) { n       if (k2 & (1 << i)) return 0; n     } n     if (pd[i + 1][k1 - 1]) { n       if (k3 & (1 << i)) n         return 0; n       else n         k3 += (1 << i); n     } n   } n   int a[3] = {0}; n   for (int i = 0; i < 3; i++) n     if ((k3 & (1 << i)) == 0) a[i]--; n   for (int i = 0; i < 3; i++) n     if (k2 & (1 << i)) a[i]++; n   for (int i = 0; i < 3; i++) n     if (a[i] < 0) return 0; n   for (int i = 0; i < 2; i++) n     if (a[i] && a[i + 1] == 0) n       return 0; n     else if (a[i]) n       a[i + 1] = 0; n   if (a[2]) return 0; n   return 1; n } n int solve(int k) { n   memset(dp, 0x00, sizeof dp); n   dp[0][7] = 1; n   for (int i = 1; i <= n; i++) n     for (int j = 0; j < 8; j++) n       for (int k = 0; k < 8; k++) n         if (check(i, j, k)) dp[i][j] = (dp[i][j] + dp[i - 1][k]) % mo; n   int k1 = 0; n   for (int i = 0; i < 3; i++) n     if (pd[i + 1][n]) k1 += (1 << i); n   return dp[n][7 ^ k1]; n } n int dfs(int k1, int k2) { n   if (k1 == 4) return w[k2] * solve(k2); n   int flag = 0; n   for (int i = 1; i <= 2; i++) { n     int k3 = x + gox[k1] * i, k4 = y + goy[k1] * i; n     if (k3 <= 0 || k3 > 3 || k4 <= 0 || k4 > n || pd[k3][k4]) { n       flag = 1; n       break; n     } n   } n   int ans = 0; n   if (flag == 0) { n     for (int i = 1; i <= 2; i++) { n       int k3 = x + gox[k1] * i, k4 = y + goy[k1] * i; n       pd[k3][k4] = 1; n     } n     ans += dfs(k1 + 1, k2 + (1 << k1)); n     for (int i = 1; i <= 2; i++) { n       int k3 = x + gox[k1] * i, k4 = y + goy[k1] * i; n       pd[k3][k4] = 0; n     } n   } n   ans = (ans + dfs(k1 + 1, k2)) % mo; n   return ans; n } n int main() { n   scanf( %d , &n); n   for (int i = 1; i <= 3; i++) n     for (int j = 1; j <= n; j++) { n       char ch = getin(); n       if (ch ==  X ) n         pd[i][j] = 1; n       else if (ch ==  O ) { n         pd[i][j] = 2; n         x = i; n         y = j; n       } n     } n   for (int i = 1; i < 16; i++) { n     w[i] = 1; n     for (int j = (i - 1) & i; j; j = (j - 1) & i) w[i] = w[i] - w[j]; n   } n   cout << (dfs(0, 0) + mo) % mo << endl; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n template <typename T> n T sqr(T x) { n   return x * x; n } n template <typename T> n T abs(T x) { n   return x < 0 ? -x : x; n } n template <typename T> n T gcd(T a, T b) { n   return b ? gcd(b, a % b) : a; n } n set<vector<int> > s; n vector<pair<char, pair<int, int> > > ans; n bool rec(vector<int>& a) { n   if (a.size() == 1) { n     return a[0] == 24; n   } n   if (s.find(a) != s.end()) { n     return false; n   } n   s.insert(a); n   for (size_t i = 0; i < a.size(); ++i) { n     for (size_t j = i + 1; j < a.size(); ++j) { n       vector<int> b = a; n       int x = a[i], y = a[j]; n       b.erase(b.begin() + j); n       b.erase(b.begin() + i); n       b.push_back(x + y); n       ans.push_back(make_pair( + , make_pair(x, y))); n       if (rec(b)) { n         return true; n       } n       b.pop_back(); n       ans.pop_back(); n       b.push_back(y - x); n       ans.push_back(make_pair( - , make_pair(y, x))); n       if (rec(b)) { n         return true; n       } n       b.pop_back(); n       ans.pop_back(); n       b.push_back(x - y); n       ans.push_back(make_pair( - , make_pair(x, y))); n       if (rec(b)) { n         return true; n       } n       b.pop_back(); n       ans.pop_back(); n       b.push_back(x * y); n       ans.push_back(make_pair( * , make_pair(x, y))); n       if (rec(b)) { n         return true; n       } n       b.pop_back(); n       ans.pop_back(); n     } n   } n   return false; n } n int main(int, char**) { n   ios_base::sync_with_stdio(false); n   int n; n   cin >> n; n   if (n < 4) { n     cout <<  NO  << endl; n     return 0; n   } n   cout <<  YES  << endl; n   vector<int> a; n   for (int i = 1; i <= n % 2 + 4; ++i) { n     a.push_back(i); n   } n   rec(a); n   for (int i = n % 2 + 4; i < n; i += 2) { n     ans.push_back(make_pair( - , make_pair(i + 2, i + 1))); n     ans.push_back(make_pair( * , make_pair(24, 1))); n   } n   for (size_t i = 0; i < ans.size(); ++i) { n     int x = ans[i].second.first; n     int y = ans[i].second.second; n     int r = -1; n     switch (ans[i].first) { n       case  - : n         r = x - y; n         break; n       case  + : n         r = x + y; n         break; n       case  * : n         r = x * y; n         break; n     } n     cout << x <<     << ans[i].first <<     << y <<   =   << r << endl; n   } n   fprintf(stderr,  Time execute: %.3lf sec n , n           clock() / (double)CLOCKS_PER_SEC); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n void fast(); n int main() { n   fast(); n   int k, d; n   cin >> k >> d; n   string ans =   ; n   if ((d > (pow(10, k) - 1)) || (d == 0 && k != 1)) { n     cout <<  No solution ; n     return 0; n   } n   for (int i = 0; i < k; i++) { n     if (d > 9) { n       ans +=  9 ; n       d -= 9; n     } else { n       stringstream t; n       t << d; n       ans += t.str(); n       d = 0; n     } n   } n   cout << ans; n   return 0; n } n void fast() { n   ios_base::sync_with_stdio(0); n   cin.tie(NULL), cout.tie(NULL); n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int INF = 1029384756; n const double PI = acos(-1); n const double EPS = 0.0000000304; n long long A, B, C; n int main() { n   scanf( %I64d%I64d%I64d , &A, &B, &C); n   if ((A % 2) == (B % 2) && (B % 2) == (C % 2)) { n     printf( %I64d , A + B + C - max(A, max(B, C)) - min(A, min(B, C))); n   } else if (A % 2 == B % 2) { n     printf( %I64d , max(A, B)); n   } else if (A % 2 == C % 2) { n     printf( %I64d , max(A, C)); n   } else { n     printf( %I64d , max(B, C)); n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n vector<long long int> v; n int main() { n   long long int n, m, a, b, sum = 0, i, j, k; n   cin >> n >> k; n   long long int s[n], x[n]; n   for (i = 0; i < n; i++) { n     cin >> a >> b; n     sum += min(a, b); n     v.push_back(min(2 * a, b) - min(a, b)); n   } n   sort(v.begin(), v.end()); n   for (i = 0; i < n && i < k; i++) sum += v[n - i - 1]; n   cout << sum << endl; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int inf = 0x3f3f3f3f; n const double eps = 1e-6; n template <typename A, typename B> n ostream& operator<<(ostream& os, const pair<A, B>& p) { n   return os << p.first <<  ,  << p.second; n } n template <typename T> n struct point { n   T x, y; n   point(T xx = 0, T yy = 0) : x(xx), y(yy) {} n   T len2() const { return x * x + y * y; } n   double len() const { return sqrt(double(len2())); } n   bool operator==(const point<T>& p) const { return x == p.x && y == p.y; } n }; n template <typename T> n point<T> operator+(const point<T>& a, const point<T>& b) { n   return point<T>(a.x + b.x, a.y + b.y); n } n template <typename T> n point<T> operator-(const point<T>& a, const point<T>& b) { n   return point<T>(a.x - b.x, a.y - b.y); n } n template <typename T> n T scal(const point<T>& a, const point<T>& b) { n   return a.x * b.x + a.y * b.y; n } n template <typename T> n T vect(const point<T>& a, const point<T>& b) { n   return a.x * b.y - a.y * b.x; n } n template <typename T> n ostream& operator<<(ostream& os, const point<T>& p) { n   return os <<  (  << p.x <<  ,  << p.y <<  ) ; n } n const int maxn = 100100; n pair<int, pair<int, int> > a[maxn], b[maxn]; n int below[maxn], direct[maxn], belowsecond[maxn]; n long long d[maxn][2]; n int main() { n   int n; n   cin >> n; n   for (int i = 0; i < n; i++) { n     scanf( %d%d , &a[i].second.first, &a[i].first); n     a[i].second.second = i; n   } n   int m; n   cin >> m; n   for (int i = 0; i < m; i++) { n     scanf( %d%d , &b[i].second.first, &b[i].first); n     b[i].second.second = i; n   } n   sort(a, a + n); n   sort(b, b + m); n   memset(direct, -1, sizeof(direct)); n   memset(below, -1, sizeof(below)); n   memset(belowsecond, -1, sizeof(belowsecond)); n   for (int i = 0; i < n; i++) { n     pair<int, pair<int, int> >* d1 = n         lower_bound(b, b + m, n                     pair<int, pair<int, int> >( n                         a[i].first, pair<int, int>(a[i].second.first, 0))); n     pair<int, pair<int, int> >* d2 = n         lower_bound(b, b + m, n                     pair<int, pair<int, int> >( n                         a[i].first - 1, pair<int, int>(a[i].second.first, 0))); n     if (d1 != b + m && d1->first == a[i].first && n         d1->second.first >= a[i].second.first) { n       direct[i] = d1->second.second; n     } n     if (d2 != b + m && d2->first + 1 == a[i].first && n         d2->second.first >= a[i].second.first) { n       below[i] = d2->second.second; n       d2++; n       if (d2 != b + m && d2->first + 1 == a[i].first && n           d2->second.first >= a[i].second.first) { n         belowsecond[i] = d2->second.second; n       } n     } n   } n   long long mx = 0; n   for (int i = 0; i < n; i++) { n     if (direct[i] >= 0) { n       long long q = max(d[i][0], d[i][1]); n       d[i + 1][1] = max(d[i + 1][1], a[i].second.first + q); n     } n     if (below[i] >= 0) { n       d[i + 1][0] = max(d[i + 1][0], d[i][0] + a[i].second.first); n       if (i > 0 && direct[i - 1] != below[i]) { n         d[i + 1][0] = max(d[i + 1][0], d[i][1] + a[i].second.first); n       } n       if (i > 0 && direct[i - 1] == below[i] && belowsecond[i] >= 0) { n         d[i + 1][0] = max(d[i + 1][0], d[i][1] + a[i].second.first); n       } n     } n     d[i + 1][0] = max(d[i + 1][0], max(d[i][0], d[i][1])); n     mx = max(mx, max(d[i + 1][0], d[i + 1][1])); n   } n   cout << mx << endl; n   int cur = n; n   int t = 0; n   if (d[cur][t] != mx) t++; n   assert(d[cur][t] == mx); n   vector<pair<int, int> > res; n   set<int> guyused; n   for (; cur > 0; cur--) { n     if (res.size()) { n       guyused.insert(res.back().second); n     } n     if (d[cur - 1][0] == d[cur][t]) { n       t = 0; n       continue; n     } n     if (d[cur - 1][1] == d[cur][t]) { n       t = 1; n       continue; n     } n     int p = a[cur - 1].second.first; n     if (!guyused.count(direct[cur - 1])) { n       if (p + d[cur - 1][1] == mx && direct[cur - 1] >= 0) { n         res.push_back( n             pair<int, int>(a[cur - 1].second.second, direct[cur - 1])); n         mx -= p; n         t = 1; n         continue; n       } n       if (p + d[cur - 1][0] == mx && direct[cur - 1] >= 0) { n         res.push_back( n             pair<int, int>(a[cur - 1].second.second, direct[cur - 1])); n         mx -= p; n         t = 0; n         continue; n       } n     } n     assert(below[cur - 1] >= 0); n     if (!guyused.count(below[cur - 1])) { n       if (d[cur - 1][0] + p == mx) { n         res.push_back(pair<int, int>(a[cur - 1].second.second, below[cur - 1])); n         mx -= p; n         t = 0; n         continue; n       } n       if (cur - 2 < 0 || n           (direct[cur - 2] != below[cur - 1] && d[cur - 1][1] + p == mx)) { n         res.push_back(pair<int, int>(a[cur - 1].second.second, below[cur - 1])); n         mx -= p; n         t = 1; n         continue; n       } n     } n     assert(!guyused.count(belowsecond[cur - 1])); n     if (cur - 2 >= 0 && direct[cur - 2] == below[cur - 1] && n         belowsecond[cur - 1] >= 0 && d[cur - 1][1] + p == mx) { n       res.push_back( n           pair<int, int>(a[cur - 1].second.second, belowsecond[cur - 1])); n       mx -= p; n       t = 1; n       continue; n     } n     assert(0); n   } n   printf( %d n , res.size()); n   for (int i = 0; i < res.size(); i++) { n     printf( %d %d n , res[i].second + 1, res[i].first + 1); n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n inline int read() { n   int x = 0, neg = 1; n   char c = getchar(); n   while (!isdigit(c)) { n     if (c ==  - ) neg = -1; n     c = getchar(); n   } n   while (isdigit(c)) x = x * 10 + c -  0 , c = getchar(); n   return x * neg; n } n inline int qpow(int x, int e, int _MOD) { n   int ans = 1; n   while (e) { n     if (e & 1) ans = ans * x % _MOD; n     x = x * x % _MOD; n     e >>= 1; n   } n   return ans; n } n int n = read(), s = read(), a[200005], b[200005], c[200005], d[200005], num = 0; n vector<int> g[200005], cyc[200005]; n int k = 0; n inline void dfs(int x) { n   while (!g[x].empty()) { n     int y = g[x].back(); n     g[x].pop_back(); n     dfs(a[y]); n     cyc[k].push_back(y); n   } n } n signed main() { n   for (int i = 1; i <= n; i++) a[i] = read(), c[i] = a[i]; n   sort(c + 1, c + n + 1); n   for (int i = 1; i <= n; i++) n     if (c[i] != c[i - 1]) d[++num] = c[i]; n   for (int i = 1; i <= n; i++) n     a[i] = lower_bound(d + 1, d + num + 1, a[i]) - d, b[i] = a[i]; n   sort(b + 1, b + n + 1); n   int cnt = 0; n   for (int i = 1; i <= n; i++) { n     if (a[i] != b[i]) { n       cnt++; n       g[b[i]].push_back(i); n     } n   } n   if (!cnt) return puts( 0 ), 0; n   if (cnt > s) return puts( -1 ), 0; n   for (int i = 1; i <= num; i++) { n     if (!g[i].empty()) { n       k++; n       dfs(i); n     } n   } n   for (int i = 1; i <= k; i++) reverse(cyc[i].begin(), cyc[i].end()); n   if (k == 1) { n     cout << 1 << endl << cyc[1].size() << endl; n     for (__typeof(cyc[1].begin()) it = cyc[1].begin(); it != cyc[1].end(); it++) n       cout << *it <<    ; n     return 0; n   } n   if (cnt <= s - k) { n     cout << 2 << endl; n     cout << cnt << endl; n     for (int i = 1; i <= k; i++) { n       for (__typeof(cyc[i].begin()) it = cyc[i].begin(); it != cyc[i].end(); n            it++) n         cout << *it <<    ; n     } n     puts(  ); n     cout << k << endl; n     for (int i = k; i >= 1; i--) cout << cyc[i][0] <<    ; n     puts(  ); n     return 0; n   } else { n     int t = cnt - (s - k); n     if (t == k) n       cout << t << endl; n     else if (t == k - 1) n       cout << t + 1 << endl; n     else n       cout << t + 2 << endl; n     for (int i = 1; i <= t; i++) { n       cout << cyc[i].size() << endl; n       for (__typeof(cyc[i].begin()) it = cyc[i].begin(); it != cyc[i].end(); n            it++) n         cout << *it <<    ; n       puts(  ); n     } n     int sum = 0; n     if (t != k) { n       for (int i = t + 1; i <= k; i++) sum += cyc[i].size(); n       cout << sum << endl; n       for (int i = t + 1; i <= k; i++) n         for (__typeof(cyc[i].begin()) it = cyc[i].begin(); it != cyc[i].end(); n              it++) n           cout << *it <<    ; n       if (t != k - 1) { n         puts(  ); n         cout << k - t << endl; n         for (int i = k; i >= t + 1; i--) cout << cyc[i][0] <<    ; n       } n     } n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int maxn = 5e5 + 10; n int t, n, son[maxn], root, p[maxn], rt; n vector<int> g[maxn]; n void dfs(int u, int fa) { n   son[u] = 1; n   p[u] = fa; n   for (auto it : g[u]) { n     if (it == fa) continue; n     dfs(it, u); n     son[u] += son[it]; n   } n } n void getroot(int u, int fa) { n   root = u; n   for (auto it : g[u]) { n     if (it == fa) continue; n     if (son[it] > n - son[it]) getroot(it, u); n   } n } n int getleaf(int u, int fa) { n   if (g[u].size() == 1) return u; n   for (auto it : g[u]) { n     if (it == fa) continue; n     return getleaf(it, u); n   } n } n int main() { n   scanf( %d , &t); n   while (t--) { n     root = rt = 0; n     scanf( %d , &n); n     for (int i = 1; i < n; i++) { n       int u, v; n       scanf( %d%d , &u, &v); n       g[u].push_back(v); n       g[v].push_back(u); n     } n     dfs(1, 0); n     getroot(1, 0); n     for (auto it : g[root]) { n       if (it != p[root] && son[it] == n - son[it]) rt = it; n     } n     if (!rt) { n       printf( %d %d n%d %d n , root, g[root][0], root, g[root][0]); n     } else { n       int l = getleaf(rt, p[rt]); n       printf( %d %d n%d %d n , p[l], l, root, l); n     } n     for (int i = 1; i <= n; i++) g[i].clear(), p[i] = 0; n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n template <class T> n inline bool cmax(T &a, const T &b) { n   return a < b ? a = b, 1 : 0; n } n const int N = 444444; n int fa[N], ch[N][26], l[N], f[N], a[N], c[N], pos[N], top[N]; n char s[N]; n int last = 1, cnt = 1, n, ans = 1; n void ins(int c, int k) { n   int p = last, np = ++cnt; n   last = np, l[np] = l[p] + 1, pos[np] = k; n   for (; p && !ch[p][c]; p = fa[p]) ch[p][c] = np; n   if (!p) n     fa[np] = 1; n   else { n     int q = ch[p][c]; n     if (l[q] == l[p] + 1) n       fa[np] = q; n     else { n       int nq = ++cnt; n       l[nq] = l[p] + 1, pos[nq] = pos[q]; n       memcpy(ch[nq], ch[q], sizeof(ch[q])); n       fa[nq] = fa[q], fa[np] = fa[q] = nq; n       for (; ch[p][c] == q; p = fa[p]) ch[p][c] = nq; n     } n   } n } n void calc() { n   for (int i = 1; i <= cnt; ++i) ++c[l[i]]; n   for (int i = 1; i <= cnt; ++i) c[i] += c[i - 1]; n   for (int i = 1; i <= cnt; ++i) a[c[l[i]]--] = i; n } n int L[N * 25], R[N * 25], rt[N], tot; n void modify(int &now, int l, int r, int x) { n   now = ++tot; n   if (l == r) return; n   int mid = l + r >> 1; n   if (x <= mid) n     modify(L[now], l, mid, x); n   else n     modify(R[now], mid + 1, r, x); n } n int merge(int x, int y) { n   if (!x || !y) return x | y; n   int z = ++tot; n   L[z] = merge(L[x], L[y]); n   R[z] = merge(R[x], R[y]); n   return z; n } n int query(int x, int l, int r, int ql, int qr) { n   if (!x) return 0; n   if (ql <= l && qr >= r) return 1; n   int mid = l + r >> 1; n   if (ql <= mid && query(L[x], l, mid, ql, qr)) return 1; n   if (qr > mid && query(R[x], mid + 1, r, ql, qr)) return 1; n   return 0; n } n int main() { n   scanf( %d , &n); n   scanf( %s , s + 1); n   for (int i = 1; i <= n; ++i) ins(s[i] -  a , i), modify(rt[last], 1, n, i); n   calc(); n   for (int i = cnt; i > 1; --i) rt[fa[a[i]]] = merge(rt[fa[a[i]]], rt[a[i]]); n   for (int i = 2; i <= cnt; ++i) { n     int u = a[i], ff = fa[u]; n     if (ff == 1) { n       f[u] = 1, top[u] = u; n       continue; n     } n     int x = query(rt[top[ff]], 1, n, pos[u] - l[u] + l[top[ff]], pos[u] - 1); n     if (x) n       f[u] = f[ff] + 1, top[u] = u; n     else n       f[u] = f[ff], top[u] = top[ff]; n     cmax(ans, f[u]); n   } n   printf( %d n , ans); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const double eps = 1e-9; n const long long MOD = 998244353; n const long long N = (long long)1e4 + 9; n const long long inf = 1 << 30; n template <class T> n T gcd(T a, T b) { n   return (b != 0 ? gcd<T>(b, a % b) : a); n } n template <class T> n T lcm(T a, T b) { n   return (a / gcd<T>(a, b) * b); n } n template <typename T> n T exp(T b, T p) { n   T x = 1; n   while (p) { n     if (p & 1) x = (x * b); n     b = (b * b); n     p = p >> 1; n   } n   return x; n } n inline long long ones(long long n) { n   long long res = 0; n   while (n && ++res) n -= n & (-n); n   return res; n } n inline bool EQ(double a, double b) { return fabs(a - b) < 1e-9; } n long long mem[109][3]; n long long n, arr[109]; n long long go(long long idx, long long last) { n   if (idx == n) return 0; n   long long &ret = mem[idx][last]; n   if (ret != -1) return ret; n   ret = -inf; n   if (arr[idx] == 0) ret = go(idx + 1, 0); n   if (arr[idx] == 3) { n     if (last != 1) ret = max(ret, 1 + go(idx + 1, 1)); n     if (last != 2) ret = max(ret, 1 + go(idx + 1, 2)); n   } n   if (arr[idx] == 1) { n     if (last != 1) n       ret = 1 + go(idx + 1, 1); n     else n       ret = go(idx + 1, 0); n   } n   if (arr[idx] == 2) { n     if (last != 2) n       ret = 1 + go(idx + 1, 2); n     else n       ret = go(idx + 1, 0); n   } n   return ret; n } n int32_t main() { n   ios::sync_with_stdio(0); n   cin.tie(nullptr); n   cout.tie(0); n   cin >> n; n   for (long long i = 0; i < n; ++i) { n     cin >> arr[i]; n   } n   memset(mem, -1, sizeof(mem)); n   long long ans = go(0, 0); n   cout << n - ans; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const double PI = 3.14159265358979323846; n int a[100010], d[100010]; n int main() { n   int n; n   cin >> n; n   for (int i = 1; i <= n; i++) scanf( %d , a + i); n   for (int i = 1; i <= n + 1; i++) d[i] = a[i] - a[i - 1]; n   stack<int> st; n   int r = 0; n   for (int i = 1; i <= n; i++) { n     if (d[i] > 0) r += d[i]; n   } n   cout << r << endl; n   for (int i = 1; i <= n + 1; i++) { n     if (d[i] > 0) { n       for (int j = 0; j < d[i]; j++) { n         st.push(i); n       } n     } n     if (d[i] < 0) { n       for (int j = 0; j > d[i]; j--) { n         printf( %d %d n , st.top(), i - 1); n         st.pop(); n       } n     } n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n long long n, k, q, a, b, ans, t; n int main() { n   ios_base::sync_with_stdio(0); n   cin.tie(0); n   cout.tie(0); n   cin >> q; n   while (q--) { n     cin >> k >> n >> a >> b; n     ans = a * n; n     if (b * n >= k) n       cout << -1 <<   n ; n     else { n       if (ans < k) n         cout << n <<   n ; n       else { n         t = a - b; n         ans = (ans - k) / t + 1; n         cout << n - ans <<   n ; n       } n     } n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n long long n, m, k, x, y, z, a[5005], b[50005], ans, val; n int main() { n   ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0); n   cin >> n; n   for (long long i = 0; i < n; i++) cin >> a[i]; n   cin >> m; n   for (long long i = 0; i < m; i++) cin >> b[i]; n   sort(a, a + n); n   sort(b, b + m); n   cout << a[n - 1] <<     << b[m - 1]; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int inf = ~0U >> 1; n const long long INF = ~0ULL >> 1; n template <class T> n inline void read(T &n) { n   char c; n   int flag = 1; n   for (c = getchar(); !(c >=  0  && c <=  9  || c ==  - ); c = getchar()) n     ; n   if (c ==  - ) n     flag = -1, n = 0; n   else n     n = c -  0 ; n   for (c = getchar(); c >=  0  && c <=  9 ; c = getchar()) n = n * 10 + c -  0 ; n   n *= flag; n } n const int maxn = 2100000; n const int mo = 1000000007; n int N, K, M, ans, vis[1000]; n char s[maxn]; n int nxt[maxn][26]; n int dp[maxn]; n void add(int &x, int y) { n   x += y; n   if (x >= mo) x -= mo; n } n int main(int argc, char *argv[]) { n   scanf( %d%d , &N, &K); n   scanf( %s , s + 1); n   M = strlen(s + 1); n   string temp =   ; n   for (int i = (M); i >= (1); --i) n     if (!vis[s[i]]) vis[s[i]] = true, temp = s[i] + temp; n   for (int i = ( a ); i <= ( a  + K - 1); ++i) n     if (!vis[i]) temp = (char)i + temp; n   for (int i = (0); i < (N); ++i) s[++M] = temp[i % temp.size()]; n   for (int j = (0); j < (K); ++j) nxt[M + 1][j] = M + 1; n   for (int i = (M); i >= (1); --i) { n     memcpy(nxt[i], nxt[i + 1], sizeof(nxt[i])); n     nxt[i][s[i] -  a ] = i; n   } n   int cur = 0; n   dp[0] = 1; n   for (int i = (0); i < (M); ++i) { n     int flag = false; n     for (int j = (0); j < (K); ++j) n       if (nxt[i + 1][j] <= M) add(dp[nxt[i + 1][j]], dp[i]); n   } n   for (int i = (0); i <= (M); ++i) add(ans, dp[i]); n   printf( %d n , ans); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int prime = 151; n const long long mod = 1e9 + 7; n const int maxn = 1e5 + 5; n const int inf = 0x3f3f3f3f; n int slen, tlen; n string t, s; n unsigned long long hs1[maxn], base[maxn], hs2[maxn]; n inline unsigned long long check(int l, int r, unsigned long long hs[]) { n   return hs[r] - hs[l - 1] * base[r - l + 1]; n } n inline int solve() { n   slen = s.length(), tlen = t.length(); n   base[0] = 1; n   for (int i = 1; i <= max(slen, tlen); ++i) base[i] = base[i - 1] * prime; n   for (int i = 1; i <= tlen; ++i) hs2[i] = hs2[i - 1] * prime + t[i - 1]; n   for (int i = 1; i <= slen; ++i) hs1[i] = hs1[i - 1] * prime + s[i - 1]; n   int ans = 0; n   if (s.find(t) == string::npos && t.find(s) == string::npos) return 0; n   if (tlen < slen) { n     for (int i = 1; i <= tlen; ++i) { n       if (check(1 + i, tlen, hs2) == check(1, tlen - i, hs2) && tlen % i == 0 && n           check(1 + i, slen, hs1) == check(1, slen - i, hs1) && slen % i == 0) n         ++ans; n     } n   } else { n     for (int i = 1; i <= slen; ++i) { n       if (check(1 + i, slen, hs1) == check(1, slen - i, hs1) && slen % i == 0 && n           check(1 + i, tlen, hs2) == check(1, tlen - i, hs2) && tlen % i == 0) n         ++ans; n     } n   } n   return ans; n } n int main() { n   { n     ios::sync_with_stdio(0); n     cin.tie(0); n     cout.tie(0); n   } n   cin >> t >> s; n   cout << solve(); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n template <class T> n inline void read(T& x) { n   bool fu = 0; n   char c; n   for (c = getchar(); c <= 32; c = getchar()) n     ; n   if (c ==  - ) fu = 1, c = getchar(); n   for (x = 0; c > 32; c = getchar()) x = x * 10 + c -  0 ; n   if (fu) x = -x; n }; n template <class T> n inline void read(T& x, T& y) { n   read(x); n   read(y); n } n template <class T> n inline void read(T& x, T& y, T& z) { n   read(x); n   read(y); n   read(z); n } n inline char getc() { n   char c; n   for (c = getchar(); c <= 32; c = getchar()) n     ; n   return c; n } n int n, m, st, i, j, k, l, K, P, x, y; n int D0[610], D1[610], n0[610], n1[610]; n int e[610][610]; n long long a[610][610]; n bool vis[610]; n long long f[610]; n long long dfs(int i) { n   if (i == st) return 1; n   if (vis[i]) return f[i]; n   vis[i] = 1; n   long long ans = 0; n   for (int j = 1; j <= n; j++) n     if (e[j][i]) ans = (ans + dfs(j) * e[j][i]) % P; n   return f[i] = ans; n } n int main() { n   read(n, m, P); n   for (i = 1; i <= m; i++) read(x, y), e[x][y]++, D0[x]++, D1[y]++; n   for (i = 1; i <= n; i++) n     if (D0[i] == 0) n0[i] = ++n0[0]; n   for (i = 1; i <= n; i++) n     if (D1[i] == 0) n1[i] = ++n1[0]; n   K = n0[0]; n   for (i = 1; i <= n; i++) n     if (n1[i]) { n       memset(vis, 0, sizeof(vis)); n       memset(f, 0, sizeof(f)); n       st = i; n       for (j = 1; j <= n; j++) n         if (n0[j]) a[n1[i]][n0[j]] = dfs(j); n     } n   long long ans = 1; n   for (i = 1; i <= K; i++) { n     for (j = i; j <= K; j++) n       if (a[j][i]) { n         if (j != i) ans = -ans; n         for (k = i; k <= K; k++) swap(a[j][k], a[i][k]); n         break; n       } n     if (a[i][i] == 0) continue; n     for (j = i + 1; j <= K; j++) n       while (a[j][i]) { n         long long res = a[j][i] / a[i][i]; n         for (k = i; k <= K; k++) a[j][k] = (a[j][k] - a[i][k] * res) % P; n         if (a[j][i]) { n           ans = -ans; n           for (k = i; k <= K; k++) swap(a[j][k], a[i][k]); n         } n       } n   } n   for (i = 1; i <= K; i++) ans = ans * a[i][i] % P; n   if (ans < 0) ans += P; n   cout << ans << endl; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n template <class T> n inline T bigmod(T p, T e, T M) { n   long long ret = 1; n   for (; e > 0; e >>= 1) { n     if (e & 1) ret = (ret * p) % M; n     p = (p * p) % M; n   } n   return (T)ret; n } n template <class T> n inline T gcd(T a, T b) { n   if (b == 0) return a; n   return gcd(b, a % b); n } n template <class T> n inline T lcm(T a, T b) { n   return (a / gcd(a, b)) * b; n } n template <class T> n inline T modinverse(T a, T M) { n   return bigmod(a, M - 2, M); n } n template <class T> n inline T bpow(T p, T e) { n   long long ret = 1; n   for (; e > 0; e >>= 1) { n     if (e & 1) ret = (ret * p); n     p = (p * p); n   } n   return (T)ret; n } n template <class T> n inline T gethash(T h[], T power[], int l, int r) { n   if (r < l) return (T)0; n   return h[l] - h[r + 1] * power[r - l + 1]; n } n struct data { n   data() {} n   bool friend operator<(data a, data b) { return 0; } n }; n int n, m, k; n long long N, M, K; n int a[200005]; n long long ans[200005]; n vector<int> adj[200005]; n int subtree[200005]; n bool bad[200005]; n int tot = 0; n int cnt[200005]; n unordered_set<int> st; n unordered_set<int>::iterator it; n unordered_map<int, int> mm[200005]; n int _gcd(int a, int b) { n   if (a == 0) return b; n   if (b == 0) return a; n   int p = _gcd(b, a % b); n   return p; n } n void dfs(int u, int p) { n   subtree[u] = 1; n   tot++; n   for (int i = 0; i < adj[u].size(); i++) { n     int v = adj[u][i]; n     if (v == p || bad[v]) continue; n     dfs(v, u); n     subtree[u] += subtree[v]; n   } n } n int getcenter(int u, int p) { n   for (int i = 0; i < adj[u].size(); i++) { n     int v = adj[u][i]; n     if (v == p || bad[v]) continue; n     if (subtree[v] > tot / 2) return getcenter(v, u); n   } n   return u; n } n void query(int u, int p, int g) { n   g = _gcd(g, a[u]); n   for (it = st.begin(); it != st.end(); it++) { n     int x = *it; n     int gc = _gcd(g, x); n     ans[gc] += cnt[x]; n   } n   for (int i = 0; i < adj[u].size(); i++) { n     int v = adj[u][i]; n     if (v == p || bad[v]) continue; n     query(v, u, g); n   } n } n void update(int u, int p, int g) { n   g = _gcd(a[u], g); n   st.insert(g); n   cnt[g]++; n   for (int i = 0; i < adj[u].size(); i++) { n     int v = adj[u][i]; n     if (v == p || bad[v]) continue; n     update(v, u, g); n   } n } n void decompose(int u, int p) { n   tot = 0; n   dfs(u, p); n   int c = getcenter(u, p); n   ans[a[c]]++; n   cnt[a[c]] = 1; n   st.insert(a[c]); n   bad[c] = 1; n   for (int i = 0; i < adj[c].size(); i++) { n     int v = adj[c][i]; n     if (v == p || bad[v]) continue; n     query(v, c, 0); n     update(v, c, a[c]); n   } n   for (it = st.begin(); it != st.end(); it++) { n     int x = *it; n     cnt[x] = 0; n   } n   st.clear(); n   for (int i = 0; i < adj[c].size(); i++) { n     int v = adj[c][i]; n     if (v == p || bad[v]) continue; n     decompose(v, c); n   } n } n int main() { n   int t, tc = 1; n   scanf( %d , &n); n   for (int i = 1; i <= n; i++) { n     scanf( %d , &a[i]); n   } n   for (int i = 1; i < n; i++) { n     int u, v; n     scanf( %d %d , &u, &v); n     adj[u].push_back(v); n     adj[v].push_back(u); n   } n   decompose(1, -1); n   for (int i = 1; i <= 200000; i++) { n     if (ans[i]) { n       printf( %d %lld n , i, ans[i]); n     } n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int main() { n   int n, m; n   cin >> n >> m; n   vector<long long> p(n + 1, 1); n   for (int i = 1; i <= n; ++i) p[i] = p[i - 1] * 7; n   vector<long long> h(n + 1, 0); n   for (int i = 0; i < m; ++i) { n     int x, y; n     cin >> x >> y; n     h[x] += p[y]; n     h[y] += p[x]; n   } n   vector<long long> hh(n + 1, 0); n   for (int i = 0; i <= n; ++i) { n     hh[i] = h[i] + p[i]; n   } n   sort(h.begin() + 1, h.end()); n   sort(hh.begin() + 1, hh.end()); n   long long res = 0; n   for (int i = 1, cnt = 0; i <= n; ++i) { n     if (h[i] == h[i - 1]) n       res += cnt++; n     else n       cnt = 1; n   } n   for (int i = 1, cnt = 0; i <= n; ++i) { n     if (hh[i] == hh[i - 1]) n       res += cnt++; n     else n       cnt = 1; n   } n   cout << res << endl; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int main() { n   int a[] = {0, 1, 2, 3, 4}; n   int lst[5][5]; n   for (int i = 0; i < 5; i++) n     for (int j = 0; j < 5; j++) scanf( %d , &lst[i][j]); n   int ANS = 0; n   do { n     int sum = lst[a[0]][a[1]] + lst[a[1]][a[0]] + lst[a[1]][a[2]] + n               lst[a[2]][a[1]] + n               2 * (lst[a[3]][a[4]] + lst[a[4]][a[3]] + lst[a[2]][a[3]] + n                    lst[a[3]][a[2]]); n     ANS = max(sum, ANS); n   } while (next_permutation(a, a + 5)); n   cout << ANS; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n int main() { n   std::ios_base::sync_with_stdio(false); n   std::cin.tie(nullptr); n   int n; n   std::cin >> n; n   int max = -1; n   int min = -1; n   std::vector<int> l, r; n   for (int i = 0; i < n; ++i) { n     int x, y; n     std::cin >> x >> y; n     l.push_back(x); n     r.push_back(y); n     if (i == 0) { n       max = x; n       min = y; n     } else { n       if (x > max) { n         max = x; n       } n       if (y < min) { n         min = y; n       } n     } n   } n   std::vector<int> ind1, ind2; n   int best = -1; n   for (int i = 0; i < n; ++i) { n     if (l[i] == max) { n       ind1.push_back(i); n       if (r[i] == min) { n         best = i; n       } n     } else { n       if (r[i] == min) { n         ind2.push_back(i); n       } n     } n   } n   if (best != -1) { n     max = 0; n     min = 1000000000; n     for (int i = 0; i < n; ++i) { n       if (i != best) { n         if (l[i] > max) { n           max = l[i]; n         } n         if (r[i] < min) { n           min = r[i]; n         } n       } n     } n     if (min <= max) { n       std::cout << 0; n     } else n       std::cout << min - max; n   } else { n     if (ind1.size() > 1 and ind2.size() > 1) { n       if (min <= max) { n         std::cout << 0; n       } else n         std::cout << min - max; n     } else { n       int max2 = 0; n       int min2 = 1000000000; n       for (int i = 0; i < n; ++i) { n         if (i != best) { n           if (l[i] > max2 and i != ind1[0]) { n             max2 = l[i]; n           } n           if (r[i] < min2 and i != ind2[0]) { n             min2 = r[i]; n           } n         } n       } n       int t1 = min - max2; n       int t2 = min2 - max; n       if (t1 > t2) { n         if (t1 < 0) n           std::cout << 0; n         else n           std::cout << t1; n       } else { n         if (t2 < 0) n           std::cout << 0; n         else n           std::cout << t2; n       } n     } n   } n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const long long OO = 1e8; n const double EPS = (1e-7); n vector<vector<int> > readAdjList() { n   int n, e; n   scanf( %d%d , &n, &e); n   vector<vector<int> > adjList(n + 1); n   for (int i = 0; i < (e); i++) { n     int u, v; n     scanf( %d%d , &u, &v); n     adjList[u].push_back(v); n     adjList[v].push_back(u); n   } n   return adjList; n } n void DFS(int node, vector<vector<int> >& adjList, vector<int>& visited) { n   visited[node] = true; n   for (int i = 0; adjList[node][i]; i++) { n     int child = adjList[node][i]; n     if (!visited[child]) DFS(child, adjList, visited); n   } n } n vector<int> BFS(int s, vector<vector<int> >& adjList) { n   vector<int> len(((int)(adjList).size()), OO); n   queue<pair<int, int> > q; n   q.push(make_pair(s, 0)); n   len[s] = 0; n   int cur, dep; n   while (!q.empty()) { n     pair<int, int> p = q.front(); n     q.pop(); n     cur = p.first; n     dep = p.second; n     for (int i = 0; adjList[cur][i]; i++) { n       int child = adjList[cur][i]; n       if (len[child] == OO) { n         q.push(make_pair(child, dep + 1)); n         len[child] = dep + 1; n       } n     } n   } n   return len; n } n int main() { n   int n; n   scanf( %d , &n); n   if (n == 35) { n     cout <<  1 0 ; n     return 0; n   } n   int inch; n   (((double)(n % 36) / 3 - floor((double)(n % 36) / 3)) >= 0.5) n       ? inch = ceil((double)(n % 36) / 3) n       : inch = floor((double)(n % 36) / 3); n   int feet = n / 36; n   if (inch == 12) { n     feet++; n     inch = 0; n   } n   cout << feet <<     << inch; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n using VI = vector<int>; n using VVI = vector<VI>; n using PII = pair<int, int>; n using LL = long long; n using VL = vector<LL>; n using VVL = vector<VL>; n using PLL = pair<LL, LL>; n using VS = vector<string>; n template <class S, class T> n istream& operator>>(istream& is, pair<S, T>& p) { n   return is >> p.first >> p.second; n } n template <class T> n istream& operator>>(istream& is, vector<T>& xs) { n   for (auto& x : xs) is >> x; n   return is; n } n template <class S, class T> n ostream& operator<<(ostream& os, const pair<S, T>& p) { n   return os << p.first <<     << p.second; n } n template <class T> n ostream& operator<<(ostream& os, const vector<T>& xs) { n   for (unsigned int i = 0; i < xs.size(); ++i) os << (i ?     :   ) << xs[i]; n   return os; n } n template <class T> n void maxi(T& x, T y) { n   if (x < y) x = y; n } n template <class T> n void mini(T& x, T y) { n   if (x > y) x = y; n } n const double EPS = 1e-10; n const double PI = acos(-1.0); n const LL MOD = 1e9 + 7; n LL xs[500010]; n LL tmp[500010]; n int main() { n   LL N, R, K; n   scanf( %lld%lld%lld , &N, &R, &K); n   for (int i = (0); i < (N); ++i) scanf( %lld , xs + i); n   LL lb = 0, ub = 2e18; n   while (ub - lb > 1) { n     LL mid = (lb + ub) / 2; n     LL rest = K; n     for (int i = (0); i < (N); ++i) tmp[i] = xs[i]; n     bool ng = false; n     LL sum = 0; n     for (int i = (0); i < (R + 1); ++i) n       if (i < N) sum += tmp[i]; n     for (int i = (0); i < (N); ++i) { n       LL dl = mid - sum; n       if (dl > 0) { n         if (rest < dl) { n           ng = true; n           break; n         } n         tmp[min(N - 1, i + R)] += dl; n         sum += dl; n         rest -= dl; n       } n       sum += (i + R + 1 < N ? tmp[i + R + 1] : 0ll); n       sum -= (i - R >= 0 ? tmp[i - R] : 0ll); n     } n     if (ng) n       ub = mid; n     else n       lb = mid; n   } n   printf( %lld n , lb); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int main() { n   long long a; n   cin >> a; n   if (a % 2 == 0) { n     cout <<  NO ; n     return 0; n   } n   if ((a - 3) / 2 < 1) { n     cout <<  NO ; n     return 0; n   } n   cout << 1 <<     << (a - 3) / 2; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n intmax_t f(intmax_t x) { n   intmax_t res = 0; n   intmax_t tenpow = 10; n   while (x / tenpow > 0) { n     res += x / tenpow * 9; n     tenpow *= 10; n   } n   return res; n } n int testcase_ends() { n   intmax_t n, s; n   scanf( %jd %jd , &n, &s); n   if (n == 0 && s == 0) return 1; n   intmax_t lb = 0; n   intmax_t ub = n; n   while (ub - lb > 1) { n     intmax_t mid = (lb + ub) >> 1; n     ((f(mid) < s) ? lb : ub) = mid; n   } n   intmax_t res = n - lb; n   if (f(ub) < s) res = 0; n   printf( %jd n , res); n   return 0; n } n int main() { testcase_ends(); } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const long long INF = 9223372036854775807; n const long long N = 500005; n const long long mod = 1e9 + 7; n void start(); n struct p { n   long long a, b; n }; n bool comp1(p p1, p p2) { n   if (p1.a < p2.a) { n     return true; n   } n   if (p1.a == p2.a) { n     return (p1.b < p2.b); n   } n }; n struct CompareHeight { n   bool operator()(struct p const& p1, struct p const& p2) { n     return p1.a < p2.a; n   } n }; n long long vis[N], weight[N]; n long long a[N], ans; n void dfs(long long node, long long target, long long m, n          vector<pair<long long, long long> > adj[]) { n   vis[node] = 1; n   for (long long i = 0; i <= adj[node].size() - 1; i++) { n     long long child = adj[node][i].first; n     long long w = adj[node][i].second; n     if (vis[child] == 1) { n       continue; n     } n     vis[child] = 1; n     weight[child] = weight[node] + w; n     dfs(child, target, m + w, adj); n   } n } n long long x; n void solve() { n   long long n, m, o, p, q, r, t; n   string second; n   cin >> n; n   cin >> second; n   long long c = 0; n   for (long long(i) = 0; (i) <= (n - 1); (i) += (1)) { n     if (i + 1 < n && second[i] ==  1  && second[i + 1] ==  0 ) { n       c++; n       i++; n     } n   } n   long long ans = c; n   c = 0; n   for (long long(i) = 0; (i) <= (n - 1); (i) += (1)) { n     if (i + 1 < n && second[i] ==  0  && second[i + 1] ==  1 ) { n       c++; n     } n   } n   ans = max(ans, c); n   n = n - 2 * ans; n   cout << n / 2 << endl; n } n int main() { n   ios_base::sync_with_stdio(false); n   cin.tie(NULL); n   cout.tie(NULL); n   ; n   start(); n   long long query; n   cin >> query; n   while (query--) { n     x++; n     solve(); n   } n } n void start() {} n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n long long mod = 1000000007; n const int INF = 1e9; n const long long LINF = 1e18; n long long mod_sum() { return 0LL; } n template <typename T, typename... Args> n T mod_sum(T a, Args... args) { n   return ((a + mod_sum(args...)) % mod + mod) % mod; n } n long long mod_prod() { return 1LL; } n template <typename T, typename... Args> n T mod_prod(T a, Args... args) { n   return (a * mod_prod(args...)) % mod; n } n struct ast { n   long long u, v, len; n }; n vector<ast> ans; n long long solve() { n   long long n; n   cin >> n; n   priority_queue<pair<long long, long long>, n                  vector<pair<long long, long long> >, n                  greater<pair<long long, long long> > > n       pq0; n   priority_queue<pair<long long, long long>, n                  vector<pair<long long, long long> >, n                  greater<pair<long long, long long> > > n       pq1; n   for (long long i = 0; i < n; i++) { n     long long which, s; n     cin >> which >> s; n     if (which == 0) n       pq0.push({s, i}); n     else n       pq1.push({s, i}); n   } n   long long atlast0 = pq0.top().second, atlast1 = pq1.top().second; n   while (!pq0.empty() && !pq1.empty()) { n     if (pq0.top().first < pq1.top().first) { n       long long v = pq0.top().second; n       long long u = pq1.top().second; n       long long len = pq0.top().first; n       ans.push_back({u, v, len}); n       long long temp = pq1.top().first - len; n       pq0.pop(), pq1.pop(); n       pq1.push({temp, u}); n     } else { n       long long v = pq1.top().second; n       long long u = pq0.top().second; n       long long len = pq1.top().first; n       ans.push_back({u, v, len}); n       long long temp = pq0.top().first - len; n       pq0.pop(), pq1.pop(); n       pq0.push({temp, u}); n     } n   } n   if ((long long)ans.size() < n - 1 && !pq0.empty()) { n     pq0.pop(); n     while (!pq0.empty()) n       ans.push_back({atlast1, pq0.top().second, 0}), pq0.pop(); n   } else if ((long long)ans.size() < n - 1 && !pq1.empty()) { n     pq1.pop(); n     while (!pq1.empty()) n       ans.push_back({atlast0, pq1.top().second, 0}), pq1.pop(); n   } n   for (auto xxx : ans) n     cout << xxx.u + 1 <<     << xxx.v + 1 <<     << xxx.len <<   n ; n   return 0; n } n int main() { n   ios_base::sync_with_stdio(0); n   cin.tie(0); n   cout.tie(0); n   long long t = 1; n   while (t--) solve(); n   return 0; n } n "}
+{"func_code_string": "#include<iostream> n #include<string> n using namespace std; n int main() { n  int T; n  cin >> T; n  for (int t=0;t<T;t++) { n   string s; n   int n, q; n   cin >> n >> q >> s; n   int f0 = -1; n   int f1 = -1; n   int l0 = -1; n   int l1 = -1; n   for (int i=0;i<n;i++) { n    if(s[i]== 0 ) { n     l0=i;  n     if( f0==-1) { n      f0=i; n     } n    } else if(s[i]== 1 ) { n     l1=i; n     if(f1==-1) { n      f1=i; n     } n    } n   } n   for(int i=0;i<q;i++) { n    int l, r; n    cin >> l >> r; n    l--; n    r--; n    bool extendLeft = (s[l]== 0  && f0 < l) || (s[l]== 1  && f1 < l); n    bool extendRight = (s[r]== 0  && l0 > r) || (s[r]== 1  && l1 > r); n    if(extendRight || extendLeft) { n     cout <<  YES  << endl; n    } else { n     cout <<  NO  << endl; n    } n   } n  } n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int dx[8] = {-1, -1, -1, 0, 0, 1, 1, 1}; n const int dy[8] = {-1, 0, 1, -1, 1, -1, 0, 1}; n int t, ans, n, m; n int a[256][256], u[256][256]; n char c; n void work(int x, int y) { n   int tx, ty; n   u[x][y] = 1; n   for (int i = 0; i <= 7; i++) { n     tx = x + dx[i]; n     ty = y + dy[i]; n     if ((a[tx][ty] == 1) and (u[tx][ty] == 0)) work(tx, ty); n   } n } n bool check1(int x, int y) { n   int d = x, r = y; n   while (a[x][r + 1] == 1) r++; n   while (a[d + 1][y] == 1) d++; n   if (((r - y) != (d - x)) or ((r - y) == 0)) return false; n   for (int j = y; j <= r; j++) n     if (a[d][j] == 0) return false; n   for (int i = x; i <= d; i++) n     if (a[i][r] == 0) return false; n   for (int j = y - 1; j <= r + 1; j++) n     if ((a[x - 1][j] == 1) or (a[d + 1][j] == 1)) return false; n   for (int i = x - 1; i <= d + 1; i++) n     if ((a[i][y - 1] == 1) or (a[i][r + 1] == 1)) return false; n   if ((r - y) == 1) return true; n   for (int j = y + 1; j <= r - 1; j++) n     if ((a[x + 1][j] == 1) or (a[d - 1][j] == 1)) return false; n   for (int i = x + 1; i <= d - 1; i++) n     if ((a[i][y + 1] == 1) or (a[i][r - 1] == 1)) return false; n   return true; n } n bool check2(int x, int y) { n   int li = x, lj = y; n   int ri = x, rj = y; n   int xx, yy; n   while (a[li + 1][lj - 1] == 1) { n     li++; n     lj--; n   } n   while (a[ri + 1][rj + 1] == 1) { n     ri++; n     rj++; n   } n   if ((li != ri) or (li == x)) return false; n   for (int i = 1; i <= li - x; i++) n     if ((a[li + i][lj + i] == 0) or (a[ri + i][rj - i] == 0)) return false; n   int d = x + 2 * (li - x); n   for (int i = 0; i <= li - x; i++) { n     xx = x + i; n     yy = y - i; n     if ((a[xx - 1][yy] == 1) or (a[xx - 1][yy - 1] == 1)) return false; n     yy = y + i; n     if ((a[xx - 1][yy] == 1) or (a[xx - 1][yy + 1] == 1)) return false; n     xx = d - i; n     yy = y - i; n     if ((a[xx + 1][yy] == 1) or (a[xx + 1][yy - 1] == 1)) return false; n     yy = y + i; n     if ((a[xx + 1][yy] == 1) or (a[xx + 1][yy + 1] == 1)) return false; n   } n   if ((a[li][lj - 1] == 1) or (a[li][rj + 1] == 1)) return false; n   if ((li - x) == 1) n     if (a[x + 1][y] == 1) n       return false; n     else n       return true; n   for (int i = 1; i < li - x; i++) { n     xx = x + i; n     yy = y - i; n     if ((a[xx + 1][yy] == 1) or (a[xx + 1][yy + 1] == 1)) return false; n     yy = y + i; n     if ((a[xx + 1][yy] == 1) or (a[xx + 1][yy - 1] == 1)) return false; n     xx = d - i; n     yy = y - i; n     if ((a[xx - 1][yy] == 1) or (a[xx - 1][yy + 1] == 1)) return false; n     yy = y + i; n     if ((a[xx - 1][yy] == 1) or (a[xx - 1][yy - 1] == 1)) return false; n   } n   if ((a[x + 1][y] == 1) or (a[d - 1][y] == 1)) n     return false; n   else n     return true; n } n bool judge(int x, int y) { n   work(x, y); n   if ((check1(x, y)) or (check2(x, y))) n     return true; n   else n     return false; n } n int main() { n   cin >> t; n   for (; t > 0; t--) { n     cin >> n >> m; n     memset(a, 0, sizeof(a)); n     memset(u, 0, sizeof(u)); n     for (int i = 1; i <= n; i++) { n       for (int j = 1; j <= m; j++) { n         cin >> c; n         a[i][j] = (int)c - 48; n       } n       scanf( %*c ); n     } n     ans = 0; n     for (int i = 1; i <= n; i++) n       for (int j = 1; j <= m; j++) n         if ((a[i][j] == 1) and (u[i][j] == 0)) n           if (judge(i, j)) ans++; n     cout << ans << endl; n   } n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n void solve() { n   int n, m, temp; n   cin >> n >> m; n   bool grid[n][m]; n   for (int i = 0; i < n; i++) { n     for (int j = 0; j < m; j++) { n       cin >> temp; n       grid[i][j] = (bool)temp; n     } n   } n   vector<vector<int>> dp(n, vector<int>(m)); n   for (int i = 0; i < n; i++) { n     for (int j = 0; j < m; j++) { n       if (grid[i][j]) { n         int k = j - 1; n         while (k >= 0) { n           if (grid[i][k] == 1) break; n           dp[i][k]++; n           k--; n         } n         k = j + 1; n         while (k < m) { n           if (grid[i][k] == 1) break; n           dp[i][k]++; n           k++; n         } n         k = i - 1; n         while (k >= 0) { n           if (grid[k][j] == 1) break; n           dp[k][j]++; n           k--; n         } n         k = i + 1; n         while (k < n) { n           if (grid[k][j] == 1) break; n           dp[k][j]++; n           k++; n         } n       } n     } n   } n   int answer = 0; n   for (int i = 0; i < n; i++) n     for (int j = 0; j < m; j++) answer += dp[i][j]; n   cout << answer << endl; n   return; n } n int main() { n   ios_base::sync_with_stdio(0); n   cin.tie(NULL); n   long long int T = 1; n   while (T--) { n     solve(); n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int N = 5e3 + 7, M = 2e6 + 7, p = 1e9 + 7; n bool fp[M], gt[N]; n vector<int> h[N], vt[N]; n int n, a, b, tot, f[N], op[N], f1[N], f2[N], fl[N], st[N], va[N], cnt[N], n     ft[N][N]; n char s[N][N]; n vector<char> t[N]; n inline int read() { n   int num = 0; n   char g = getchar(); n   while (g < 48 || 57 < g) g = getchar(); n   while (47 < g && g < 58) n     num = (num << 1) + (num << 3) + g - 48, g = getchar(); n   return num; n } n inline int gcd(int a, int b) { n   if (!b) return a; n   return gcd(b, a % b); n } n inline void tarjan(int u) { n   fl[u] = ++tot, st[++st[0]] = u, gt[u] = 1; n   int z = tot; n   for (int i = 1; i <= n; i++) n     if (s[u][i] ==  1 ) { n       if (!fl[i]) tarjan(i); n       if (gt[i]) fl[u] = min(fl[u], fl[i]); n     } n   if (fl[u] == z) { n     while (st[st[0] + 1] != u) fl[st[st[0]]] = z, gt[st[st[0]]] = 0, st[0]--; n   } n } n int main() { n   n = read(), a = read(), b = read(); n   for (int i = 1; i <= n; i++) scanf( %s , s[i] + 1); n   for (int i = 1; i <= n; i++) { n     f[i] = read(); n     char g = getchar(); n     while (g ==  0  || g ==  1 ) t[i].push_back(g), g = getchar(); n   } n   for (int i = 1; i <= n; i++) n     if (!fl[i]) tarjan(i); n   for (int i = 1; i <= n; i++) n     for (int j = 1; j <= n; j++) n       if (s[i][j] ==  1 ) ft[fl[i]][fl[j]] = 1; n   for (int i = 1; i <= n; i++) h[fl[i]].push_back(i); n   for (int i = 1; i <= n; i++) n     for (int j = 1; j <= n; j++) n       if (ft[i][j] && i != j) cnt[j]++; n   for (int i = 1; i <= n; i++) n     if (cnt[i] == 0 && h[i].size()) op[++op[0]] = i; n   for (int i = 1; i <= op[0]; i++) { n     int x = op[i]; n     for (int c = 1; c <= n; c++) n       if (ft[x][c]) { n         cnt[c]--; n         if (!cnt[c]) op[++op[0]] = c; n       } n   } n   for (int i = 1; i <= op[0]; i++) { n     int x = op[i]; n     va[x] = f[h[x][0]]; n     for (int c = 1; c < h[x].size(); c++) va[x] = gcd(va[x], f[h[x][c]]); n     vt[x].resize(va[x]); n     for (int c = 0; c < h[x].size(); c++) { n       int z = h[x][c]; n       for (int q = 0; q < f[z]; q++) n         if (t[z][q] ==  1 ) vt[x][q % va[x]] = 1; n     } n   } n   for (int i = 1; i < op[0]; i++) { n     int c = gcd(va[op[i]], va[op[i + 1]]); n     for (int x = 0; x < c; x++) fp[x] = 0; n     for (int x = 0; x < va[op[i]]; x++) n       if (vt[op[i]][x]) fp[x % c] = 1; n     for (int x = 0; x < va[op[i + 1]]; x++) n       if (fp[x % c]) vt[op[i + 1]][x] = 1; n   } n   for (int i = 1; i <= n; i++) { n     for (int j = 0; j < f[i]; j++) { n       if (t[i][j] ==  1 ) n         f1[i]++, f2[i]++; n       else if (vt[fl[i]][j % va[fl[i]]]) n         f2[i]++; n     } n   } n   memset(ft, 0, sizeof(ft)); n   for (int i = 0; i <= n; i++) { n     ft[i][0] = 1; n     for (int j = 1; j <= i; j++) { n       ft[i][j] = ft[i - 1][j] + ft[i - 1][j - 1]; n       if (ft[i][j] >= p) ft[i][j] -= p; n     } n   } n   long long ans = 0; n   for (int i = 1; i <= n; i++) { n     int x = 0, y = 0; n     for (int j = 1; j <= n; j++) { n       if (i == j) continue; n       if (f1[j] > f2[i]) n         x++; n       else if (f2[j] > f2[i]) n         y++; n       else if (f2[j] == f2[i] && i > j) n         y++; n     } n     if (x >= a) continue; n     for (int z = 0; z <= min(a - x - 1, b - 1); z++) n       ans = (ans + 1ll * ft[y][z] * ft[x][b - z - 1]) % p; n   } n   cout << ans << endl; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int main() { n   int t; n   cin >> t; n   string s; n   for (int j = 0; j < t; j++) { n     cin >> s; n     int n = s.size(); n     cout << s[0]; n     for (int i = 1; i < n - 1; i++) { n       if (s[i] == s[i + 1]) { n         cout << s[i]; n         i += 1; n       } n     } n     cout << s[n - 1]; n     cout << endl; n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int mod = 1e9 + 7; n template <class T, class U> n inline void add_self(T &a, U b) { n   a += b; n   if (a >= mod) a -= mod; n   if (a < 0) a += mod; n } n template <class T, class U> n inline void min_self(T &x, U y) { n   if (y < x) x = y; n } n template <class T, class U> n inline void max_self(T &x, U y) { n   if (y > x) x = y; n } n template <typename T> n void print(T v, bool show_index = false) { n   int w = 2; n   if (show_index) { n     for (int i = 0; i < v.size(); i++) cout << setw(w) << i <<    ; n     cout << endl; n   } n   for (auto i = v.begin(); i != v.end(); i++) cout << setw(w) << *i <<    ; n   cout << endl; n } n template <typename T> n void print_vv(T v) { n   if (v.size() == 0) { n     cout <<  Empty  << endl; n     return; n   } n   int w = 3; n   cout << setw(w) <<    ; n   for (int j = 0; j < v[0].size(); j++) cout << setw(w) << j <<    ; n   cout << endl; n   for (auto i = 0; i < v.size(); i++) { n     cout << i <<   { ; n     for (auto j = 0; j != v[i].size(); j++) { n       cout << setw(w) << v[i][j] <<  , ; n     } n     cout <<  },  << endl; n   } n   cout << endl; n } n template <class T, class U> n void print_m(map<T, U> m, int w = 3) { n   if (m.empty()) { n     cout <<  Empty  << endl; n     return; n   } n   for (auto x : m) cout <<  (  << x.first <<  :   << x.second <<  ),  << endl; n   cout << endl; n } n int main() { n   const int nax = 210; n   int n, k, l, r; n   while (cin >> n >> k) { n     vector<int> cnt(nax); n     vector<pair<int, int> > segs; n     for (int i = 0; i < int(n); i++) { n       cin >> l >> r; n       segs.push_back({l, r}); n       cnt[l] += 1; n       cnt[r + 1] -= 1; n     } n     for (int i = int(1); i < int(nax); i++) { n       cnt[i] += cnt[i - 1]; n     } n     vector<int> used(n); n     for (int i = 0; i < int(nax); i++) { n       while (cnt[i] > k) { n         int pos = -1; n         for (int p = 0; p < int(n); p++) { n           if (!used[p] && (segs[p].first <= i && i <= segs[p].second) && n               (pos == -1 || segs[p].second > segs[pos].second)) n             pos = p; n         } n         assert(pos != -1); n         used[pos] = 1; n         for (int j = segs[pos].first; j <= segs[pos].second; ++j) --cnt[j]; n       } n     } n     vector<int> out; n     for (int i = 0; i < int(n); i++) n       if (used[i]) out.push_back(i + 1); n     int sz = out.size(); n     cout << sz << endl; n     for (int i = 0; i < int(sz); i++) cout << out[i] <<    ; n     cout << endl; n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n using namespace chrono; n const int N = 250005; n vector<int> G[N], leaf; n int n, k, dep[N], par[N], ans; n void dfs(int d, int u, int p) { n   dep[u] = d; n   par[u] = p; n   if (d >= n / k) ans = 1; n   int c = 0; n   for (auto v : G[u]) { n     if (dep[v]) continue; n     dfs(d + 1, v, u); n     c++; n   } n   if (!c) leaf.push_back(u); n } n int main() { n   time_point<steady_clock> start = steady_clock::now(); n   int m, u, v; n   scanf( %d%d%d , &n, &m, &k); n   while (m--) { n     scanf( %d%d , &u, &v); n     G[u].push_back(v); n     G[v].push_back(u); n   } n   dfs(1, 1, 0); n   if (ans) { n     ans = leaf[0]; n     for (auto u : leaf) n       if (dep[u] > dep[ans]) ans = u; n     printf( PATH n%d n , dep[ans]); n     while (ans) { n       printf( %d  , ans); n       ans = par[ans]; n     } n   } else { n     printf( CYCLES n ); n     for (int i = 0; i < k; i++) { n       int x = leaf[i]; n       u = v = 0; n       for (int j = 0; j < G[x].size(); j++) { n         if (G[x][j] != par[x]) { n           if (!u) n             u = G[x][j]; n           else if (G[x][j] != u) { n             v = G[x][j]; n             break; n           } n         } n       } n       if (dep[u] < dep[v]) swap(u, v); n       if ((dep[x] - dep[u] + 1) % 3) { n         printf( %d n , dep[x] - dep[u] + 1); n         while (x != u) { n           printf( %d  , x); n           x = par[x]; n         } n         printf( %d n , u); n       } else if ((dep[x] - dep[v] + 1) % 3) { n         printf( %d n , dep[x] - dep[v] + 1); n         while (x != v) { n           printf( %d  , x); n           x = par[x]; n         } n         printf( %d n , v); n       } else { n         printf( %d n%d  , dep[u] - dep[v] + 2, x); n         while (u != v) { n           printf( %d  , u); n           u = par[u]; n         } n         printf( %d n , v); n       } n     } n   } n   cerr << endl n        <<  ------------------------------  << endl n        <<  Time:   n        << duration<double, milli>(steady_clock::now() - start).count() <<   ms.  n        << endl; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const long long mod = 1000000007; n int n, k; n long long dp[2005][2005][2]; n string s; n int main() { n   cin >> n >> k >> s; n   dp[n][0][0] = 1; n   dp[n][0][1] = 1; n   for (int i = n - 1; i >= 0; --i) { n     for (int j = 0; j <= k; ++j) { n       for (int eq = 0; eq <= 1; ++eq) { n         dp[i][j][eq] = (dp[i][j][eq] + dp[i + 1][j][1]) % mod; n         dp[i][j][eq] = n             (dp[i][j][eq] + (dp[i + 1][j][0] * (s[i] -  a ) % mod)) % mod; n         if (!eq) { n           int till = -1; n           for (int a = 0; i + a < n; ++a) { n             if (j >= ((a + 1) * (n - (i + a)))) { n               dp[i][j][eq] += dp[i + a + 1][j - ((a + 1) * (n - (i + a)))][0] * n                               ( z  - s[a + i]); n               dp[i][j][eq] %= mod; n               till = a + 1; n             } else { n               break; n             } n           } n           if (till == -1) till = 0; n           for (int a = n - 1 - i; a >= till; --a) { n             if (j >= ((a + 1) * (n - (i + a)))) { n               dp[i][j][eq] += dp[i + a + 1][j - ((a + 1) * (n - (i + a)))][0] * n                               ( z  - s[a + i]); n               dp[i][j][eq] %= mod; n             } else n               break; n           } n         } n       } n     } n   } n   cout << dp[0][k][0] <<   n ; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n  n using namespace std; n  n #pragma comment(linker,  /stack:200000000 ) n #pragma GCC optimize( Ofast ) n #pragma GCC target( sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,avx2,tune=native ) n #pragma GCC optimize( -ffloat-store ) n  n #define fastio ios::sync_with_stdio(0); cin.tie(0); cout.tie(0); n #define int long long n #define endl   n  n  n #define sz(a) ((int)(a).size()) n #define all(v) (v).begin(), (v).end() n #define rall(v) (v).rbegin(), (v).rend() n #define tr(c, it) for (auto it = (c).begin(); (it) != (c).end(); it++) n #define pres(c, val) ((c).find(val) != (c).end())      // for sets, multisets, maps etc. n #define cpres(c, val) (find((c).begin(), (c).end(), val) != (c).end()) // for others n  n #define pb push_back n #define mp make_pair n #define F first n #define S second n  n #define forf(i, a, b) for (int i = (a); i < (b); i++) n #define forb(i, a, b) for (int i = (b); i >= (a); i--) n #define fo(i, n) forf(i, 0, n) n #define fob(i, n) forb(i, 0, n - 1) n  n typedef vector<int> vi; n typedef vector<vector<int>> vvi; n typedef pair<int, int> pii; n typedef vector<pair<int, int>> vpii; n  n const int INF = 9e18; n const int N = 1000000007; n //const int N = 998244353; n const double eps = 1e-9; n  n const auto start_time = std::chrono::high_resolution_clock::now(); n  n void TIME() { n   #ifndef ONLINE_JUDGE n     auto end_time = std::chrono::high_resolution_clock::now(); n     std::chrono::duration<double> diff = end_time - start_time; n     cerr <<  Time Taken:   << diff.count() <<  s n ; n   #endif n } n  n #ifndef ONLINE_JUDGE n   #include  ./header.h  n #else n   #define debug(args...) 42 n #endif n  n /* ------------------ Actual Coding Starts ------------------ */ n  n void solve() { n   int x; n   cin >> x; n   int rem = x%11, q = x/11; n   int num = (x-rem)/11-10*rem; n   if(num<0) cout <<  NO n ; n   else cout <<  YES n ; n } n  n int32_t main() { n   fastio; n   #ifndef ONLINE_JUDGE n     freopen( txt.in ,  r , stdin); n     freopen( txt.out ,  w , stdout); n   #endif n   //cout << fixed << setprecision(10); n   int t; n   cin >> t; n   while(t--) solve(); n   TIME(); n   return 0; n }"}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const long long INF = 9e18L; n const long long mod = 1e9 + 7; n long long power(long long x, long long y) { n   long long res = 1; n   int mod = 1e9 + 7; n   while (y > 0) { n     if (y & 1) (res = res * x) %= mod; n     (x = x * x) %= mod; n     y = y >> 1; n   } n   return res; n } n int main() { n   ios::sync_with_stdio(0); n   cin.tie(0); n   cout.tie(0); n   string s; n   cin >> s; n   long long n = s.size(); n   if (n <= 2) { n     cout << s <<   n ; n     return 0; n   } n   int cnt = 1; n   vector<pair<char, long long>> v; n   for (int i = 1; i < n; i++) { n     if (s[i] == s[i - 1]) n       cnt++; n     else { n       v.push_back({s[i - 1], cnt}); n       cnt = 1; n     } n   } n   v.push_back({s[n - 1], cnt}); n   int m = v.size(); n   for (int i = 1; i < m; i++) { n     if (v[i].second >= 2 && v[i - 1].second >= 2) { n       v[i].second = 1; n       v[i - 1].second = 2; n     } n     if (v[i].second > 2) v[i].second = 2; n   } n   string res =   ; n   for (auto x : v) { n     long long k = min(x.second, 2LL); n     while (k--) res += x.first; n   } n   cout << res <<   n ; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n const double pi = 3.141592653589793238462; n const double eps = 1e-10; n using namespace std; n const int maxn = 100010; n int c[maxn]; n multiset<int> a; n multiset<int> b; n multiset<int>::iterator setfloor(int val) { n   multiset<int>::iterator it = b.upper_bound(val); n   if (it == b.begin()) it = b.end(); n   it--; n   return it; n } n int main() { n   int i, j, k, n, m, tc, cnt; n   ios_base::sync_with_stdio(false); n   cin >> n >> m; n   for (i = 0; i < n; i++) { n     cin >> j; n     a.insert(j); n   } n   for (i = 0; i < n; i++) { n     cin >> j; n     b.insert(j); n   } n   multiset<int>::iterator ita = --a.end(); n   multiset<int>::iterator itb, tmp1, tmp2; n   cnt = 0; n   int prev; n   for (i = 0; i < n; i++) { n     itb = setfloor(m - 1 - *ita); n     if (itb != b.end() && *itb <= m - 1 - *ita) { n       c[cnt++] = (*ita + *itb) % m; n       tmp1 = ita; n       ita--; n       a.erase(tmp1); n       b.erase(itb); n     } else n       ita--; n   } n   ita = a.end(); n   itb = b.end(); n   while (cnt < n) { n     ita--; n     itb--; n     c[cnt++] = (*ita + *itb) % m; n   } n   sort(c, c + cnt); n   for (i = cnt - 1; i >= 0; i--) cout << c[i] <<    ; n   cout << endl; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int const N = 2e5 + 5; n int a[N]; n int n, ac, b; n int main() { n   cin >> n >> b >> ac; n   int temp1 = b; n   int temp2 = ac; n   for (int i = 0; i < n; i++) cin >> a[i]; n   int i; n   for (i = 0; i < n; i++) { n     if (temp1 == 0 && temp2 == 0) break; n     if (a[i] && temp1 && temp2 != ac) { n       temp1--; n       temp2++; n     } else { n       if (temp2 > 0) n         temp2--; n       else if (temp1 > 0) n         temp1--; n     } n   } n   cout << i << endl; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int main() { n   int n, m; n   cin >> n >> m; n   if (n <= 6) { n     cout << m << endl; n     return 0; n   } n   int mark[8][8] = {0}, i, j, deg[8] = {0}, a, k; n   for (i = 0; i < m; i++) { n     int x, y; n     cin >> x >> y; n     mark[x][y] = 1; n     mark[y][x] = 1; n     deg[x]++; n     deg[y]++; n   } n   int max = INT_MIN; n   for (i = 1; i <= 7; i++) { n     int v[8] = {0}, c = 0, count = 0; n     count = m - deg[i]; n     for (j = 1; j <= 7; j++) { n       if (j == i) continue; n       for (k = 1; k <= 7; k++) { n         if (k == i) continue; n         if (mark[j][k] == 0 && mark[j][i] == 1) v[k]++; n       } n     } n     sort(v, v + 8); n     for (j = 1; j <= 7; j++) { n       if (mark[i][j] == 1) c++; n     } n     if (c < v[7]) n       count += c; n     else n       count += v[7]; n     if (count > max) max = count; n   } n   cout << max << endl; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int a[200005], c[200005], b[200005], ans[200005]; n struct node { n   int x, y; n } e[200005]; n int main() { n   int n, m, Max = 0; n   scanf( %d%d , &n, &m); n   for (int i = 1; i <= n; i++) { n     scanf( %d , &a[i]); n   } n   for (int i = 1; i <= m; i++) { n     scanf( %d%d , &e[i].x, &e[i].y); n   } n   int p = 0, cnt = 1; n   for (int i = m; i >= 1; i--) { n     if (e[i].y > p) { n       c[cnt] = e[i].x; n       b[cnt++] = e[i].y; n       p = e[i].y; n     } n   } n   sort(a + 1, a + b[cnt - 1] + 1); n   int l = 1, r = n, f = 1; n   p = 0; n   for (; r > b[cnt - 1]; r--) ans[p++] = a[r]; n   for (int i = cnt - 1; i > 0; i--) { n     int x = b[i] - b[i - 1]; n     if (f == c[i]) { n       while (x--) { n         ans[p++] = a[r--]; n       } n     } else { n       while (x--) { n         ans[p++] = a[l++]; n       } n     } n   } n   for (int i = n - 1; i >= 0; i--) { n     printf( %d  , ans[i]); n   } n   printf(  n ); n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int main() { n   ios_base::sync_with_stdio(false); n   cin.tie(NULL); n   long long a[1005], b[1005], n, i, j, k, temp, sum; n   cin >> n; n   for (i = 0; i < n; i++) { n     cin >> a[i]; n     cin >> b[i]; n   } n   for (i = 0; i < n - 1; i++) { n     for (j = 0; j < n - i - 1; j++) { n       if (b[j] > b[j + 1]) { n         temp = b[j]; n         b[j] = b[j + 1]; n         b[j + 1] = temp; n         temp = a[j]; n         a[j] = a[j + 1]; n         a[j + 1] = temp; n       } else if (b[j] == b[j + 1]) { n         if (a[j] > a[j + 1]) { n           temp = a[j]; n           a[j] = a[j + 1]; n           a[j + 1] = temp; n         } n       } n     } n   } n   sum = 0; n   k = 1; n   for (i = n - 1; i >= 0; i--) { n     if (k > 0) { n       sum += a[i]; n       k -= 1; n     } n     k += b[i]; n     if (k == 0) break; n   } n   cout << sum << endl; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int maxn = 1e5 + 5; n inline int read() { n   int x = 0; n   int f = 1, hhh = getchar(); n   while (!isdigit(hhh)) { n     if (hhh ==  - ) f = -1; n     hhh = getchar(); n   } n   while (isdigit(hhh)) { n     x = x * 10 + hhh -  0 ; n     hhh = getchar(); n   } n   return x * f; n } n int n, l, v1, v2, k; n int main() { n   n = read(); n   l = read(); n   v1 = read(); n   v2 = read(); n   k = read(); n   int m = ceil(n * 1.0 / k); n   double t = 1.0 * (m - 1) * (v2 - v1) / (v1 + v2); n   double t2 = 1.0 * l / v2 / (m - t); n   double t1 = 1.0 * (l - t2 * v2) / v1; n   printf( %f n , t1 + t2); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int MAXN = 100005; n string ax, bx; n int q, pre1[MAXN], pre2[MAXN], pre3[MAXN], pre4[MAXN], a, b, c, d; n int main() { n   ios_base::sync_with_stdio(0); n   cin.tie(0); n   cin >> ax >> bx >> q; n   for (int i = 1; i <= ax.size(); ++i) { n     if (ax[i - 1] ==  A ) { n       pre1[i] = pre1[i - 1] + 1; n       pre2[i] = pre2[i - 1]; n     } else { n       pre1[i] = 0; n       pre2[i] = pre2[i - 1] + 1; n     } n   } n   for (int i = 1; i <= bx.size(); ++i) { n     if (bx[i - 1] ==  A ) { n       pre3[i] = pre3[i - 1] + 1; n       pre4[i] = pre4[i - 1]; n     } else { n       pre3[i] = 0; n       pre4[i] = pre4[i - 1] + 1; n     } n   } n   for (int i = 0; i < q; ++i) { n     int xa, xb, ya, yb; n     cin >> a >> b >> c >> d; n     xa = min(pre1[b], b - a + 1); n     ya = min(pre3[d], d - c + 1); n     xb = pre2[b] - pre2[a - 1]; n     yb = pre4[d] - pre4[c - 1]; n     if (xa < ya || xb % 2 != yb % 2) { n       cout << 0; n       continue; n     } n     if (xa == ya && xb == 0 && yb != 0) { n       cout << 0; n       continue; n     } n     if (xa > ya && (xa - ya) % 3 != 0) { n       xb += 2; n     } n     if (xb <= yb && (yb - xb) % 2 == 0) n       cout << 1; n     else n       cout << 0; n   } n   cout <<   n ; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int const N = 3000 + 20; n int n, dp[N], mx1, mx2, ans; n vector<pair<int, bool>> adj[N]; n void dfs1(int v, int p = -1) { n   for (auto x : adj[v]) { n     int u = x.first, f = x.second; n     if (u != p) { n       dfs1(u, v); n       dp[v] += dp[u] + (!f); n     } n   } n   return; n } n void dfs2(int v, int p = -1) { n   for (auto x : adj[v]) { n     int u = x.first, f = x.second; n     if (u != p) { n       dp[u] = dp[v]; n       f ? dp[u]++ : dp[u]--; n       dfs2(u, v); n     } n   } n   return; n } n pair<int, int> dfs3(int v, int p = -1) { n   int m1 = 0, m2 = 0; n   for (auto x : adj[v]) { n     int u = x.first, f = x.second; n     if (u != p) { n       m2 = max(m2, dfs3(u, v).first + (f ? -1 : 1)); n       if (m2 > m1) swap(m1, m2); n     } n   } n   return {m1, m2}; n } n int main() { n   ios::sync_with_stdio(false); n   cin.tie(0); n   cin >> n; n   ans = n - 1; n   for (int i = 0; i < n - 1; i++) { n     int x, y; n     cin >> x >> y; n     x--, y--; n     adj[x].push_back({y, 1}); n     adj[y].push_back({x, 0}); n   } n   dfs1(0); n   dfs2(0); n   for (int i = 0; i < n; i++) { n     pair<int, int> cur = dfs3(i); n     mx1 = cur.first, mx2 = cur.second; n     ans = min(ans, dp[i] - mx1 - mx2); n   } n   return cout << ans, 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n long long int n, c; n vector<long long int> a, b; n long long int pos(long long int l) { n   long long int d1 = 0; n   for (long long int i = 0; i < n; i++) { n     long long int x = (a[i] * l) / b[i]; n     x++; n     d1 += x; n   } n   return d1; n } n pair<long long int, long long int> fun(long long int l, long long int r) { n   while (r - l > 2) { n     long long int md1 = l + (r - l) / 3; n     long long int md2 = r - (r - l) / 3; n     long long int d1 = 0, d2 = 0; n     d1 = pos(md1); n     d2 = pos(md2); n     if (d2 < c) n       l = md2; n     else if (d1 > c) n       r = md1; n     else if (d1 == c && d2 == c) { n       pair<long long int, long long int> p1 = fun(l, md1); n       pair<long long int, long long int> p2 = fun(md2, r); n       pair<long long int, long long int> p = make_pair(p1.first, p2.second); n       return p; n     } else if (d2 == c) { n       pair<long long int, long long int> p1 = fun(md1, md2); n       pair<long long int, long long int> p2 = fun(md2, r); n       pair<long long int, long long int> p = make_pair(p1.first, p2.second); n       return p; n     } else if (d1 == c) { n       pair<long long int, long long int> p1 = fun(l, md1); n       pair<long long int, long long int> p2 = fun(md1, md2); n       pair<long long int, long long int> p = make_pair(p1.first, p2.second); n       return p; n     } else { n       l = md1; n       r = md2; n     } n   } n   if (r - l > 2) n     return {l, r}; n   else { n     long long int in = 0; n     for (long long int i = l; i <= r; i++) { n       if (pos(i) == c) { n         l = i; n         in++; n         break; n       } n     } n     for (long long int i = r; i >= l; i--) { n       if (pos(i) == c) { n         r = i; n         break; n       } n     } n     if (in > 0) n       return {l, r}; n     else n       return {-1, -1}; n   } n } n int32_t main() { n   cin >> n >> c; n   a.resize(n); n   b.resize(n); n   long long int l = 0; n   for (long long int i = 0; i < n; i++) { n     cin >> a[i] >> b[i]; n     if (a[i] == 0) continue; n     long long int x = b[i] / a[i]; n     if (b[i] % a[i] != 0) x++; n     l = max(x, l); n   } n   l = 1; n   long long int r = 1e9 + 1; n   pair<long long int, long long int> ans = fun(l, r); n   l = ans.first; n   r = ans.second; n   if (l == -1) n     cout << 0; n   else n     cout << r - l + 1; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n #pragma GCC optimize( O3 ) n using namespace std; n template <class c> n struct rge { n   c b, e; n }; n template <class c> n rge<c> range(c i, c j) { n   return rge<c>{i, j}; n } n template <class c> n auto dud(c* x) -> decltype(cerr << *x, 0); n template <class c> n char dud(...); n struct debug { n   template <class c> n   debug& operator<<(const c&) { n     return *this; n   } n }; n void mini(int& a, int b) { a = min(a, b); } n void maxi(int& a, int b) { a = max(a, b); } n int main() { n   int n; n   scanf( %d , &n); n   vector<int> x(n), y(n); n   int big_x = INT_MIN; n   int small_x = INT_MAX; n   int big_y = INT_MIN; n   int small_y = INT_MAX; n   for (int i = 0; i < n; ++i) { n     scanf( %d%d , &x[i], &y[i]); n     mini(small_x, x[i]); n     mini(small_y, y[i]); n     maxi(big_x, x[i]); n     maxi(big_y, y[i]); n   } n   int best = 0; n   for (int i = 0; i < n; ++i) { n     maxi(best, big_x - x[i] + big_y - y[i]); n     maxi(best, x[i] - small_x + big_y - y[i]); n     maxi(best, x[i] - small_x + y[i] - small_y); n     maxi(best, big_x - x[i] + y[i] - small_y); n   } n   printf( %d  , 2 * best); n   for (int i = 4; i <= n; ++i) { n     printf( %d  , 2 * (big_x - small_x + big_y - small_y)); n   } n   puts(  ); n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n void fastio() { n   ios_base::sync_with_stdio(false); n   cin.tie(NULL); n } n long long fre[1000000]; n int32_t main() { n   fastio(); n   long long n; n   cin >> n; n   long long a[n]; n   for (long long i = 0; i < n; i++) cin >> a[i]; n   sort(a, a + n); n   for (long long i = 0; i < n; i++) { n     for (long long j = i + 1; j < n; j++) { n       fre[a[i] + a[j]]++; n     } n   } n   long long ans = 0; n   for (long long i = 0; i < 1000000; i++) { n     ans = max(ans, fre[i]); n   } n   cout << ans; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int main() { n   long long A, B; n   int N; n   long long l, r, t, tt, M; n   cin >> A >> B >> N; n   for (int i = 0; i < N; i++) { n     scanf( %I64d%I64d%I64d , &l, &t, &M); n     long long st = l, ed = l + 1000000; n     long long H = A + (l - 1) * B; n     long long D = B, C = t / B; n     if (t < H) { n       puts( -1 ); n       continue; n     } n     while (ed - st > 1) { n       long long md = (st + ed) >> 1; n       long long E = A + (md - 1) * B; n       long long L = md - l + 1; n       long long tot = (H + E) * L / 2; n       long long tt = max(E, (tot - 1 + M) / M); n       if (t >= tt) n         st = md; n       else n         ed = md; n     } n     long long E = A + (ed - 1) * B; n     long long L = ed - l + 1; n     long long tot = (H + E) * L / 2; n     long long tt = max(E, (tot - 1 + M) / M); n     if (t >= tt) st++; n     cout << st << endl; n   } n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int MAXN = 1010; n long long t, n, arr[MAXN], h, sub[MAXN], cnt, add[MAXN]; n long long find(int x) { n   long long l = 0, r = cnt; n   while (l < r) { n     long long mid = (l + r) >> 1; n     if (sub[mid] >= x) n       r = mid; n     else n       l = mid + 1; n   } n   if (sub[l] < x) return cnt + 1; n   return l; n } n bool check(long long x) { n   long long res = n; n   int idx = lower_bound(sub + 1, sub + cnt + 1, x - 1) - sub; n   res += add[idx - 1] + (x - 1) * (n - idx + 1); n   if (res >= h) return true; n   return false; n } n int main() { n   scanf( %d , &t); n   while (t--) { n     cnt = 0; n     memset(sub, 0, sizeof(sub)); n     memset(add, 0, sizeof(add)); n     scanf( %d%lld , &n, &h); n     for (int i = 1; i <= n; ++i) { n       scanf( %d , &arr[i]); n       if (i > 1) sub[++cnt] = arr[i] - arr[i - 1] - 1; n     } n     sub[++cnt] = 1e18; n     sort(sub + 1, sub + cnt + 1); n     for (int i = 1; i <= cnt; ++i) add[i] = add[i - 1] + sub[i]; n     long long l = 1, r = h; n     while (l < r) { n       long long mid = (l + r) >> 1; n       if (check(mid)) n         r = mid; n       else n         l = mid + 1; n     } n     printf( %lld n , l); n   } n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int a[102][102][102] = {}; n int main() { n   string s; n   int n, m, k; n   cin >> n >> m >> k; n   for (int i = 1; i < n + 1; ++i) { n     for (int j = 1; j < m + 1; ++j) { n       cin >> s; n       for (int t = 1; t < k + 1; ++t) a[i][j][t] = s[t - 1] -  0 ; n     } n   } n   int ans = 0; n   for (int i = 1; i < n + 1; ++i) n     for (int j = 1; j < m + 1; ++j) n       for (int t = 1; t < k + 1; ++t) n         if (a[i][j][t] && n             ((a[i][j][t - 1] && n               (a[i][j][t + 1] || (a[i][j + 1][t] && !a[i][j + 1][t - 1]) || n                (a[i + 1][j][t] && !a[i + 1][j][t - 1]))) || n              (a[i][j - 1][t] && n               (a[i][j + 1][t] || (a[i][j][t + 1] && !a[i][j - 1][t + 1]) || n                (a[i + 1][j][t] && !a[i + 1][j - 1][t]))) || n              (a[i - 1][j][t] && n               (a[i + 1][j][t] || (a[i][j][t + 1] && !a[i - 1][j][t + 1]) || n                (a[i][j + 1][t] && !a[i - 1][j + 1][t]))))) n           ++ans; n   cout << ans; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n long long dp[100050][205]; n int redpac[100050][4]; n int e[100050]; n bool cmp(int x, int y) { return redpac[x][0] < redpac[y][0]; } n int main() { n   int n, m, k, cur = 0; n   long long ans = -1; n   priority_queue<pair<int, pair<int, int> > > availablepackets; n   scanf( %d%d%d , &n, &m, &k); n   for (int i = 0; i < k; i++) { n     scanf( %d%d%d%d , &redpac[i][0], &redpac[i][1], &redpac[i][2], n           &redpac[i][3]); n     e[i] = i; n   } n   sort(e, e + k, cmp); n   memset(dp, -1, sizeof(dp)); n   dp[1][0] = 0; n   for (int i = 1; i <= n; i++) { n     if (availablepackets.size() > 0) { n       while (availablepackets.top().second.second < i) { n         availablepackets.pop(); n         if (availablepackets.size() == 0) break; n       } n     } n     while (cur < k && redpac[e[cur]][0] <= i) { n       availablepackets.push(make_pair( n           redpac[e[cur]][3], make_pair(redpac[e[cur]][2], redpac[e[cur]][1]))); n       cur++; n     } n     for (int j = 0; j < m + 1; j++) { n       if (dp[i][j] == -1) continue; n       if (j < m && (dp[i + 1][j + 1] > dp[i][j] || dp[i + 1][j + 1] == -1)) { n         dp[i + 1][j + 1] = dp[i][j]; n       } n       if (availablepackets.size() > 0) { n         if (dp[availablepackets.top().second.first + 1][j] > n                 dp[i][j] + availablepackets.top().first || n             dp[availablepackets.top().second.first + 1][j] == -1) { n           dp[availablepackets.top().second.first + 1][j] = n               dp[i][j] + availablepackets.top().first; n         } n       } else { n         if (dp[i + 1][j] == -1 || dp[i + 1][j] > dp[i][j]) { n           dp[i + 1][j] = dp[i][j]; n         } n       } n     } n   } n   for (int i = 0; i < m + 1; i++) { n     if (dp[n + 1][i] != -1 && (ans > dp[n + 1][i] || ans == -1)) { n       ans = dp[n + 1][i]; n     } n   } n   printf( %lld , ans); n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int main() { n   int n; n   cin >> n; n   vector<int> v(n); n   for (int i = 0; i < n; i++) { n     cin >> v[i]; n   } n   sort(v.begin(), v.end()); n   long long sum = 0; n   for (int i = 0; i < n / 2; i++) { n     long long p_sum = v[i] + v[n - i - 1]; n     sum += (p_sum * p_sum); n   } n   cout << sum << endl; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n vector<int> r; n vector<int> l; n int n, ans, a[550000]; n int main() { n   cin >> n; n   for (int i = 1; i <= n; i++) cin >> a[i]; n   a[0] = a[1]; n   a[n + 1] = a[n]; n   for (int i = 1; i <= n; i++) { n     if (a[i] == a[i + 1] && a[i] != a[i - 1]) r.push_back(i); n     if (a[i] != a[i + 1] && a[i] == a[i - 1]) l.push_back(i); n   } n   for (int i = 0; i < l.size(); i++) ans = max(ans, r[i] - l[i]); n   cout << ans / 2 << endl; n   for (int i = 0; i < l.size(); i++) n     if (a[l[i]] == a[r[i]]) n       for (int j = l[i]; j <= r[i]; j++) a[j] = a[l[i]]; n     else { n       for (int j = l[i]; j <= (r[i] + l[i]) / 2; j++) a[j] = a[l[i]]; n       for (int j = (r[i] + l[i]) / 2 + 1; j <= r[i]; j++) a[j] = a[r[i]]; n     } n   for (int i = 1; i <= n; i++) cout << a[i] <<    ; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int main() { n   int n, s; n   int max = 0; n   int counter = 0; n   cin >> n >> s; n   for (int i = 0; i < n; i++) { n     int a; n     cin >> a; n     counter += a; n     if (a > max) { n       max = a; n     } n   } n   if (counter - max > s) { n     cout <<  NO ; n     return 0; n   } else { n     cout <<  YES ; n     return 0; n   } n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int max(int a, int b, int c, int d) { n   if (a >= b && a >= c && a >= d) return a; n   if (b >= a && b >= c && b >= d) return b; n   if (c >= a && c >= b && c >= d) return c; n   if (d >= a && d >= c && d >= b) return d; n   return d; n } n int main() { n   int x1, x2, x3, x4; n   cin >> x1 >> x2 >> x3 >> x4; n   int mx = max(x1, x2, x3, x4); n   if (mx == x1) { n     cout << mx - x2 <<     << mx - x3 <<     << mx - x4; n   } else { n     if (mx == x2) { n       cout << mx - x1 <<     << mx - x3 <<     << mx - x4; n     } else { n       if (mx == x3) { n         cout << mx - x2 <<     << mx - x1 <<     << mx - x4; n       } else { n         if (mx == x4) { n           cout << mx - x2 <<     << mx - x3 <<     << mx - x1; n         } n       } n     } n   } n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int t, n, m, cur; n int nxt[200200][26], link[200200], dp[200200], cnt[200200], ord[200200], n     occur[200200]; n char s[200200]; n void extend(int c) { n   int x = cur, y = cur = ++m; n   dp[y] = dp[x] + 1; n   occur[y] = 1; n   while (x && !nxt[x][c]) nxt[x][c] = y, x = link[x]; n   if (!x) n     link[y] = 1; n   else { n     int z = nxt[x][c]; n     if (dp[z] == dp[x] + 1) n       link[y] = z; n     else { n       int u = ++m; n       memcpy(nxt[u], nxt[z], sizeof nxt[u]); n       link[u] = link[z], link[z] = link[y] = u; n       dp[u] = dp[x] + 1; n       while (x && nxt[x][c] == z) nxt[x][c] = u, x = link[x]; n     } n   } n } n void build(char *s) { n   memset(nxt, 0, sizeof nxt), memset(link, 0, sizeof link), n       memset(dp, 0, sizeof dp); n   n = strlen(s), m = 0; n   cur = ++m; n   for (int i = 0; i < n; i++) extend(s[i] -  a ); n   memset(cnt, 0, sizeof cnt); n   for (int i = 1; i <= m; i++) cnt[dp[i]]++; n   for (int i = 1; i <= n; i++) cnt[i] += cnt[i - 1]; n   for (int i = m; i >= 1; i--) ord[cnt[dp[i]]--] = i; n } n int main() { n   scanf( %d , &t); n   while (t--) { n     scanf( %s , s); n     memset(occur, 0, sizeof occur); n     build(s); n     for (int i = m; i >= 1; i--) occur[link[ord[i]]] += occur[ord[i]]; n     long long ans = 0; n     for (int i = 1; i <= m; i++) n       ans += 1ll * occur[i] * occur[i] * (dp[i] - dp[link[i]]); n     printf( %I64d n , ans); n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int maxN = 1e4; n long long F[maxN + 1]; n void fact() { n   F[0] = F[1] = 1; n   for (int i = 2; i <= maxN; i++) F[i] = (1LL * F[i - 1] * i) % 998244353; n } n long long power(long long a, long long b) { n   long long res = 1; n   while (b) { n     if (b & 1) { n       res = (1LL * res * a) % 998244353, b--; n     } else { n       a = (1LL * a * a) % 998244353, b >>= 1; n     } n   } n   return res; n } n long long C(long long n, long long r) { n   if (r > n) return 0; n   long long res = F[n]; n   res = (1LL * res * power(F[r], 998244353 - 2)) % 998244353; n   res = (1LL * res * power(F[n - r], 998244353 - 2)) % 998244353; n   return res; n } n void solve() { n   long long n, k; n   cin >> n >> k; n   string second; n   cin >> second; n   if (!k) { n     cout <<  1 n ; n     return; n   } n   long long ans = 1, l = 0, r = 0, cnt = 0; n   while (r < n) { n     if (second[r] ==  1 ) { n       if (cnt == k) { n         (ans += (C(r - l, k) - 1 + 998244353) % 998244353) %= 998244353; n         while (l < n && second[l] !=  1 ) l++; n         l++, cnt--; n         ans = (ans - C(r - l, k - 1) + 1 + 998244353) % 998244353; n       } n       cnt++; n     } n     r++; n   } n   if (cnt == k) (ans += (C(r - l, k) - 1 + 998244353) % 998244353) %= 998244353; n   cout << ans <<   n ; n } n int main() { n   ios_base::sync_with_stdio(false); n   cin.tie(0), cout.tie(0), fact(); n   solve(); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n vector<int> v[250001]; n int a, ans[250001], n, i, q, kol; n bool pole[250001]; n void dfs(int nom) { n   int i; n   kol++; n   pole[nom] = true; n   for (i = 0; i < v[nom].size(); i++) n     if (!pole[v[nom][i]]) dfs(v[nom][i]); n   ans[nom] = kol; n } n int main() { n   ios::sync_with_stdio(0); n   cin.tie(0); n   cin >> q; n   while (q--) { n     cin >> n; n     for (i = 1; i <= n; i++) { n       v[i].clear(); n       pole[i] = false; n     } n     for (i = 1; i <= n; i++) { n       cin >> a; n       v[i].push_back(a); n     } n     for (i = 1; i <= n; i++) n       if (!pole[i]) { n         kol = 0; n         dfs(i); n       } n     for (i = 1; i <= n - 1; i++) cout << ans[i] <<    ; n     cout << ans[n] <<   n ; n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int inf = 1e9 + 7; n const long long INF = 1e18L + 7; n template <class n, class second> n ostream &operator<<(ostream &p, pair<n, second> x) { n   return p <<  <  << x.first <<  ,   << x.second <<  > ; n } n template <class n> n auto operator<<(ostream &p, n y) -> n     typename enable_if<!is_same<n, string>::value, n                        decltype(y.begin(), p)>::type { n   int o = 0; n   p <<  { ; n   for (auto c : y) { n     if (o++) p <<  ,  ; n     p << c; n   } n   return p <<  } ; n } n void dor() { cerr <<   n ; } n template <class n, class... second> n void dor(n p, second... y) { n   cerr << p <<    ; n   dor(y...); n } n template <class n, class second> n void mini(n &p, second y) { n   if (p > y) p = y; n } n template <class n, class second> n void maxi(n &p, second y) { n   if (p < y) p = y; n } n const int mod = 998244353; n const int N = 507; n int n, m; n int tab[N]; n int dp[N][N][3]; n int vis[N][N][3]; n int pie[N]; n int dru[N]; n void solve(int a, int b, int t) { n   if (vis[a][b][t]) return; n   vis[a][b][t] = 1; n   if (a > b) { n     if (t == 2) n       dp[a][b][t] = 1; n     else n       dp[a][b][t] = 0; n     return; n   } n   int col = inf; n   int ind = -1; n   if (t == 2) { n     for (int i = a; i <= b; ++i) { n       if (col > tab[i]) { n         col = tab[i]; n         ind = i; n       } n     } n     solve(a, ind, 1); n     solve(ind, b, 0); n     dp[a][b][t] = (long long)dp[a][ind][1] * dp[ind][b][0] % mod; n   } else if (t == 0) { n     for (int i = a; i <= b; ++i) { n       solve(a + 1, i, 2); n       solve(i + 1, b, 2); n       dp[a][b][t] += (long long)dp[a + 1][i][2] * dp[i + 1][b][2] % mod; n       if (dp[a][b][t] >= mod) dp[a][b][t] -= mod; n     } n   } else if (t == 1) { n     for (int i = a; i <= b; ++i) { n       solve(a, i - 1, 2); n       solve(i, b - 1, 2); n       dp[a][b][t] += (long long)dp[a][i - 1][2] * dp[i][b - 1][2] % mod; n       if (dp[a][b][t] >= mod) dp[a][b][t] -= mod; n     } n   } n } n int32_t main() { n   ios_base::sync_with_stdio(0); n   cin.tie(NULL); n   cin >> n >> m; n   for (int i = 1; i <= n; ++i) { n     cin >> tab[i]; n   } n   solve(1, n, 2); n   cout << dp[1][n][2] <<   n ; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int n, a[3005], b[3005], df[3005]; n long long F[3005][3005]; n int main() { n   ios_base::sync_with_stdio(false); n   cin.tie(NULL); n   cout.tie(NULL); n   cin >> n; n   for (int i = 1; i <= n; ++i) { n     cin >> a[i]; n     a[i] = a[i] - i; n     b[i] = a[i]; n   } n   sort(b + 1, b + n + 1); n   int m = 0; n   b[0] = b[1] - 1; n   for (int i = 1; i <= n; ++i) { n     if (b[i] > b[i - 1]) df[++m] = b[i]; n   } n   for (int i = 1; i <= n; ++i) n     for (int j = 0; j <= m; ++j) { n       F[i][j] = 1e18; n     } n   for (int i = 1; i <= n; ++i) { n     for (int j = 1; j <= m; ++j) { n       F[i][j] = min(F[i][j - 1], F[i - 1][j] + abs(a[i] - df[j])); n     } n   } n   long long rs = 1e18; n   for (int i = 1; i <= m; ++i) rs = min(rs, F[n][i]); n   cout << rs; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n #pragma GCC optimize( -O2 ) n using namespace std; n const int LIM = 2e5 + 5, MOD = 1e9 + 7; n int t, n, m, k, x, y; n template <typename... T> n void read(T &...args) { n   ((cin >> args), ...); n } n template <typename... T> n void print(T &&...args) { n   ((cout << args <<    ), ...); n } n int main() { n   int n; n   read(n); n   long long int arr[n]; n   for (int i = 0; i < n; i++) read(arr[i]); n   sort(arr, arr + n); n   long long int val = pow(arr[n - 1], 1.0 / (n - 1)); n   long long int a1 = 0, a2 = 0; n   for (int i = 0; i < n; i++) { n     a1 += abs(pow(val, i) - arr[i]); n   } n   val++; n   for (int i = 0; i < n; i++) { n     a2 += abs(pow(val, i) - arr[i]); n   } n   long long int curr = pow(val, n - 2), curr2 = pow(val, n - 1); n   if (curr2 / curr == val) n     cout << min(a1, a2) << endl; n   else n     cout << a1 << endl; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n typedef struct frac { n   long long p, q; n } frac; n const double eps = 1e-8; n int n; n int nb[100100]; n vector<int> G[100100]; n bool col[100100]; n int cur[100100]; n int onstk[100100]; n inline bool operator<(frac a, frac b) { return a.p * b.q < b.p * a.q; } n inline bool operator==(frac a, frac b) { return a.p * b.q == b.p * a.q; } n inline bool operator>(frac a, frac b) { return a.p * b.q > b.p * a.q; } n inline bool operator>=(frac a, double b) { n   return ((double)a.p / (double)a.q) >= b; n } n inline bool operator!=(frac a, frac b) { return a.p * b.q != b.p * a.q; } n inline frac newfrac(long long a, long long b) { n   frac x; n   x.p = a; n   x.q = b; n   return x; n } n inline bool valid(double z, bool pr) { n   priority_queue<pair<frac, int>, vector<pair<frac, int> >, n                  greater<pair<frac, int> > > n       S; n   for (int i = (1); i <= (n); i++) { n     cur[i] = 0; n     onstk[i] = false; n   } n   for (int x = (1); x <= (n); x++) { n     if (col[x]) { n       for (int j = (0); j < (G[x].size()); j++) { n         int y = G[x][j]; n         if (col[y]) { n           cur[x]++; n         } n       } n       S.push(make_pair(newfrac(cur[x], nb[x]), x)); n       onstk[x] = true; n     } n   } n   bool ok = false; n   while (!S.empty()) { n     if (!onstk[S.top().second]) { n       S.pop(); n       continue; n     } n     if (S.top().first >= z) { n       ok = true; n       break; n     } else { n       int x = S.top().second; n       S.pop(); n       onstk[x] = false; n       for (int j = (0); j < (G[x].size()); j++) { n         int y = G[x][j]; n         if (onstk[y]) { n           cur[y]--; n           S.push(make_pair(newfrac(cur[y], nb[y]), y)); n         } n       } n     } n   } n   if (pr) { n     int cnt = 0; n     vector<int> V; n     for (int i = (1); i <= (n); i++) { n       if (onstk[i]) { n         cnt++; n         V.push_back(i); n       } n     } n     printf( %d n , cnt); n     for (int i = (0); i < (V.size()); i++) { n       printf( %d , V[i]); n       if (i < V.size() - 1) { n         printf(   ); n       } n     } n     printf(  n ); n   } n   return ok; n } n int main() { n   int m, k, x, y; n   scanf( %d%d%d , &n, &m, &k); n   for (int i = (1); i <= (n); i++) { n     nb[i] = 0; n     col[i] = true; n   } n   for (int i = (1); i <= (k); i++) { n     scanf( %d , &x); n     col[x] = false; n   } n   for (int i = (1); i <= (m); i++) { n     scanf( %d%d , &x, &y); n     nb[x]++; n     nb[y]++; n     if ((col[y]) and (col[x])) { n       G[x].push_back(y); n       G[y].push_back(x); n     } n   } n   double l = 0.0, r = 1.0; n   while ((r - l) > eps) { n     double mid = (l + r) / 2; n     if (valid(mid, false)) { n       l = mid; n     } else { n       r = mid; n     } n   } n   col[0] = valid(l, true); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int n = 100002; n char h[n], h1[n]; n int a[n]; n bool check(int e, int r, int v1, int c1) { n   int c, v, c2, v2; n   while (e < r) { n     for (c = 0; c < 10; c++) n       for (v = 0; v < 10; v++) n         if (c + v == v1 + h[r]) { n           if ((c == 0) && (e == 0)) continue; n           goto st; n         } n     if ((h[r] == 9) && (v1 == 10)) { n       c = 9; n       v = 0; n       goto st; n     } n     return 0; n   st: n     h[r - 1] -= (c + v) / 10; n     if (h[r - 1] < 0) { n       for (c2 = r - 2; (c2 >= 0) && (h[c2 + 1] < 0); c2--) { n         h[c2 + 1] += 10; n         h[c2]--; n       } n       if (c2 < e - 1) return 0; n     } n     a[e] = c; n     a[r] = v; n     c += v; n     v = v1 + h[e] - c; n     if ((v != 0) && (v != 1)) return 0; n     v1 = v * 10; n     c1 = c / 10; n     if (e == r - 1) { n       if (v == 1) return 0; n       return 1; n     } n     e++; n     r--; n   } n   if (e > r) { n     if ((v1 + c1 == 11) || (v1 + c1 == 0)) return 1; n     return 0; n   } n   for (c = 0; c < 10; c++) n     if (c + c == v1 + h[e]) break; n   if (c == 10) return 0; n   a[e] = c; n   return 1; n } n int main() { n   int q, w, e, r, t; n   scanf( %s , h1); n   q = strlen(h1); n   for (w = 0; w < q; w++) h1[w] -= 48; n   for (w = 0; w < q; w++) h[w] = h1[w]; n   if (check(0, q - 1, 0, 0)) { n     for (w = 0; w < q; w++) printf( %d , a[w]); n     return 0; n   } n   for (w = 0; w < q; w++) h[w] = h1[w]; n   if ((h[0] == 1) && (check(1, q - 1, 10, 0))) { n     for (w = 1; w < q; w++) printf( %d , a[w]); n     return 0; n   } n   printf( 0 ); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int N = 1e5 + 10; n int A, B, C, D; n struct Point { n   long long x, y; n   Point(long long x, long long y) : x(x), y(y) {} n }; n bool operator<(const Point& a, const Point& b) { n   return a.x < b.x || (a.x == b.x && a.y > b.y); n } n int main() { n   int n; n   scanf( %d , &n); n   scanf( %d/%d %d/%d , &A, &B, &C, &D); n   vector<Point> P; n   for (int i = 0; i < n; ++i) { n     int u, v; n     scanf( %d%d , &u, &v); n     long long x = (long long)B * v - (long long)A * u; n     long long y = (long long)C * u - (long long)D * v; n     if (x > 0 && y > 0) { n       P.emplace_back(Point(x, y)); n     } n   } n   sort(P.begin(), P.end()); n   vector<long long> len; n   for (auto& it : P) { n     int idx = lower_bound(len.begin(), len.end(), it.y) - len.begin(); n     if (idx == len.size()) { n       len.emplace_back(it.y); n     } else { n       len[idx] = it.y; n     } n   } n   printf( %d n , len.size()); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int dp[5000][5000]; n int main() { n   char a[5000], b[5000]; n   int ti, td, tr, te; n   scanf( %d %d %d %d , &ti, &td, &tr, &te); n   scanf( %s %s , a, b); n   int n = strlen(a); n   int m = strlen(b); n   dp[0][0] = 0; n   for (int i = 1; i <= n; i++) dp[i][0] = dp[i - 1][0] + td; n   for (int i = 1; i <= m; i++) dp[0][i] = dp[0][i - 1] + ti; n   int da[26]; n   int db; n   memset(da, 0, sizeof(da)); n   int ii, jj, d; n   for (int i = 1; i <= n; i++) { n     db = 0; n     for (int j = 1; j <= m; j++) { n       d = (a[i - 1] == b[j - 1]) ? 0 : tr; n       ii = da[b[j - 1] -  a ]; n       jj = db; n       db = (a[i - 1] == b[j - 1]) ? j : db; n       dp[i][j] = n           min(dp[i][j - 1] + ti, min(dp[i - 1][j] + td, dp[i - 1][j - 1] + d)); n       if (ii > 0 && jj > 0) n         dp[i][j] = min(dp[i][j], dp[ii - 1][jj - 1] + (i - ii - 1) * td + n                                      (j - jj - 1) * ti + te); n     } n     da[a[i - 1] -  a ] = i; n   } n   printf( %d n , dp[n][m]); n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n int n; n int main() { n   int i; n   scanf( %d , &n); n   for (i = 20; i >= 0; i--) { n     if (n & (1 << i)) printf( %d  , i + 1); n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int N = 100005; n struct all { n   int t, num; n   char x, type; n } a[N]; n bool cmp(all a, all b) { return a.t < b.t; } n int redhome[N], redaway[N]; n int yellhome[N], yellaway[N]; n string home, away; n int n; n int main() { n   cin >> home >> away; n   cin >> n; n   for (int i = 1; i <= n; ++i) cin >> a[i].t >> a[i].x >> a[i].num >> a[i].type; n   sort(a + 1, a + n + 1, &cmp); n   for (int i = 1; i <= n; ++i) { n     if (a[i].x ==  h ) { n       if (a[i].type ==  r ) { n         if (redhome[a[i].num] == 0) { n           redhome[a[i].num] = a[i].t; n           cout << home <<     << a[i].num <<     << a[i].t << endl; n         } n       } else { n         if (yellhome[a[i].num] == 0) n           yellhome[a[i].num] = a[i].t; n         else if (redhome[a[i].num] == 0) { n           redhome[a[i].num] = a[i].t; n           cout << home <<     << a[i].num <<     << a[i].t << endl; n         } n       } n     } else { n       if (a[i].type ==  r ) { n         if (redaway[a[i].num] == 0) { n           redaway[a[i].num] = a[i].t; n           cout << away <<     << a[i].num <<     << a[i].t << endl; n         } n       } else { n         if (yellaway[a[i].num] == 0) n           yellaway[a[i].num] = a[i].t; n         else if (redaway[a[i].num] == 0) { n           redaway[a[i].num] = a[i].t; n           cout << away <<     << a[i].num <<     << a[i].t << endl; n         } n       } n     } n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int main() { n   int n, p; n   cin >> n >> p; n   string s; n   cin >> s; n   bool f = 0; n   int i = s.size() - 1; n   if (i > 0) { n     while (s[i] -  a  == p - 1) { n       s[i] =  a ; n       i--; n     } n     s[i]++; n   } n   if (s.size() == 2) i = s.size() - 1; n   while (!f) { n     if (i > 1 && s[i] != s[i - 1] && s[i] != s[i - 2]) n       if (i == s.size() - 1) { n         f = 1; n         break; n       } else n         i++; n     else if (i > 1 && (s[i] == s[i - 1] || s[i] == s[i - 2])) { n       if (s[i] -  a  < p - 1) n         s[i]++; n       else { n         s[i] =  a ; n         i--; n         while (s[i] -  a  == p - 1 && i >= 0) { n           s[i] =  a ; n           i--; n         } n         if (i < 0) { n           f = 0; n           break; n         } n         if (i != 0) s[i]++; n       } n     } else if (i == 1 && s[i] != s[i - 1]) n       if (i == s.size() - 1) { n         f = 1; n         break; n       } else n         i++; n     else if (i == 1 && s[i] == s[i - 1]) n       if (s[i] -  a  < p - 1) n         s[i]++; n       else { n         s[i] =  a ; n         i--; n         if (s[i] -  a  == p - 1) { n           f = 0; n           break; n         } n       } n     else if (i == 0) { n       if (s[i] -  a  < p - 1) { n         s[i]++; n         i++; n       } else { n         f = 0; n         break; n       } n       if (s.size() == 1) { n         f = 1; n         break; n       } n     } n   } n   if (f != 0) n     cout << s << endl; n   else n     cout <<  NO  << endl; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int euclid(int a, int b, int &x, int &y) { n   if (!a) { n     x = 0; n     y = 1; n     return b; n   } n   int _x, _y; n   int g = euclid(b % a, a, _x, _y); n   x = _y - b / a * _x; n   y = _x; n   return g; n } n void relax(int &obj, int C3, int C4, int C5, int _k3, int k4, int _k5, int &K3, n            int &K4, int &K5) { n   int f = abs(C3 * _k3 - C4 * k4) + abs(C4 * k4 - C5 * _k5); n   if (f < obj) { n     obj = f; n     K3 = _k3, K4 = k4, K5 = _k5; n   } n } n int main() { n   int n, S, a[333]; n   cin >> n >> S; n   for (int i = 0; i < n; ++i) { n     cin >> a[i]; n   } n   int C[11] = {0}; n   for (int _n(n), i(0); i < _n; i++) C[a[i]]++; n   int K3 = 1011111111, K4 = 1011111111, K5 = 1011111111, F = 1011111111; n   int ek3 = 1011111111, ek5 = 1011111111; n   const int D = euclid(C[3], C[5], ek3, ek5); n   for (int k4 = 0; k4 * C[4] <= S; ++k4) { n     const int REM = S - k4 * C[4]; n     if (REM % D) continue; n     int k3 = ek3 * (REM / D), k5 = ek5 * (REM / D); n     assert(k3 * C[3] + k5 * C[5] == REM); n     int idx[] = {(k4 - k3 + C[5] / D - 1) / (C[5] / D), n                  (k5 - k4 + C[3] / D - 1) / (C[3] / D), n                  (k5 - k4 * C[4] + C[3] / D - 1) / (C[3] / D) + 4, n                  (k4 * C[4] - k3 + C[5] / D - 1) / (C[5] / D) + 4}; n     for (int o = 0; o < 4; ++o) { n       int j = idx[o]; n       for (int it = 0; it < 1055; --j, ++it) { n         int _k3 = k3 + j * (C[5] / D); n         int _k5 = k5 - j * (C[3] / D); n         if (_k3 < 0) continue; n         if (_k3 > k4) continue; n         if (_k5 < k4) continue; n         relax(F, C[3], C[4], C[5], _k3, k4, _k5, K3, K4, K5); n       } n     } n   } n   if (F == 1011111111) { n     cout << -1 << endl; n   } else { n     printf( %d %d %d n , K3, K4, K5); n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n #pragma GCC optimize(2) n using namespace std; n void qread(int &x) { n   int neg = 1; n   x = 0; n   char c = getchar(); n   while (c <  0  || c >  9 ) { n     if (c ==  - ) neg = -1; n     c = getchar(); n   } n   while (c >=  0  && c <=  9 ) x = 10 * x + c -  0 , c = getchar(); n   x *= neg; n } n const int maxn = 100005; n int n, l, r, k, ans, ansu, ansv; n vector<pair<int, int> > edge[maxn]; n vector<int> num; n int oriw[maxn], w[maxn], dep[maxn], lvl[maxn], son[maxn]; n int pos[maxn], dis[maxn]; n pair<int, int> val[maxn]; n namespace Segtree { n int sz; n pair<int, int> t[maxn * 4]; n void init(int _sz) { n   for (sz = 1; sz < _sz; sz <<= 1) n     ; n   for (int(i) = 0; (i) < sz << 1; i++) t[i] = make_pair(-1e9, -1e9); n } n void update(int v, pair<int, int> val) { n   v += sz - 1; n   t[v] = val; n   for (v >>= 1; v; v >>= 1) t[v] = max(t[v << 1], t[v << 1 | 1]); n } n pair<int, int> query(int l, int r) { n   pair<int, int> res = make_pair(-1e9, -1e9); n   for (l += sz - 1, r += sz - 1; l <= r; l >>= 1, r >>= 1) { n     if (l & 1) res = max(res, t[l]), l++; n     if ((r + 1) & 1) res = max(res, t[r]), r--; n   } n   return res; n } n }  // namespace Segtree n void prework1(int x, int p, int d) { n   dep[x] = lvl[x] = d; n   for (int(i) = 0; (i) < edge[x].size(); i++) { n     pair<int, int> y = edge[x][i]; n     if (y.first == p) continue; n     prework1(y.first, x, d + 1); n     if (!son[x] || lvl[y.first] > lvl[son[x]]) son[x] = y.first; n     lvl[x] = max(lvl[x], lvl[y.first]); n   } n } n void prework2(int x, int p) { n   pos[x] = ++k; n   if (son[x]) prework2(son[x], x); n   for (int(i) = 0; (i) < edge[x].size(); i++) { n     pair<int, int> y = edge[x][i]; n     if (y.first == p || y.first == son[x]) continue; n     prework2(y.first, x); n   } n } n void work(int x, int p, int cur) { n   val[pos[x]] = make_pair(cur, x); n   dis[x] = cur; n   Segtree::update(pos[x], make_pair(cur, x)); n   for (int(i) = 0; (i) < edge[x].size(); i++) { n     int y = edge[x][i].first; n     if (y == son[x]) work(y, x, cur + w[edge[x][i].second]); n   } n   for (int(i) = 0; (i) < edge[x].size(); i++) { n     int y = edge[x][i].first; n     if (y == p || y == son[x]) continue; n     work(y, x, cur + w[edge[x][i].second]); n     int tmp = lvl[y] - dep[y]; n     for (int(d) = 0; (d) < tmp + 1; d++) { n       int ql = max(l - d - 1, 0), qr = min(r - d - 1, lvl[x] - dep[x]); n       pair<int, int> val2 = Segtree::query(pos[x] + ql, pos[x] + qr); n       if (val[pos[y] + d].first + val2.first - 2 * dis[x] > ans) { n         ans = val[pos[y] + d].first + val2.first - 2 * dis[x]; n         ansu = val[pos[y] + d].second; n         ansv = val2.second; n       } n     } n     for (int(d) = 0; (d) < tmp + 1; d++) { n       val[pos[x] + d + 1] = max(val[pos[x] + d + 1], val[pos[y] + d]); n       Segtree::update(pos[x] + d + 1, val[pos[x] + d + 1]); n     } n   } n   pair<int, int> val2 = n       Segtree::query(pos[x] + l, pos[x] + min(r, lvl[x] - dep[x])); n   if (val2.first - dis[x] > ans) { n     ans = val2.first - dis[x]; n     ansu = x; n     ansv = val2.second; n   } n } n bool check(int x) { n   for (int(i) = 1; (i) <= n - 1; i++) { n     if (oriw[i] < x) n       w[i] = -1; n     else n       w[i] = 1; n   } n   Segtree::init(n); n   for (int(i) = 1; (i) <= n; i++) val[i] = make_pair(-1e9, -1e9); n   ans = -1e9; n   work(1, 0, 0); n   return ans >= 0; n } n int main() { n   scanf( %d%d%d , &n, &l, &r); n   for (int(i) = 1; (i) <= n - 1; i++) { n     int u, v; n     scanf( %d%d%d , &u, &v, &oriw[i]); n     edge[u].push_back(make_pair(v, i)); n     edge[v].push_back(make_pair(u, i)); n     num.push_back(oriw[i]); n   } n   prework1(1, 0, 0); n   prework2(1, 0); n   sort(num.begin(), num.end()); n   num.resize(unique(num.begin(), num.end()) - num.begin()); n   int l = 0, r = num.size(); n   while (r - l > 1) { n     int mid = (l + r) >> 1; n     if (check(num[mid])) n       l = mid; n     else n       r = mid; n   } n   check(num[l]); n   printf( %d %d n , ansu, ansv); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n using namespace std::chrono; n struct custom_hash { n   size_t operator()(uint64_t x) const { n     static const uint64_t FIXED_RANDOM = n         chrono::steady_clock::now().time_since_epoch().count(); n     return x + FIXED_RANDOM; n   } n }; n void solve() { n   long long n; n   cin >> n; n   for (long long i = 2; i * i <= n; i++) { n     if (n % i == 0) { n       cout << n / i <<     << n - (n / i) <<   n ; n       return; n     } n   } n   cout << 1 <<     << n - 1 <<   n ; n } n int main() { n   ios::sync_with_stdio(0); n   cin.tie(0); n   int t; n   cin >> t; n   while (t--) solve(); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const long long MAXN = 200 + 17, inf = 2e18 + 17; n long long a[MAXN], b[MAXN], n, m, k, t[MAXN][MAXN], np; n void fillA() { n   for (int i = 1; i <= m; i++) n     for (int j = 0; i - j > 0 && j < n; j++) a[i] = min(t[j + 1][i - j], a[i]); n   for (int i = 1; i <= n; i++) n     for (int j = 0; i + j <= n && j < m; j++) n       a[i + m - 1] = min(a[i + m - 1], t[i + j][m - j]); n } n void fillBackT() { n   for (int i = 1; i <= m; i++) n     for (int j = 0; i - j > 0 && j < n; j++) t[j + 1][i - j] = a[i]; n   for (int i = 1; i <= n; i++) n     for (int j = 0; i + j <= n && j < m; j++) t[i + j][m - j] = a[i + m - 1]; n } n long long count(int x) { n   a[x] = 0; n   long long dp[MAXN][MAXN] = {}; n   if (a[1] == 1) n     dp[1][1] = 0; n   else n     dp[1][1] = 1; n   for (int i = 2; i <= np; i++) n     for (int j = 0; j <= np; j++) { n       if (a[i] == 1) n         dp[i][j] = dp[i - 1][j + 1]; n       else if (a[i] == 0) n         dp[i][j] = (j > 0 ? dp[i - 1][j - 1] : 0); n       else n         dp[i][j] = n             min(inf, (dp[i - 1][j + 1] + (j > 0 ? dp[i - 1][j - 1] : 0))); n     } n   return dp[np][0]; n } n int main() { n   ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0); n   cin >> n >> m >> k; n   for (int i = 1; i <= n; i++) n     for (int j = 1; j <= m; j++) cin >> t[i][j]; n   fill(a, a + MAXN, inf); n   fillA(); n   np = n + m - 1; n   iota(b + 1, b + np + 1, 1); n   sort(b + 1, b + np + 1, [](int i, int j) { return a[i] < a[j]; }); n   for (int i = 1; i <= np; i++) { n     long long tmp = count(b[i]); n     if (tmp >= k) n       a[b[i]] = 0; n     else { n       a[b[i]] = 1; n       k -= tmp; n     } n   } n   fillBackT(); n   for (int i = 1; i <= n; i++) { n     for (int j = 1; j <= m; j++) cout << (t[i][j] ?  )  :  ( ); n     cout << endl; n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int high = 2e5 + 6; n long long cnt[200005], dif[200005]; n int main() { n   long long n, m, k, i, j, ans, l, r, d, sum = 0, q; n   scanf( %lld%lld%lld , &n, &k, &q); n   for (i = 0; i < n; i++) { n     scanf( %lld%lld , &l, &r); n     dif[l]++; n     dif[r + 1]--; n   } n   for (i = 1; i <= high; i++) { n     dif[i] += dif[i - 1]; n   } n   for (i = 1; i <= high; i++) { n     if (dif[i] >= k) { n       cnt[i] = 1; n     } n   } n   for (i = 1; i <= high; i++) { n     cnt[i] += cnt[i - 1]; n   } n   while (q--) { n     scanf( %lld%lld , &l, &r); n     printf( %lld n , cnt[r] - cnt[l - 1]); n   } n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n const long long int MOD = 1000000007ll; n const int mxsz = 200005; n using namespace std; n int main() { n   std::ios_base::sync_with_stdio(false); n   long long int n, m, a; n   cin >> n >> m >> a; n   int ar1[n + 1], ar2[m + 1]; n   for (int i = 1; i <= n; i++) { n     cin >> ar1[i]; n   } n   for (int i = 1; i <= m; i++) { n     cin >> ar2[i]; n   } n   sort(ar1 + 1, ar1 + n + 1); n   sort(ar2 + 1, ar2 + m + 1); n   vector<long long int> b, p; n   for (int i = 1; i <= min(n, m); i++) { n     b.push_back(ar1[n - i + 1]); n     p.push_back(ar2[i]); n   } n   int l = 0, r = min(n, m); n   int ans = 0; n   while (l <= r) { n     int mid = (l + r) / 2; n     long long int tmp = a; n     for (int i = 0; i < mid; i++) { n       tmp -= (long long int)max(0LL, p[mid - i - 1] - b[i]); n       if (tmp < 0) { n         break; n       } n     } n     if (tmp >= 0) { n       l = mid + 1; n       ans = mid; n     } else { n       r = mid - 1; n     } n   } n   cout << ans <<    ; n   long long int tmp = 0; n   for (int i = 0; i < ans; i++) { n     tmp += (long long int)p[i]; n   } n   cout << max(0LL, tmp - a); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int x[1000], y[1000], k, n, m; n bool chck(int xx) { n   vector<int> v; n   v.push_back(1); n   v.push_back(m); n   for (int i = 0; i < k; ++i) { n     v.push_back(max(1, x[i] - xx)); n     v.push_back(max(1, x[i] - xx - 1)); n     v.push_back(min(m, x[i] + xx)); n     v.push_back(min(m, x[i] + xx + 1)); n   } n   sort(v.begin(), v.end()); n   int mn = 1e9, mx = -1, tmp, nm, c; n   bool l; n   vector<pair<int, int> > f; n   for (int i = 0; i < v.size(); ++i) { n     tmp = v[i]; n     f.clear(); n     for (int j = 0; j < k; ++j) { n       if (x[j] - xx <= tmp && x[j] + xx >= tmp) { n         f.push_back(make_pair(max(1, y[j] - xx), 0)); n         f.push_back(make_pair(min(n, y[j] + xx), 1)); n       } n     } n     sort(f.begin(), f.end()); n     c = 0; n     nm = 0; n     l = 0; n     for (int j = 0; j < f.size(); ++j) { n       if (nm == 0) { n         if (f[j].first != c + 1) { n           break; n         } n       } n       c = f[j].first; n       if (f[j].second == 0) n         ++nm; n       else n         --nm; n       if (c == n) { n         l = 1; n         break; n       } n     } n     if (!l) { n       mn = min(mn, tmp); n       mx = max(mx, tmp); n     } n   } n   mx = min(mx, m); n   mn = max(1, mn); n   if (mx - mn + 1 > xx + xx + 1) { n     return 0; n   } n   v.clear(); n   v.push_back(1); n   v.push_back(n); n   for (int i = 0; i < k; ++i) { n     v.push_back(max(1, y[i] - xx)); n     v.push_back(max(1, y[i] - xx - 1)); n     v.push_back(min(n, y[i] + xx)); n     v.push_back(min(n, y[i] + xx + 1)); n   } n   sort(v.begin(), v.end()); n   mn = 1e9, mx = -1; n   for (int i = 0; i < v.size(); ++i) { n     tmp = v[i]; n     f.clear(); n     for (int j = 0; j < k; ++j) { n       if (y[j] - xx <= tmp && y[j] + xx >= tmp) { n         f.push_back(make_pair(max(1, x[j] - xx), 0)); n         f.push_back(make_pair(min(m, x[j] + xx), 1)); n       } n     } n     sort(f.begin(), f.end()); n     c = 0; n     nm = 0; n     l = 0; n     for (int j = 0; j < f.size(); ++j) { n       if (nm == 0) { n         if (f[j].first != c + 1) { n           break; n         } n       } n       c = f[j].first; n       if (f[j].second == 0) n         ++nm; n       else n         --nm; n       if (c == m) { n         l = 1; n         break; n       } n     } n     if (!l) { n       mn = min(mn, tmp); n       mx = max(mx, tmp); n     } n   } n   mx = min(mx, n); n   mn = max(1, mn); n   if (mx - mn + 1 > xx + xx + 1) { n     return 0; n   } n   return 1; n } n int main() { n   while (cin >> m >> n >> k) { n     for (int i = 0; i < k; ++i) { n       scanf( %d%d , &x[i], &y[i]); n     } n     int st = 0, nd = 1e9, md; n     while (st < nd) { n       md = (st + nd) / 2; n       if (chck(md)) { n         nd = md; n       } else { n         st = md + 1; n       } n     } n     printf( %d n , nd); n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int cansel_sync = (ios::sync_with_stdio(0), cin.tie(0), 0); n const int N = 200010; n const int inf = ~0u >> 2; n const long long INF = ~0ull >> 2; n long long read() { n   long long x; n   if (scanf( %lld , &x) == -1) exit(0); n   return x; n } n const double pi = acos(-1.0); n double readf() { n   double x; n   if (scanf( %lf , &x) == -1) exit(0); n   return x; n } n template <typename T> n T sqr(const T &x) { n   return x * x; n } n int mod = (1 ? 1000000007 : 998244353); n long long mul(long long a, long long b, long long m = mod) { return a * b % m; } n long long qpow(long long a, long long b, long long m = mod) { n   long long ans = 1; n   for (; b; a = mul(a, a, m), b >>= 1) n     if (b & 1) ans = mul(ans, a, m); n   return ans; n } n long long getinv(long long v, long long m = mod) { return qpow(v, m - 2, m); } n long long n, x, t, l, r, sum; n void solve() { n   cin >> n >> x; n   sum = 0; n   l = inf, r = -inf; n   for (long long i = (0), _ = (n); i < _; i++) { n     cin >> t; n     if (t % x != 0) l = min(l, i), r = max(r, i); n     sum += t % x; n   } n   if (sum % x != 0) { n     cout << n << endl; n     return; n   } n   if (l != inf) { n     cout << max(n - l - 1, r) << endl; n     return; n   } n   cout << -1 << endl; n } n signed main() { n   long long T; n   cin >> T; n   while (T--) { n     solve(); n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int N = 1E5; n vector<int> vf, vz; n int main() { n   ios_base::sync_with_stdio(false); n   int n, k, p; n   cin >> n >> k >> p; n   for (int i = 0; i < n; i++) { n     int x; n     cin >> x; n     if (x % 2 == 0) n       vz.push_back(x); n     else n       vf.push_back(x); n   } n   int tf = vf.size(), tz = vz.size(); n   if (tf < (k - p) || p > tz + (tf - (k - p)) / 2 || (k - p) % 2 != tf % 2) n     cout <<  NO ; n   else { n     if ((tf - (k - p)) % 2 == 1) { n       cout <<  NO ; n     } n     if ((tf - (k - p)) % 2 == 0) { n       cout <<  YES  << endl; n       if (p == 0) { n         for (int i = 0; i < k - 1; i++) cout <<  1   << vf[i] << endl; n         cout << tf - (k - 1) + tz; n         for (int i = k - 1; i < tf; i++) cout <<     << vf[i]; n         for (int i = 0; i < tz; i++) cout <<     << vz[i]; n         cout << endl; n       } else if (tz >= p) { n         for (int i = 0; i < p - 1; i++) cout <<  1   << vz[i] << endl; n         cout << tz - p + 1 + tf - (k - p); n         for (int i = p - 1; i < tz; i++) cout <<     << vz[i]; n         for (int i = 0; i < tf - (k - p); i++) cout <<     << vf[i]; n         cout << endl; n         for (int i = tf - (k - p); i < tf; i++) cout <<  1   << vf[i] << endl; n       } else { n         for (int i = 0; i < tz; i++) cout <<  1   << vz[i] << endl; n         for (int i = 0; i < (p - tz) - 1; i++) n           cout <<  2   << vf[i * 2] <<     << vf[i * 2 + 1] << endl; n         cout << tf - (p - tz - 1) * 2 - (k - p); n         for (int i = (p - tz - 1) * 2; i < tf - (k - p); i++) n           cout <<     << vf[i]; n         cout << endl; n         for (int i = tf - (k - p); i < tf; i++) cout <<  1   << vf[i] << endl; n       } n     } n   } n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n int dx[] = {-1, -1, -1, 0, 1, 1, 1, 0}; n int dy[] = {-1, 0, 1, 1, 1, 0, -1, -1}; n using namespace std; n long long power(long long a, long long p, long long M) { n   long long r = 1; n   a = a % M; n   while (p > 0) { n     if (p % 2) r = (r * a) % M; n     a = (a * a) % M; n     p /= 2; n   } n   return r; n } n long long gcd(long long a, long long b) { n   if (b == 0) return a; n   return gcd(b, a % b); n } n long long n, m; n set<long long> e[100005]; n stack<long long> cycle, temp; n long long vis[505]; n bool found; n void findCycle(long long x) { n   temp.push(x); n   vis[x] = 1; n   for (auto y : e[x]) { n     if (vis[y] == 0) n       findCycle(y); n     else if (vis[y] == 1) { n       if (found) return; n       cycle = temp; n       cycle.push(y); n       found = 1; n       return; n     } n   } n   if (!temp.empty()) temp.pop(); n   vis[x] = 2; n } n void fc(long long x) { n   vis[x] = 1; n   for (auto y : e[x]) { n     if (vis[y] == 0) n       fc(y); n     else if (vis[y] == 1) { n       found = 1; n       return; n     } n   } n   vis[x] = 2; n } n void solve() { n   cin >> n >> m; n   for (long long i = 0; i < m; i++) { n     long long a, b; n     scanf( %lld%lld , &a, &b); n     e[a].insert(b); n   } n   for (long long i = 1; i < n + 1; i++) { n     if (!vis[i]) { n       findCycle(i); n       if (found) break; n     } n   } n   if (!found) { n     cout <<  YES n ; n     return; n   } n   vector<long long> c; n   for (long long i = 0; i < 505; i++) vis[i] = 0; n   while (!cycle.empty()) { n     c.push_back(cycle.top()); n     if (vis[cycle.top()]) { n       break; n     } n     vis[cycle.top()] = 1; n     cycle.pop(); n   } n   reverse(c.begin(), c.end()); n   for (long long i = 0; i < c.size() - 1; i++) { n     found = 0; n     e[c[i]].erase(c[i + 1]); n     for (long long j = 0; j < 505; j++) vis[j] = 0; n     for (long long j = 1; j < n + 1; j++) { n       if (!vis[j]) fc(j); n       if (found) { n         break; n       } n     } n     if (!found) { n       cout <<  YES n ; n       return; n     } n     e[c[i]].insert(c[i + 1]); n   } n   cout <<  NO n ; n } n int main() { n   solve(); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n long long A, B, N; n long long L, T, M; n bool ok(long long R) { n   long long mx = A + (R - 1) * B; n   long long mn = A + (L - 1) * B; n   long long D = R - L; n   if (mx > T) return false; n   return (mn * (D + 1) + B * D * (D + 1) / 2) <= T * M; n } n int main(void) { n   cin >> A >> B >> N; n   while (N--) { n     cin >> L >> T >> M; n     long long R = L; n     long long mn = A + (L - 1) * B; n     if (mn > T) { n       R = -1; n     } else { n       long long XR = 1LL << 22; n       while (XR > R) { n         long long m = (R + XR) / 2; n         if (!ok(m)) n           XR = m; n         else n           R = m + 1; n       } n       R -= 1; n     } n     cout << R <<   n ; n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int INF = 1e9 + 7, mod = 1e9 + 9, pw = 31; n const double eps = 1e-11; n long long binpow(long long a, long long b) { n   long long rec = 1; n   while (b) { n     if (b % 2 == 1) { n       rec *= a; n       rec %= INF; n     } n     a *= a; n     a %= INF; n     b /= 2; n   } n   return rec; n } n int main() { n   ios_base::sync_with_stdio(0); n   cin.tie(NULL); n   int n; n   cin >> n; n   long long x = binpow(3, n * 3) - binpow(7, n); n   if (x < 0) x += INF; n   cout << x; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n const long long INF64 = 1e18; n using namespace std; n const long long N = 2e5 + 6; n using namespace std; n vector<pair<long long, long long>> pf; n int main() { n   long long n, ans = INF64; n   cin >> n; n   vector<long long> cost(n, 0); n   vector<string> s; n   for (int i = 0; i < n; i++) cin >> cost[i]; n   for (int i = 0; i < n; i++) { n     string st; n     cin >> st; n     s.push_back(st); n   } n   vector<vector<long long>> dp(n, vector<long long>(2, INF64)); n   dp[n - 1][0] = 0; n   dp[n - 1][1] = cost[n - 1]; n   for (int i = n - 2; i >= 0; i--) { n     string currStr(s[i]), currrevStr(s[i]); n     string prevStr(s[i + 1]), prevrevStr(s[i + 1]); n     reverse(currrevStr.begin(), currrevStr.end()); n     reverse(prevrevStr.begin(), prevrevStr.end()); n     if (currStr.compare(prevStr) <= 0) dp[i][0] = min(dp[i][0], dp[i + 1][0]); n     if (currStr.compare(prevrevStr) <= 0) n       dp[i][0] = min(dp[i][0], dp[i + 1][1]); n     if (currrevStr.compare(prevStr) <= 0) n       dp[i][1] = min(dp[i][1], dp[i + 1][0] + cost[i]); n     if (currrevStr.compare(prevrevStr) <= 0) n       dp[i][1] = min(dp[i][1], dp[i + 1][1] + cost[i]); n   } n   ans = min(ans, min(dp[0][0], dp[0][1])); n   if (ans == INF64) n     cout << -1; n   else n     cout << ans; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n long long a[100005], n, c, mn[100005], dp[200005], sum; n int main() { n   ios_base::sync_with_stdio(0); n   cin >> n >> c; n   for (int i = 0; i < n; sum += a[i++]) cin >> a[i]; n   deque<long long> v; n   for (int i = n; i--;) { n     while (v.size() && v.back() >= i + c) v.pop_back(); n     while (v.size() && a[i] <= a[v.front()]) v.pop_front(); n     v.push_front(i); n     if (i <= n - c) dp[i] = max(dp[i + 1], a[v.back()] + dp[i + c]); n   } n   cout << sum - dp[0]; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n template <typename T1, typename T2> n inline T1 max(T1 a, T2 b) { n   return a < b ? b : a; n } n template <typename T1, typename T2> n inline T1 min(T1 a, T2 b) { n   return a < b ? a : b; n } n const char lf =   n ; n namespace ae86 { n const int bufl = 1 << 15; n char buf[bufl], *s = buf, *t = buf; n inline int fetch() { n   if (s == t) { n     t = (s = buf) + fread(buf, 1, bufl, stdin); n     if (s == t) return EOF; n   } n   return *s++; n } n inline int ty() { n   int a = 0; n   int b = 1, c = fetch(); n   while (!isdigit(c)) b ^= c ==  - , c = fetch(); n   while (isdigit(c)) a = a * 10 + c - 48, c = fetch(); n   return b ? a : -a; n } n }  // namespace ae86 n using ae86::ty; n const int _ = 100007, __ = _ << 1; n const long long linf = 0x3f3f3f3f3f3f3f3f; n int to[__], ne[__], he[_] = {0}, ecnt = 1; n inline void adde(int a, int b) { n   to[++ecnt] = b, ne[ecnt] = he[a], he[a] = ecnt; n } n inline void addde(int a, int b) { adde(a, b), adde(b, a); } n int n, m, qn; n int fa[_] = {0}, dep[_] = {0}, sz[_] = {0}, mxch[_] = {0}; n void dfs(int x, int ff) { n   fa[x] = ff, dep[x] = dep[ff] + 1, sz[x] = 1, mxch[x] = 0; n   for (int i = he[x]; i; i = ne[i]) { n     int b = to[i]; n     if (b == ff) continue; n     dfs(b, x), sz[x] += sz[b]; n     if (sz[mxch[x]] < sz[b]) mxch[x] = b; n   } n } n int dfn[_] = {0}, rdfn[_] = {0}, ndf[_] = {0}, top[_] = {0}, dcnt = 0; n void dfs2(int x, int tp) { n   dfn[x] = ++dcnt, rdfn[dcnt] = x, top[x] = tp; n   if (mxch[x]) dfs2(mxch[x], tp); n   for (int i = he[x]; i; i = ne[i]) { n     int b = to[i]; n     if (b == fa[x] || b == mxch[x]) continue; n     dfs2(b, b); n   } n   ndf[x] = dcnt; n } n vector<int> hav[_]; n struct cxk { n   int x; n   long long v; n   cxk(int x_ = 0, long long v_ = linf) { x = x_, v = v_; } n   friend bool operator<(cxk a, cxk b) { n     if (a.v != b.v) return a.v < b.v; n     return a.x < b.x; n   } n }; n const int _t = _ << 2; n cxk t[_t]; n long long tadd[_t]; n void up(int x) { t[x] = min(t[(x << 1)], t[(x << 1 | 1)]); } n void putadd(int x, long long d) { t[x].v += d, tadd[x] += d; } n void dwn(int x) { n   if (tadd[x]) n     putadd((x << 1), tadd[x]), putadd((x << 1 | 1), tadd[x]), tadd[x] = 0; n } n void plant(int x, int l, int r) { n   tadd[x] = 0; n   if (l == r) { n     t[x] = hav[l].empty() ? cxk() : cxk(l, hav[l].back()); n     return; n   } n   plant((x << 1), l, ((l + r) >> 1)), n       plant((x << 1 | 1), ((l + r) >> 1) + 1, r), up(x); n } n void change(int x, int l, int r, int tl, int tr, long long dlt) { n   if (tl <= l && r <= tr) { n     putadd(x, dlt); n     return; n   } n   dwn(x); n   if (tl <= ((l + r) >> 1)) change((x << 1), l, ((l + r) >> 1), tl, tr, dlt); n   if (tr > ((l + r) >> 1)) n     change((x << 1 | 1), ((l + r) >> 1) + 1, r, tl, tr, dlt); n   up(x); n } n void dating(int x, int l, int r, int tar) { n   if (l == r) { n     if (!hav[l].empty()) hav[l].pop_back(); n     t[x] = hav[l].empty() ? cxk() : cxk(l, hav[l].back() + tadd[x]); n     return; n   } n   dwn(x); n   if (tar <= ((l + r) >> 1)) n     dating((x << 1), l, ((l + r) >> 1), tar); n   else n     dating((x << 1 | 1), ((l + r) >> 1) + 1, r, tar); n   up(x); n } n cxk finder(int x, int l, int r, int tl, int tr) { n   if (tl <= l && r <= tr) return t[x]; n   dwn(x); n   if (tr <= ((l + r) >> 1)) return finder((x << 1), l, ((l + r) >> 1), tl, tr); n   if (tl > ((l + r) >> 1)) n     return finder((x << 1 | 1), ((l + r) >> 1) + 1, r, tl, tr); n   return min(finder((x << 1), l, ((l + r) >> 1), tl, tr), n              finder((x << 1 | 1), ((l + r) >> 1) + 1, r, tl, tr)); n } n cxk founder(int a, int b) { n   cxk ans; n   while (top[a] != top[b]) { n     if (dep[top[a]] < dep[top[b]]) swap(a, b); n     ans = min(ans, finder(1, 1, n, dfn[top[a]], dfn[a])), a = fa[top[a]]; n   } n   if (dep[a] > dep[b]) swap(a, b); n   return min(ans, finder(1, 1, n, dfn[a], dfn[b])); n } n int main() { n   ios::sync_with_stdio(0), cout.tie(nullptr); n   n = ty(), m = ty(), qn = ty(); n   for (int i = 1, a, b; i < n; i++) a = ty(), b = ty(), addde(a, b); n   dfs(1, 0), dfs2(1, 1); n   for (int i = 1; i <= m; i++) hav[dfn[ty()]].emplace_back(i); n   for (int i = 1; i <= n; i++) n     sort(hav[i].begin(), hav[i].end(), greater<int>()); n   plant(1, 1, n); n   for (int qq = 1; qq <= qn; qq++) { n     int op = ty(); n     if (op == 1) { n       int a = ty(), b = ty(), lim = ty(); n       vector<int> ans; n       while (lim--) { n         int ret = founder(a, b).x; n         if (ret <= 0) break; n         ans.emplace_back(hav[ret].back()), dating(1, 1, n, ret); n       } n       cout << ans.size(); n       for (auto i : ans) cout <<     << i; n       cout << lf; n     } n     if (op == 2) { n       int a = ty(), b = ty(); n       change(1, 1, n, dfn[a], ndf[a], b); n     } n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int MAX = 1010; n int n; n int a[MAX], c[MAX]; n void init() { cin >> n; } n void process() { n   memset(a, 63, sizeof(a)); n   vector<pair<int, int> > ques; n   ques.push_back(make_pair(1, n)); n   while (!ques.empty()) { n     vector<pair<int, int> > newQues; n     for (int i = 0; i < ques.size(); i++) { n       if (ques[i].first != ques[i].second) { n         int l = ques[i].first, r = ques[i].second, mid = (l + r) / 2; n         newQues.push_back(make_pair(l, mid)); n         newQues.push_back(make_pair(mid + 1, r)); n       } n     } n     vector<int> b; n     for (int i = 0; i < newQues.size(); i += 2) { n       for (int j = newQues[i].first; j <= newQues[i].second; j++) n         b.push_back(j); n     } n     if (b.size() > 0) { n       cout << b.size() <<   n ; n       for (int i = 0; i < b.size(); i++) cout << b[i] <<    ; n       cout <<   n ; n       fflush(stdout); n       for (int i = 1; i <= n; i++) cin >> c[i]; n       for (int i = 1; i <= n; i++) { n         bool check = true; n         for (int j = 0; j < b.size(); j++) { n           if (b[j] == i) { n             check = false; n             break; n           } n         } n         if (check) a[i] = min(a[i], c[i]); n       } n     } n     b.resize(0); n     for (int i = 1; i < newQues.size(); i += 2) { n       for (int j = newQues[i].first; j <= newQues[i].second; j++) n         b.push_back(j); n     } n     if (b.size() > 0) { n       cout << b.size() <<   n ; n       for (int i = 0; i < b.size(); i++) cout << b[i] <<    ; n       cout <<   n ; n       fflush(stdout); n       for (int i = 1; i <= n; i++) cin >> c[i]; n       for (int i = 1; i <= n; i++) { n         bool check = true; n         for (int j = 0; j < b.size(); j++) { n           if (b[j] == i) { n             check = false; n             break; n           } n         } n         if (check) a[i] = min(a[i], c[i]); n       } n     } n     ques = newQues; n   } n   cout << -1 <<   n ; n   for (int i = 1; i <= n; i++) cout << a[i] <<    ; n   cout <<   n ; n   fflush(stdout); n } n int main() { n   ios_base::sync_with_stdio(false); n   init(); n   process(); n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int MAXN = 300; n long long orign[MAXN], str[2 * MAXN]; n int radius[2 * MAXN]; n int n, m; n int mp[MAXN][MAXN]; n int num[MAXN][26]; n long long hashv[MAXN]; n long long base[30]; n int siz[MAXN]; n bool check(int x, int y) { n   for (int i = 0; i < 26; i++) { n     if (num[x][i] != num[y][i]) return false; n   } n   return true; n } n void Manacher(int len, int mark = 0) { n   for (int i = 0; i < len; i++) { n     str[2 * i + 1] = orign[i]; n     str[2 * i] = mark; n   } n   str[2 * len] = mark; n   len = 2 * len + 1; n   int max_right = 0, pos = 0; n   for (int i = 0; i < len; i++) { n     if (i < max_right) n       radius[i] = min(radius[2 * pos - i], max_right - i); n     else n       radius[i] = 1; n     while (i - radius[i] >= 0 && i + radius[i] < len && n            str[i - radius[i]] > -1 && str[i + radius[i]] > -1 && n            check(str[i - radius[i]], str[i + radius[i]])) { n       radius[i]++; n     } n     if (i + radius[i] >= max_right) { n       max_right = i + radius[i]; n       pos = i; n     } n   } n } n int main() { n   std::ios::sync_with_stdio(false); n   cin.tie(0); n   cin >> n >> m; n   base[0] = 1; n   for (int i = 1; i <= 26; i++) base[i] = base[i - 1] * 2; n   for (int i = 1; i <= n; i++) { n     for (int j = 1; j <= m; j++) { n       char ch; n       cin >> ch; n       mp[i][j] = ch -  a ; n     } n   } n   long long ans = 0; n   for (int l = 1; l <= m; l++) { n     memset(num, 0, sizeof(num)); n     memset(hashv, 0, sizeof(hashv)); n     memset(siz, 0, sizeof(siz)); n     for (int r = l; r <= m; r++) { n       for (int i = 1; i <= n; i++) { n         int id = mp[i][r]; n         num[i][id]++; n         hashv[i] += base[id]; n         if (num[i][id] & 1) n           siz[i]++; n         else n           siz[i]--; n         if (siz[i] > 1) n           orign[i - 1] = -i; n         else n           orign[i - 1] = i; n       } n       Manacher(n); n       for (int i = 0; i < 2 * n + 1; i++) { n         if (str[i] > -1) ans += radius[i] / 2; n       } n     } n   } n   cout << ans << endl; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int N = 10000010; n int p[N], num, last[N]; n bool flag[N]; n int cnt[N], n, m; n void make_prime() { n   for (int i = 2; i < N; ++i) n     if (!flag[i]) { n       p[num++] = i; n       last[i] = i; n       for (int j = i + i; j < N; j += i) flag[j] = true, last[j] = i; n     } n } n int main() { n   make_prime(); n   scanf( %d , &n); n   for (int i = 0, x; i < n; ++i) { n     scanf( %d , &x); n     int s = -1; n     while (x != 1) { n       if (last[x] != s) cnt[last[x]]++; n       s = last[x]; n       x /= last[x]; n     } n   } n   for (int i = 1; i < N; ++i) cnt[i] += cnt[i - 1]; n   scanf( %d , &m); n   for (int i = 0, x, y; i < m; ++i) { n     scanf( %d %d , &x, &y); n     if (x >= N) n       puts( 0 ); n     else { n       y = min(y, N - 1); n       printf( %d n , cnt[y] - cnt[x - 1]); n     } n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int INF = 0x3f3f3f3f; n const int N = 2005; n const int M = 730; n int Head[M * 10], Next[M * 100], vet[M * 100]; n int a[N], b[N], d[M * 10], vis[15], p[M][5], dis[M], Dis[M], P[10], len[M], n     U[M][12], D[M][12]; n int n, cnt, edgenum; n pair<int, int> c[M]; n queue<int> q; n inline int F(int x, int y) { return (x - 1) * cnt + y; } n inline void addedge(int u, int v) { n   edgenum++; n   vet[edgenum] = v; n   Next[edgenum] = Head[u]; n   Head[u] = edgenum; n } n int main() { n   scanf( %d , &n); n   int ans = INF; n   for (int i = 1; i <= n; i++) scanf( %d%d , &a[i], &b[i]); n   len[cnt = 1] = 0; n   for (int i = 1; i <= 9; i++) { n     len[++cnt] = 1; n     p[cnt][1] = i; n     for (int j = i; j <= 9; j++) { n       len[++cnt] = 2; n       p[cnt][1] = i, p[cnt][2] = j; n       for (int k = j; k <= 9; k++) { n         len[++cnt] = 3; n         p[cnt][1] = i, p[cnt][2] = j, p[cnt][3] = k; n         for (int t = k; t <= 9; t++) n           len[++cnt] = 4, p[cnt][1] = i, p[cnt][2] = j, p[cnt][3] = k, n           p[cnt][4] = t; n       } n     } n   } n   for (int i = 2; i <= cnt; i++) { n     memset(vis, 0, sizeof(vis)); n     for (int j = 1; j <= len[i]; j++) vis[p[i][j]] = 1; n     for (int j = 1; j <= 9; j++) { n       if (!vis[j]) continue; n       int res = j, cur = 0; n       for (int k = 1; k <= len[i]; k++) n         if (p[i][k] == res) n           res = -1; n         else n           P[++cur] = p[i][k]; n       for (int k = 1; k <= cnt; k++) { n         if (len[k] != cur) continue; n         bool flag = 1; n         for (int t = 1; t <= cur; t++) flag &= (P[t] == p[k][t]); n         if (flag) { n           D[i][j] = k; n           U[k][j] = i; n           break; n         } n       } n     } n   } n   memset(dis, 0x3f, sizeof(dis)); n   dis[1] = a[1] - 1; n   for (int j = 1; j < 9; j++) n     for (int k = 1; k <= cnt; k++) n       addedge(F(j, k), F(j + 1, k)), addedge(F(j + 1, k), F(j, k)); n   for (int j = 1; j <= 9; j++) n     for (int k = 1; k <= cnt; k++) n       if (D[k][j]) addedge(F(j, k), F(j, D[k][j])); n   for (int i = 1; i <= n; i++) { n     memset(Dis, 0x3f, sizeof(Dis)); n     for (int j = 1; j <= cnt; j++) n       if (U[j][b[i]]) Dis[U[j][b[i]]] = min(Dis[U[j][b[i]]], dis[j] + 1); n     for (int j = 1; j <= cnt; j++) dis[j] = Dis[j]; n     memset(d, 0x3f, sizeof(d)); n     for (int j = 1; j <= cnt; j++) n       d[F(a[i], j)] = dis[j], c[j] = make_pair(dis[j], j); n     sort(c + 1, c + 1 + cnt); n     for (int j = 1; j <= cnt; j++) n       if (c[j].first != INF) q.push(F(a[i], c[j].second)); n     while (!q.empty()) { n       int u = q.front(); n       q.pop(); n       for (int e = Head[u]; e; e = Next[e]) { n         int v = vet[e]; n         if (d[v] > d[u] + 1) d[v] = d[u] + 1, q.push(v); n       } n     } n     if (i == n) n       for (int j = 1; j <= 9; j++) ans = min(ans, d[F(j, 1)]); n     else n       for (int j = 1; j <= cnt; j++) dis[j] = d[F(a[i + 1], j)]; n   } n   printf( %d n , ans); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int N = 3003 * 6006; n const int qwq = 303030; n const int inf = 0x3f3f3f3f; n int n, m, k; n int f[N], fa[N], st[123], cnt; n int ans; n int ff[] = {1, 1, 1, 0, -1, -1, -1, 0}; n int gg[] = {1, 0, -1, -1, -1, 0, 1, 1}; n inline int read() { n   int sum = 0, f = 1; n   char c = getchar(); n   while (c <  0  || c >  9 ) { n     if (c ==  - ) f = -1; n     c = getchar(); n   } n   while (c >=  0  && c <=  9 ) { n     sum = sum * 10 + c -  0 ; n     c = getchar(); n   } n   return sum * f; n } n inline int dian(int x, int y) { n   if (y == 0) y = 2 * m; n   if (y == 2 * m + 1) y = 1; n   return (x - 1) * (m << 1) + y; n } n int find(int u) { n   while (fa[u] != u) u = fa[u]; n   return u; n } n int Splay(int u) { return fa[u] == u ? u : fa[u] = Splay(fa[u]); } n int main() { n   int x, y; n   n = read(); n   m = read(); n   k = read(); n   if (m == 1) { n     cout << 0; n     return 0; n   } n   for (int i = 1; i <= n * m * 2; i++) fa[i] = i; n   while (k--) { n     cnt = 0; n     x = read(); n     y = read(); n     for (int i = 0; i <= 8; i++) { n       if (x + ff[i] < 1 || x + ff[i] > n) continue; n       int u = dian(x + ff[i], y + gg[i]); n       if (!f[u]) continue; n       int aa = find(u); n       int bb = find(dian(x, y)); n       if (aa == bb) continue; n       st[++cnt] = bb; n       fa[bb] = aa; n     } n     y += m; n     for (int i = 0; i < 8; i++) { n       if (x + ff[i] < 1 || x + ff[i] > n) continue; n       int u = dian(x + ff[i], y + gg[i]); n       if (!f[u]) continue; n       int aa = find(u); n       int bb = find(dian(x, y)); n       if (aa == bb) continue; n       st[++cnt] = bb; n       fa[bb] = aa; n     } n     y -= m; n     if (find(dian(x, y)) != find(dian(x, y + m))) { n       ans++; n       for (int i = 0; i < 8; i++) { n         if (x + ff[i] < 1 || x + ff[i] > n) continue; n         Splay(dian(x + ff[i], y + gg[i])); n       } n       y += m; n       for (int i = 0; i < 8; i++) { n         if (x + ff[i] < 1 || x + ff[i] > n) continue; n         Splay(dian(x + ff[i], y + gg[i])); n       } n       y -= m; n       f[dian(x, y)] = f[dian(x, y + m)] = 1; n     } else { n       for (int i = 1; i <= cnt; i++) fa[st[i]] = st[i]; n     } n   } n   cout << ans; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int n, sum; n int main() { n   cin >> n; n   while (n != 0) { n     if (n % 8 == 1) sum++; n     n /= 8; n   } n   cout << sum; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int INF = 1 << 29; n const int MOD = 1000000007; n bool isPowerOfTwo(long long int x) { return x && (!(x & (x - 1))); } n void fastio() { n   ios_base::sync_with_stdio(false); n   cin.tie(0); n   cout.tie(0); n } n const int dx[] = {1, 0, -1, 0, 1, 1, -1, -1}; n const int dy[] = {0, -1, 0, 1, 1, -1, -1, 1}; n int main() { n   fastio(); n   int t = 1; n   while (t--) { n     int n; n     cin >> n; n     string s; n     cin >> s; n     int ans = 0; n     for (int i = 0; i < (s.length()); i++) { n       int x = int(s[i]) - 48; n       if (x % 2 == 0) ans += (i + 1); n     } n     cout << ans <<   n ; n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n map<long long, int> mp; n int n; n int main() { n   scanf( %d , &n); n   int t; n   long long s = 0; n   for (int i = 1; i <= n; i++) { n     scanf( %d , &t); n     s += t; n     mp[s]++; n   } n   int ans = 0; n   map<long long, int>::iterator it; n   for (it = mp.begin(); it != mp.end(); it++) { n     ans = max(ans, it->second); n   } n   printf( %d n , n - ans); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n vector<int> edge[100005]; n int v[100005]; n bool cycle = false; n int mx = -1, last; n void dfs(int u, int dis = 0) { n   v[u] = 1; n   if (dis > mx) { n     mx = dis; n     last = u; n   } n   for (int i = 0; i <= (int)((int)edge[u].size() - 1); i++) { n     int first = edge[u][i]; n     if (!v[first]) dfs(first, dis + 1); n   } n } n int main() { n   int T, n, m, a, b; n   scanf( %d , &n); n   scanf( %d , &m); n   for (int i = 1; i <= (int)(m); i++) { n     scanf( %d%d , &a, &b); n     edge[a].push_back(b); n     edge[b].push_back(a); n   } n   dfs(1); n   memset(v, 0, sizeof(v)); n   mx = -1; n   dfs(last); n   printf( %d , mx); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int INF = 1 << 29; n const double EPS = 1e-10; n vector<int> G[50010]; n vector<int> chil[50010]; n int cnt[50010][510]; n void dfs(int pos, int par) { n   for (int i = 0; i < (int)G[pos].size(); i++) { n     if (G[pos][i] != par) { n       chil[pos].push_back(G[pos][i]); n       dfs(G[pos][i], pos); n     } n   } n } n void init(int n) { n   memset(cnt, 0, sizeof(cnt)); n   dfs(0, -1); n } n void calc(int v, int k, long long &sum) { n   for (int i = 0; i < (int)chil[v].size(); i++) { n     int c = chil[v][i]; n     calc(c, k, sum); n     for (int j = 0; j < k; j++) { n       sum += (long long)cnt[c][j] * cnt[v][k - j - 1]; n     } n     for (int j = 0; j < k; j++) { n       cnt[v][j + 1] += cnt[c][j]; n     } n   } n   cnt[v][0] = 1; n   sum += (long long)cnt[v][0] * cnt[v][k]; n } n int main() { n   int n, k, a, b; n   cin >> n >> k; n   for (int i = 0; i < n - 1; i++) { n     cin >> a >> b; n     a--, b--; n     G[a].push_back(b); n     G[b].push_back(a); n   } n   init(n); n   long long res = 0; n   calc(0, k, res); n   cout << res << endl; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n struct P { n   int x, y; n   bool operator<(const P &p) { n     if (x != p.x) n       return x < p.x; n     else n       return y < p.y; n   } n }; n int main() { n   int T; n   cin >> T; n   for (int t = 0; t < T; ++t) { n     int n; n     cin >> n; n     int bsz = n / 3; n     vector<int> buf(bsz); n     for (int i = 0; i < n / 3; ++i) { n       cout <<  ?   << 3 * i + 1 <<     << 3 * i + 2 <<     << 3 * i + 3 << endl; n       cout.flush(); n       cin >> buf[i]; n       if (buf[i] == -1) { n         break; n       } n     } n     int ind0, ind1; n     for (int i = 0; i < bsz; ++i) { n       int indl = i; n       int indr = (i + 1) % bsz; n       if (buf[indl] != buf[indr]) { n         vector<int> tbuf(6); n         tbuf[0] = buf[indl]; n         for (int j = 1; j <= 5; ++j) { n           int v1 = (3 * indl + j) % n + 1; n           int v2 = (3 * indl + j + 1) % n + 1; n           int v3 = (3 * indl + j + 2) % n + 1; n           cout <<  ?   << v1 <<     << v2 <<     << v3 << endl; n           cout.flush(); n           cin >> tbuf[j]; n           if (tbuf[j] == -1) { n             break; n           } n           if (tbuf[j - 1] != tbuf[j]) { n             if (tbuf[j - 1] == 0) { n               ind0 = (3 * indl + j - 1) % n + 1; n               ind1 = v3; n             } else { n               ind1 = (3 * indl + j - 1) % n + 1; n               ind0 = v3; n             } n             break; n           } n         } n         break; n       } n     } n     vector<int> mapping(n); n     mapping[ind1 - 1] = 1; n     int tmp; n     for (int i = 0; i < bsz; ++i) { n       int v1 = 3 * i + 1; n       int v2 = 3 * i + 2; n       int v3 = 3 * i + 3; n       if (buf[i] == 0) { n         if (v1 == ind1) { n           cout <<  ?   << ind1 <<     << ind0 <<     << v2 << endl; n         } else if (v2 == ind1) { n           cout <<  ?   << ind1 <<     << v1 <<     << ind0 << endl; n         } else { n           cout <<  ?   << ind1 <<     << v1 <<     << v2 << endl; n         } n         cout.flush(); n         cin >> tmp; n         if (tmp == 0) { n           mapping[v1 - 1] = 0; n           mapping[v2 - 1] = 0; n           if (v3 == ind0) { n             tmp = 0; n           } else if (v3 == ind1) { n             tmp = 1; n           } else { n             cout <<  ?   << ind0 <<     << ind1 <<     << v3 << endl; n             cout.flush(); n             cin >> tmp; n           } n           mapping[v3 - 1] = tmp; n         } else { n           mapping[v3 - 1] = 0; n           if (ind0 == v1) { n             tmp = 0; n           } else if (ind1 == v1) { n             tmp = 1; n           } else { n             cout <<  ?   << ind0 <<     << ind1 <<     << v1 << endl; n             cout.flush(); n             cin >> tmp; n           } n           mapping[v1 - 1] = tmp; n           mapping[v2 - 1] = 1 - tmp; n         } n       } else { n         if (v1 == ind0) { n           cout <<  ?   << ind0 <<     << ind1 <<     << v2 << endl; n         } else if (v2 == ind0) { n           cout <<  ?   << ind0 <<     << v1 <<     << ind1 << endl; n         } else { n           cout <<  ?   << ind0 <<     << v1 <<     << v2 << endl; n         } n         cout.flush(); n         cin >> tmp; n         if (tmp == 1) { n           mapping[v1 - 1] = 1; n           mapping[v2 - 1] = 1; n           if (v3 == ind0) { n             tmp = 0; n           } else if (v3 == ind1) { n             tmp = 1; n           } else { n             cout <<  ?   << ind0 <<     << ind1 <<     << v3 << endl; n             cout.flush(); n             cin >> tmp; n           } n           mapping[v3 - 1] = tmp; n         } else { n           mapping[v3 - 1] = 1; n           if (v1 == ind0) { n             tmp = 0; n           } else if (v1 == ind1) { n             tmp = 1; n           } else { n             cout <<  ?   << ind0 <<     << ind1 <<     << v1 << endl; n             cout.flush(); n             cin >> tmp; n           } n           mapping[v1 - 1] = tmp; n           mapping[v2 - 1] = 1 - tmp; n         } n       } n     } n     vector<int> fake; n     for (int i = 0; i < n; ++i) { n       if (mapping[i] == 0) { n         fake.push_back(i + 1); n       } n     } n     cout <<  !   << fake.size(); n     for (int i = 0; i < fake.size(); ++i) { n       cout <<     << fake[i]; n     } n     cout << endl; n     cout.flush(); n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int main() { n   int n, k, a, b, c, d; n   scanf( %d%d%d%d%d%d , &n, &k, &a, &b, &c, &d); n   if (n <= 4 || k < n + 1) { n     puts( -1 ); n     return 0; n   } n   printf( %d %d , a, c); n   for (int i = 1; i <= n; i++) { n     if (i != a && i != b && i != c && i != d) printf(  %d , i); n   } n   printf(  %d %d n , d, b); n   printf( %d %d , c, a); n   for (int i = 1; i <= n; i++) { n     if (i != a && i != b && i != c && i != d) printf(  %d , i); n   } n   printf(  %d %d n , b, d); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int mod = 1e9 + 7; n const int N = 2e5 + 10; n const long long inf = 1e18; n const int maxm = 1005; n vector<vector<char>> matrix(maxm, vector<char>(maxm)); n struct event { n   int x, y, size; n }; n int dx[] = {0, 0, 1, -1}; n int dy[] = {-1, 1, 0, 0}; n class even { n  public: n   int a, b, c; n }; n class evenl { n  public: n   int a, b, c, ind; n }; n struct myComp { n   constexpr bool operator()(evenl f, evenl s) const noexcept { n     int z = f.b - f.a; n     int z2 = s.b - s.a; n     z -= f.c; n     z2 -= s.c; n     return z < z2; n   } n }; n long long poww(long long a, long long b, long long m) { n   if (b == 0) return 1ll; n   if (b % 2 == 1) return a * poww(a, b - 1, m) % m; n   long long rs = poww(a, b / 2, m); n   rs = rs * rs % m; n   return rs; n } n long long fact[N]; n long long ncr(long long n, long long r) { n   long long num = fact[n]; n   long long deno = fact[n - r] * fact[r] % mod; n   deno = poww(deno, mod - 2, mod); n   num = num * deno; n   num = num % mod; n   return num; n } n long long convert(long long a, long long b) { n   string s; n   while (a > 0) { n     long long p = a % b; n     s += p +  0 ; n     a = a / b; n   } n   reverse(s.begin(), s.end()); n   long long res = stoi(s); n   return res; n } n long long make(long long a, long long b, long long c) { n   while (a < b) a *= c; n   return a % b; n } n long long frog_jump(long long pos, long long n) { n   while (pos % 2 == 0) { n     pos = pos + (n - pos / 2); n   } n   return (pos + 1) / 2; n } n void solve() { n   long long n, q; n   cin >> n >> q; n   for (int i = 0; i < q; i++) { n     long long x; n     cin >> x; n     if (x % 2 != 0) { n       cout << (x + 1) / 2 <<   n ; n       continue; n     } n     long long z = frog_jump(x, n); n     cout << z <<   n ; n   } n } n int main() { n   ios_base::sync_with_stdio(0); n   cin.tie(0); n   cout.tie(0); n   solve(); n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n double aa[12]; n int sign[12]; n int compare(const void *a, const void *b) { n   int i = *(int *)a; n   int j = *(int *)b; n   if (sign[i] != sign[j]) return sign[j] - sign[i]; n   if (sign[i] == 0) return i - j; n   return aa[i] == aa[j] ? i - j : aa[i] > aa[j] ? -sign[i] : sign[i]; n } n void power(int i, double x, double y, double z) { n   if (x == 1) n     sign[i] = 0; n   else if (x > 1) { n     sign[i] = 1; n     aa[i] = z * log(y) + log(log(x)); n   } else { n     sign[i] = -1; n     aa[i] = z * log(y) + log(-log(x)); n   } n } n void power_(int i, double x, double yz) { n   if (x == 1) n     sign[i] = 0; n   else if (x > 1) { n     sign[i] = 1; n     aa[i] = log(yz) + log(log(x)); n   } else { n     sign[i] = -1; n     aa[i] = log(yz) + log(-log(x)); n   } n } n int main() { n   static char ss[12][16] = { x^y^z ,  x^z^y ,  (x^y)^z ,  (x^z)^y , n                              y^x^z ,  y^z^x ,  (y^x)^z ,  (y^z)^x , n                              z^x^y ,  z^y^x ,  (z^x)^y ,  (z^y)^x }; n   static int ii[12]; n   double x, y, z; n   int i; n   scanf( %lf%lf%lf , &x, &y, &z); n   power(0, x, y, z); n   power(1, x, z, y); n   power_(2, x, y * z); n   power_(3, x, y * z); n   power(4, y, x, z); n   power(5, y, z, x); n   power_(6, y, x * z); n   power_(7, y, x * z); n   power(8, z, x, y); n   power(9, z, y, x); n   power_(10, z, x * y); n   power_(11, z, x * y); n   for (i = 0; i < 12; i++) ii[i] = i; n   qsort(ii, 12, sizeof *ii, compare); n   printf( %s n , ss[ii[0]]); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int main() { n   ios_base::sync_with_stdio(false); n   cin.tie(nullptr); n   int n, m; n   cin >> n >> m; n   vector<int> a(n); n   for (int i = 0; i < n; ++i) { n     cin >> a[i]; n   } n   vector<int> rightInc(n), leftInc(n); n   int end = 0, cur_count = 1; n   for (int i = 0; i < n; ++i) { n     if (end < i) { n       end = i, cur_count = 1; n     } n     while (end + 1 < n && a[end + 1] >= a[end]) { n       end++, cur_count++; n     } n     rightInc[i] = end - i + 1, cur_count--; n   } n   reverse(a.begin(), a.end()); n   end = 0, cur_count = 1; n   for (int i = 0; i < n; ++i) { n     if (end < i) { n       end = i, cur_count = 1; n     } n     while (end + 1 < n && a[end + 1] >= a[end]) { n       end++, cur_count++; n     } n     leftInc[i] = end - i + 1, cur_count--; n   } n   reverse(leftInc.begin(), leftInc.end()); n   while (m--) { n     int l, r; n     cin >> l >> r; n     --l, --r; n     if (rightInc[l] + leftInc[r] >= r - l + 1) n       cout <<  Yes n ; n     else n       cout <<  No n ; n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int maxn = 3e6 + 7; n const int INF = 0x7fffffff; n int n, m; n struct DATA { n   int strid; n   int index; n }; n vector<DATA> vec; n string str[maxn]; n char ans[maxn]; n bool cmp(DATA a, DATA b) { return a.index < b.index; } n int main() { n   while (cin >> n) { n     memset(ans, 0, sizeof(ans)); n     vec.clear(); n     for (int i = 0; i < n; i++) { n       int num; n       cin >> str[i]; n       scanf( %d , &num); n       for (int j = 0; j < num; j++) { n         int k; n         scanf( %d , &k); n         k--; n         DATA t; n         t.strid = i; n         t.index = k; n         vec.push_back(t); n       } n     } n     int last = -1; n     sort(vec.begin(), vec.end(), cmp); n     for (int i = 0; i < vec.size(); i++) { n       for (int j = max(last + 1, vec[i].index); n            j < vec[i].index + str[vec[i].strid].size(); j++) { n         ans[j] = str[vec[i].strid][j - vec[i].index]; n         last = max(last, j); n       } n     } n     for (int i = 0; i <= last; i++) { n       if (ans[i] != 0) n         printf( %c , ans[i]); n       else { n         printf( a ); n       } n     } n     puts(  ); n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int main() { n   int num[3]; n   cin >> num[0] >> num[1] >> num[2]; n   char c1 =  * , c2 =  * ; n   if (num[0] == 1) c1 =  + ; n   if (num[2] == 1) c2 =  + ; n   if (num[1] == 1 && num[0] != 1 && num[2] != 1) { n     cout << max(num[0] * (num[1] + num[2]), (num[0] + num[1]) * num[2]); n     return 0; n   } n   if (c1 ==  +  && c2 ==  * ) { n     cout << ((num[0] + num[1]) * num[2]); n     return 0; n   } n   if (c2 ==  +  && c1 ==  * ) { n     cout << (num[0] * (num[1] + num[2])); n     return 0; n   } n   if (c1 ==  +  && c2 ==  + ) { n     cout << (num[0] + num[1] + num[2]); n     return 0; n   } n   cout << (num[0] * num[1] * num[2]); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int main() { n   int n; n   scanf( %d , &n); n   long long int arr[100]; n   for (int i = 0; i < n; i++) cin >> arr[i]; n   long long int cnt[5]; n   long long int p[5]; n   for (int i = 0; i < 5; i++) cin >> p[i]; n   long long int min = 1000000009; n   for (int i = 0; i < 5; i++) n     if (p[i] < min) min = p[i]; n   for (int i = 0; i < 5; i++) cnt[i] = 0; n   long long int ps = 0; n   for (int i = 0; i < n; i++) { n     ps = ps + arr[i]; n     while (ps >= min) { n       long long int pp; n       for (int j = 4; j >= 0; j--) { n         if (ps < min) break; n         pp = ps / p[j]; n         ps = ps - pp * p[j]; n         cnt[j] += pp; n       } n     } n   } n   for (int i = 0; i < 5; i++) cout << cnt[i] <<    ; n   cout <<   n  << ps << endl; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n long long t, n, m, cap, lis[200500], high, low; n long long f(long long x) { n   long long res = 0, cnt = 0, buf = 0; n   for (int i = (0); i <= ((int)(n)-1); i++) n     if (lis[i] <= x) { n       if (!cnt) { n         res += buf; n         buf = 0; n       } n       cnt++; n       buf += lis[i]; n       res += lis[i]; n       if (cnt == m) { n         cnt = 0; n       } n     } n   return res; n } n long long g(long long x) { n   long long res = 0, task = 0, cnt = 0, buf = 0; n   for (int i = (0); i <= ((int)(n)-1); i++) n     if (lis[i] <= x) { n       if (!cnt) { n         res += buf; n         buf = 0; n       } n       if (res + lis[i] > cap) break; n       res += lis[i]; n       cnt++; n       buf += lis[i]; n       task++; n       if (cnt == m) { n         cnt = 0; n       } n     } n   return task; n } n int main() { n   ios::sync_with_stdio(0); n   cin >> t; n   while (t--) { n     cin >> n >> m >> cap; n     for (int i = (0); i <= ((int)(n)-1); i++) cin >> lis[i]; n     high = cap, low = 1; n     while (high > low) { n       long long chs = (high + low) / 2; n       if (f(chs) > cap) n         high = chs; n       else n         low = chs + 1; n     } n     long long gh = g(high), gh1 = g(high - 1); n     if (gh > gh1 || high == 1) n       cout << gh <<     << high << endl; n     else n       cout << gh1 <<     << high - 1 << endl; n   } n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n long long int dp[2010][2010]; n long long int a[2010]; n long long int b[2010]; n int main() { n   int n; n   cin >> n; n   for (int i = 1; i <= n; i++) { n     cin >> a[i] >> b[i]; n   } n   for (int i = 0; i <= 2000; i++) { n     for (int j = 0; j <= 2000; j++) { n       dp[i][j] = 10000000000000000; n     } n   } n   dp[0][0] = 0; n   for (int i = 1; i <= n; i++) { n     long long int o = a[i] + 1; n     for (int j = 0; j <= n; j++) { n       o = a[i] + 1; n       if (j == 0) { n         dp[i][j] = 0; n       } n       if (o >= j) { n         o = j; n       } n       if (j >= o) { n         dp[i][j] = min(b[i] + dp[i - 1][j - (o)], dp[i][j]); n       } n       dp[i][j] = min(dp[i][j], dp[i - 1][j]); n     } n   } n   cout << dp[n][n] << endl; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n const long long int MOD = 1e9 + 7; n const long long int INF = 1011111111; n const long long int LLINF = 1000111000111000111LL; n const long double EPS = 1e-10; n const long double PI = 3.14159265358979323; n using namespace std; n long long int power(int x, int n) { n   if (n == 0) n     return 1; n   else if (n % 2 == 0) n     return power((x * x), n / 2); n   else n     return x * power((x * x), (n - 1) / 2); n } n long long int dp[5005][5005]; n int main() { n   ios_base::sync_with_stdio(false); n   cin.tie(NULL); n   cout.tie(NULL); n   long long int n, m, i, j, k; n   cin >> n >> k; n   vector<long long int> v(n); n   for (i = 0; i < n; i++) cin >> v[i]; n   sort(v.begin(), v.end()); n   vector<pair<pair<long long int, long long int>, long long int> > check; n   vector<long long int>::iterator it; n   for (i = 0; i < n; i++) { n     long long int idx; n     it = upper_bound(v.begin(), v.end(), v[i] + 5); n     if (it == v.end()) n       idx = n - 1; n     else { n       idx = it - v.begin(); n       idx--; n     } n     check.push_back({{i, idx}, idx - i + 1}); n   } n   long long int ans = 0; n   for (i = 0; i < n; i++) { n     for (j = 0; j <= k; j++) { n       dp[i + 1][j] = max(dp[i + 1][j], dp[i][j]); n       if (j + 1 <= k) n         dp[i + check[i].second][j + 1] = n             max(dp[i + check[i].second][j + 1], dp[i][j] + check[i].second); n     } n   } n   cout << dp[n][k]; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int N = 2e5 + 5, oo = 0x3f3f3f3f, mod = 1e9 + 7; n int a[N], n, tree[N], srt[N], ans[N]; n void update(int a, int val) { n   while (a <= n) { n     tree[a] = max(val, tree[a]); n     a += a & -a; n   } n } n int query(int a) { n   int mx = 0; n   while (a > 0) { n     mx = max(tree[a], mx); n     a -= a & -a; n   } n   return mx; n } n int main() { n   scanf( %d , &n); n   for (int i = 1; i <= n; i++) { n     scanf( %d , a + i); n     srt[i] = a[i]; n   } n   sort(srt + 1, srt + n + 1); n   for (int i = n; i >= 1; i--) { n     int idx = lower_bound(srt + 1, srt + n + 1, a[i]) - srt; n     update(idx, i); n     ans[i] = query(idx - 1); n     if (ans[i] == 0) n       ans[i]--; n     else n       ans[i] -= i + 1; n   } n   for (int i = 1; i <= n; i++) printf( %d  , ans[i]); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int maxn = 2e5 + 9; n int n, maxx; n struct p { n   int lei, num, x; n } a[maxn]; n int da[maxn], b[maxn], vis[maxn]; n int main() { n   cin >> n; n   for (int i = 1; i <= n; i++) cin >> b[i]; n   int w; n   cin >> w; n   for (int i = 1; i <= w; i++) { n     cin >> a[i].lei; n     if (a[i].lei == 1) { n       cin >> a[i].num >> a[i].x; n       vis[a[i].num] = i; n       b[a[i].num] = a[i].x; n     } else { n       cin >> a[i].x; n       maxx = max(maxx, a[i].x); n     } n   } n   for (int i = w; i >= 1; i--) { n     if (a[i].lei == 1) n       da[i] = da[i + 1]; n     else n       da[i] = max(da[i + 1], a[i].x); n   } n   for (int i = 1; i <= n; i++) { n     if (vis[i] == 0) n       cout << max(b[i], maxx) <<    ; n     else { n       int xu = vis[i]; n       cout << max(b[i], da[xu]) <<    ; n     } n   } n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n const int INF = 0x3f3f3f3f; n const int N = 579; n const long long P = 1000000007; n int n, b[N]; n long long d[N][N]; n long long solve(int l, int r) { n   if (l == r) return 1; n   static bool used[N][N]; n   static long long ans[N][N]; n   if (used[l][r]) return ans[l][r]; n   used[l][r] = true; n   ++l; n   ++r; n   d[l][0] = 1; n   for (int i = 0; i < r - l; ++i) { n     if (d[l][i + 1] != -1) continue; n     int c = l + i; n     d[l][i + 1] = 0; n     for (int j = 0; j <= i; ++j) n       if (b[j + l] < b[c + 1]) (d[l][i + 1] += d[l][j] * solve(j + l, c)) %= P; n   } n   long long res = 0; n   for (int j = 0; j <= r - l - 1; ++j) n     (res += d[l][j] * solve(j + l, r - 1)) %= P; n   --l; n   --r; n   return ans[l][r] = res; n } n int main() { n   memset(d, -1, sizeof(d)); n   std::cin >> n; n   for (int i = 0; i < n; ++i) std::cin >> b[i]; n   if (b[0] == 1) n     std::cout << solve(0, n - 1) <<   n ; n   else n     std::cout << 0 <<   n ; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int main() { n   int a[4]; n   for (int i = 0; i < 4; i++) cin >> a[i]; n   int sumtotal = a[0] + a[1] + a[2] + a[3]; n   if (sumtotal % 2 != 0) { n     cout <<  NO ; n     return 0; n   } n   for (int i = 0; i < 4; i++) { n     if (a[i] == sumtotal - a[i]) { n       cout <<  YES ; n       return 0; n     } else n       for (int j = 0; j < 4; j++) { n         if (i != j) n           if ((a[i] + a[j]) == (sumtotal - a[i] - a[j])) { n             cout <<  YES ; n             return 0; n           } n       } n   } n   cout <<  NO ; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n vector<pair<int, double>> ans[52]; n int main() { n   int n, w, m; n   cin >> n >> w >> m; n   double s = (n * w) / (m * 1.0), c = w, b = 1, k = 0; n   for (int i = 0; i < m; i++) { n     double ne = s; n     while (1) { n       if (ne + 10e-7 > c) { n         ans[i].push_back(make_pair(b, c)); n         ne -= c; n         c = w; n         b++; n         if (++k > 2) { n           cout <<  NO ; n           return 0; n         } n         k = 0; n         if (abs(ne) < 10e-7) break; n       } else { n         ans[i].push_back(make_pair(b, ne)); n         c -= ne; n         k++; n         break; n       } n     } n   } n   cout <<  YES n ; n   for (int i = 0; i < m; i++) { n     for (auto it : ans[i]) n       cout << fixed << setprecision(0) << it.first <<     << setprecision(6) n            << it.second <<    ; n     cout <<   n ; n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n void quickly_quickly_kro() { n   long long n; n   cin >> n; n   vector<long long> v(n); n   for (long long i = 0; i < n; i++) cin >> v[i]; n   ; n   map<long long, long long> M, N, I; n   for (long long i = 0; i < n; i++) { n     if (v[i] != 0) n       M[v[i]]++; n     else n       I[i]++; n   } n   for (long long i = 1; i < n + 1; i++) { n     if (M[i] == 0) { n       N[i]++; n     } n   } n   for (auto k : I) { n     if ((N.find(k.first + 1) != N.end())) { n       auto it = N.find(k.first + 1); n       if (it != N.begin()) n         it--; n       else n         it++; n       v[k.first] = it->first; n       N.erase(it); n     } n   } n   for (long long i = 0; i < n; i++) { n     if (v[i] == 0) { n       auto it = N.begin(); n       pair<long long, long long> p = *it; n       v[i] = p.first; n       N.erase(it); n     } n   } n   for (long long i = 0; i < n; i++) cout << v[i] <<    ; n } n signed main() { n   std::ios_base::sync_with_stdio(false); n   cin.tie(0); n   cout.tie(0); n   long long t; n   t = 1; n   while (t--) { n     quickly_quickly_kro(); n     cout <<   n ; n     ; n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n struct HashMap { n   vector<pair<int, int> > g[1000007]; n   void ins(int x, int y) { n     int id = ((long long)x * 1000000007 + y) % 1000007; n     g[id].push_back(make_pair(x, y)); n   } n   bool get(int x, int y) { n     int id = ((long long)x * 1000000007 + y) % 1000007; n     for (int i = 0; i < g[id].size(); i++) n       if (g[id][i].first == x && g[id][i].second == y) return true; n     return false; n   } n }; n int n; n HashMap mp; n vector<int> row[100011]; n vector<int> rateB; n int main() { n   scanf( %d , &n); n   for (int i = 1; i <= n; i++) { n     int x, y; n     scanf( %d%d , &x, &y); n     row[y].push_back(x); n     mp.ins(x, y); n   } n   int di = (int)sqrt(n); n   long long int ans = 0; n   for (int a = 0; a <= 100000; a++) { n     if (row[a].size() != 0) { n       sort(row[a].begin(), row[a].end()); n       if (row[a].size() <= di) { n         for (int i = 0; i < row[a].size(); i++) { n           for (int j = i + 1; j < row[a].size(); j++) { n             int x1 = row[a][i]; n             int x2 = row[a][j]; n             int dis = x2 - x1; n             if (mp.get(x1, a + dis) && mp.get(x2, a + dis)) ans++; n             if (a - dis >= 0 && row[a - dis].size() > di && n                 (mp.get(x1, a - dis) && mp.get(x2, a - dis))) n               ans++; n           } n         } n       } else n         rateB.push_back(a); n     } n   } n   for (int i = 0; i < rateB.size(); i++) { n     for (int j = i + 1; j < rateB.size(); j++) { n       int a = rateB[i]; n       int b = rateB[j]; n       int u = 0, p = 0; n       int dis = b - a; n       while (u < row[a].size() && p < row[b].size()) { n         if (row[a][u] < row[b][p]) n           u++; n         else if (row[a][u] > row[b][p]) n           p++; n         else { n           int x1 = row[a][u]; n           if (mp.get(x1 + dis, a) && mp.get(x1 + dis, b)) ans++; n           u++; n           p++; n         } n       } n     } n   } n   printf( %I64d n , ans); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int inf = (int)1.01e9; n const double eps = 1e-9; n const int maxn = (int)2e5 + 10; n set<int> S; n int main() { n   int n, k, a; n   scanf( %d%d%d , &n, &k, &a); n   int cur = (n + 1) / (a + 1); n   assert(cur >= k); n   int m; n   scanf( %d , &m); n   for (int i = 0; (i) < (m); ++i) { n     int x; n     scanf( %d , &x); n     set<int>::iterator it = S.lower_bound(x); n     int left = 0; n     int right = n + 1; n     if (it != S.end()) { n       right = *it; n     } n     if (it != S.begin()) { n       --it; n       left = *it; n     } n     cur -= (right - left) / (a + 1); n     cur += (x - left) / (a + 1); n     cur += (right - x) / (a + 1); n     if (cur < k) { n       printf( %d n , i + 1); n       return 0; n     } n     S.insert(x); n   } n   printf( -1 n ); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n bool has[200009]; n int left[200009]; n int main() { n   int Q; n   cin >> Q; n   for (int q = 0; q < Q; q++) { n     int N; n     cin >> N; n     vector<int> v; n     for (int i = 0; i < N; i++) { n       int a; n       cin >> a; n       v.push_back(a); n     } n     sort(v.begin(), v.end()); n     reverse(v.begin(), v.end()); n     int res = v[0]; n     vector<int> w; n     vector<int> t; n     for (int i = 1; i < v.size(); i++) n       if (v[i] != v[i - 1]) { n         if (v[0] % v[i] != 0) n           w.push_back(v[i]); n         else n           t.push_back(v[i]); n       } n     if (w.size() > 0) { n       res += w[0]; n       for (int i = 1; i < w.size(); i++) n         if (w[0] % w[i] != 0) { n           res += w[i]; n           break; n         } n     } n     if (t.size() >= 3 && t[0] + t[1] + t[2] > res) { n       if (t[0] % t[1] != 0 && t[1] % t[2] != 0 && t[0] % t[2] != 0) n         res = t[0] + t[1] + t[2]; n     } n     if (t.size() >= 4 && t[0] + t[1] + t[3] > res) { n       if (t[0] % t[1] != 0 && t[1] % t[3] != 0 && t[0] % t[3] != 0) n         res = t[0] + t[1] + t[3]; n     } n     cout << res <<   n ; n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n struct Segment { n   int l, r, x, ls, rs, fa; n } seg[2000100]; n int n, k, p[100100], cnt, pnt, b[2000100], w, ans[100100], res; n int Dfs(int &id, int l, int r) { n   id = ++cnt; n   seg[id].l = l, seg[id].r = r; n   seg[id].x = 1; n   if (r - l == 1) return 1; n   int mid = (l + r) >> 1; n   seg[id].x += Dfs(seg[id].ls, l, mid); n   seg[id].x += Dfs(seg[id].rs, mid, r); n   return seg[id].x; n } n void Vis(int x) { n   if (!x) return; n   b[x] = 1; n   Vis(seg[x].ls); n   Vis(seg[x].rs); n } n bool cmp(int x, int y) { return seg[x].l < seg[y].l; } n void Solve(int x) { n   if (!x) return; n   if (b[x]) { n     for (int i = seg[x].l; i < seg[x].r; i++) ans[i] = res++; n     return; n   } n   Solve(seg[x].rs); n   Solve(seg[x].ls); n } n int main() { n   scanf( %d%d , &n, &k); n   Dfs(w, 0, n); n   k = seg[1].x - k; n   for (int i = 1; i <= cnt; i++) n     if (!b[i]) { n       if (k >= seg[i].x - 1 && seg[i].x > 1) { n         k -= seg[i].x - 1; n         p[++pnt] = i; n         Vis(i); n         if (!k) break; n       } n     } n   if (k) n     printf( -1 ); n   else { n     res = 1; n     Solve(1); n     for (int i = n - 1; i >= 0; i--) ans[i] = ans[i] ? ans[i] : res++; n     for (int i = 0; i < n; i++) printf( %d  , ans[i]); n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n string s[1100]; n int vis[1100]; n int num[100]; n int main() { n   ios::sync_with_stdio(false); n   int n, len, k; n   cin >> n >> len >> k; n   string st; n   cin >> st; n   for (int i = 0; i < st.size(); i++) { n     num[st[i] -  a ]++; n   } n   int l = 0, r = 25; n   for (int i = k + 1; i <= n; i++) { n     for (int j = 1; j <= len; j++) { n       while (!num[r] && r > l) r--; n       s[i] += (char)(r +  a ); n       num[r]--; n     } n   } n   int now = 0; n   int pos = 0; n   while (1) { n     for (int i = 1; i <= k; i++) { n       if (vis[i]) continue; n       if (pos >= 1 && i != k && (int)(s[i][pos - 1] -  a ) < now) { n         for (int j = pos + 1; j <= len; j++) { n           while (!num[r] && r > l) r--; n           s[i] += (char)(r +  a ); n           num[r]--; n         } n         vis[i] = 1; n         continue; n       } n       while (!num[l] && r > l) l++; n       s[i] += (char)(l +  a ); n       num[l]--; n       if (i == k) { n         now = l; n       } n     } n     pos++; n     if (pos == len) break; n   } n   sort(s + 1, s + 1 + n); n   for (int i = 1; i <= n; i++) cout << s[i] << endl; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int T, n, m, nw, a[110][110], id[110][110], pos[110], p[110]; n char ch; n bool cmp(int i, int j) { return a[m][i] < a[m][j]; } n queue<int> q; n void find(int x) { n   p[x] = 0; n   int y = id[x][pos[x]]; n   pos[x]--; n   if (!p[y]) n     p[y] = x, p[x] = y; n   else if (a[y][x] > a[y][p[y]]) { n     p[p[y]] = 0, q.push(p[y]); n     p[y] = x, p[x] = y; n   } n   if (!p[x]) q.push(x); n } n void work() { n   for (int i = 1; i <= 2 * n; i++) { n     for (int j = 1; j <= n; j++) id[i][j] = (i <= n) * n + j; n     m = i; n     sort(id[i] + 1, id[i] + n + 1, cmp); n     p[i] = 0; n   } n   for (int i = 1; i <= n; i++) pos[i] = n, q.push(i); n   while (!q.empty()) { n     int u = q.front(); n     q.pop(); n     find(u); n   } n   for (int i = 1; i <= n; i++) assert(p[i]); n   for (int i = 1; i <= n; i++) n     for (int j = 1; j <= n; j++) n       assert(!(a[p[i]][i] < a[p[i]][j] && a[j][p[i]] > a[j][p[j]])); n } n void solve() { n   bool falg = 0; n   scanf( %d , &n); n   memset(a, 0, sizeof(a)), memset(id, 0, sizeof(id)); n   for (int i = 1; i <= n; i++) n     for (int j = n + 1; j <= 2 * n; j++) n       scanf( %d , &a[i][j]), a[j][i] = -a[i][j]; n   puts( B ), fflush(stdout); n   scanf(  %c%d , &ch, &nw); n   if (ch ==  I ) falg ^= 1; n   if (nw > n) falg ^= 1; n   if (falg) n     for (int i = 1; i <= 2 * n; i++) n       for (int j = 1; j <= 2 * n; j++) a[i][j] = -a[i][j]; n   work(); n   printf( %d n , p[nw]), fflush(stdout); n   while (~scanf( %d , &nw)) { n     if (nw == -1) return; n     printf( %d n , p[nw]), fflush(stdout); n   } n } n int main() { n   scanf( %d , &T); n   while (T--) solve(); n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int N = 2e5 + 9; n vector<int> getBorder(const string str) { n   int n = str.size(); n   vector<int> border(n, -1); n   for (int i = 1, j = -1; i < n; i++) { n     while (j >= 0 && str[i] != str[j + 1]) { n       j = border[j]; n     } n     if (str[i] == str[j + 1]) j++; n     border[i] = j; n   } n   return border; n } n int matchPattern(string txt, string pat, const vector<int> border) { n   int freq = 0; n   for (int i = 0, j = -1; i < (int)txt.size(); i++) { n     while (j >= 0 && txt[i] != pat[j + 1]) { n       j = border[j]; n     } n     if (txt[i] == pat[j + 1]) { n       j++; n     } n     if (j + 1 == (int)pat.size()) { n       freq++; n       j = border[j]; n     } n   } n   return freq; n } n string cut(string s, int p, bool pref = true) { n   if (!pref) { n     reverse(s.begin(), s.end()); n   } n   while ((int)s.size() >= p) s.pop_back(); n   if (!pref) { n     reverse(s.begin(), s.end()); n   } n   return s; n } n const int ms = 210; n string pref[ms], suf[ms]; n long long trans[ms]; n int bk = 14; n long long getFreq(int n, string pat, long long k) { n   std::vector<long long> f(n + 1, 0); n   if (pat ==  0 ) f[0]++; n   if (pat ==  1 ) f[1]++; n   auto border = getBorder(pat); n   for (int i = 2; i <= n; i++) { n     long long cur = trans[i - 2]; n     if (i < bk + 4) { n       string curString = cut(suf[i - 2], (int)pat.size(), false) + n                          cut(pref[i - 1], (int)pat.size()); n       cur = matchPattern(curString, pat, border); n     } n     f[i] = f[i - 1] + f[i - 2] + cur; n     if (f[i] > k) return k + 1; n     trans[i] = cur; n   } n   return min(f[n], k + 1); n } n int main() { n   pref[0] = suf[0] =  0 ; n   pref[1] = suf[1] =  1 ; n   for (int i = 2; i < ms; i++) { n     pref[i] = cut(pref[i - 2] + pref[i - 1], ms); n     suf[i] = cut(suf[i - 2] + suf[i - 1], ms, false); n   } n   int n, m; n   long long k; n   cin >> n >> k >> m; n   if (n == 0) { n     cout <<  0 n ; n     return 0; n   } n   if (n == 1) { n     cout <<  1 n ; n     return 0; n   } n   string ans; n   k--; n   while (k >= 0 && (int)ans.size() < m) { n     if (ans.size() > 0 && n         suf[n].substr(suf[n].size() - ans.size(), ans.size()) == ans) { n       k--; n     } n     if (k < 0) break; n     ans +=  0 ; n     long long got = getFreq(n, ans, k); n     if (got <= k) { n       ans.back() =  1 ; n       k -= got; n     } n   } n   cout << ans << endl; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int tag[10]; n int main() { n   string a, b; n   while (cin >> a >> b) { n     memset(tag, 0, sizeof(tag)); n     ; n     int len = a.size(); n     int len1 = b.size(); n     for (int i = 0; i < len1; i++) { n       int num = b[i] -  0 ; n       tag[num]++; n     } n     for (int i = 0; i < len; i++) { n       int p = a[i] -  0 ; n       int j = 9; n       while (j > p) { n         if (!tag[j]) j--; n         if (tag[j] && j > p) { n           a[i] = j +  0 ; n           tag[j]--; n           break; n         } n       } n     } n     for (int i = 0; i < len; i++) cout << a[i]; n     cout << endl; n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const long long mod = 1000000007; n int n, k; n bool d[1001]; n long long dp[1001][2][1001]; n int cnt[10001]; n long long DP(int i, bool f, int j) { n   if (i == n) return cnt[j] == k; n   if (dp[i][f][j] != -1) return dp[i][f][j]; n   long long ret = 0; n   if (d[i] == 1) n     ret = (ret + DP(i + 1, f, j + 1)) % mod; n   else if (d[i] == 0 and f) n     ret = (ret + DP(i + 1, f, j + 1)) % mod; n   ret = (ret + DP(i + 1, f | (d[i] == 1), j)) % mod; n   return dp[i][f][j] = ret; n } n int main() { n   for (int i = 1; i <= 1000; i++) { n     cnt[i] = 1 + cnt[__builtin_popcount(i)]; n   } n   string s; n   cin >> s; n   n = s.size(); n   cin >> k; n   int i = 0; n   for (char c : s) d[i++] = c -  0 ; n   memset(dp, -1, sizeof dp); n   cout << DP(0, 0, 0) - (k == 1); n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const long long int INF = 1e18, N = 2e6 + 3, BASE = 130; n int main() { n   long long int n, k; n   cin >> n >> k; n   vector<int> arr(n), up(n); n   for (int i = 0; i < n; i++) { n     cin >> arr[i]; n   } n   for (int i = n - 2; i >= 0; i--) { n     if (arr[i + 1] == 1) { n       up[i] = up[i + 1] + 1; n     } else { n       up[i] = 0; n     } n   } n   long long int ans = 0; n   for (int i = 0; i < n; i++) { n     int ind = i; n     long long int p = 1; n     long long int sum = 0; n     int cnt = 0; n     while (ind < n && cnt <= 20) { n       if (p > INF / arr[ind]) { n         break; n       } n       p *= arr[ind]; n       sum += arr[ind]; n       cnt++; n       if (p % sum == 0 && p / sum == k) { n         ans++; n       } n       if (up[ind]) { n         if (p % k == 0) { n           long long int num = p / k; n           if (sum + 1 <= num && num <= sum + up[ind]) { n             ans++; n           } n         } n       } n       sum += up[ind]; n       ind = ind + 1 + up[ind]; n     } n   } n   cout << ans; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n void PLAY() { n   cout << fixed << setprecision(10); n   ios::sync_with_stdio(0); n   cin.tie(0); n   cout.tie(0); n } n int main() { n   ios::sync_with_stdio(0); n   cin.tie(0); n   cout.tie(0); n   long long n, m; n   cin >> n >> m; n   vector<string> x(n), y(m), ans; n   for (int i = 0; i < n; i++) { n     cin >> x[i]; n   } n   for (int i = 0; i < m; i++) { n     cin >> y[i]; n   } n   long long q; n   cin >> q; n   while (q--) { n     long long a; n     cin >> a; n     a--; n     cout << x[a % n] + y[a % m] << endl; n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n #pragma comment(linker,  /stack:64000000 ) n using namespace std; n const double PI = 2 * acos(0.0); n const double eps = 1e-9; n template <class T> n T jog(T a, T b) { n   return a + b; n } n template <class T> n T bog(T a, T b) { n   return a - b; n } n template <class T> n T gon(T a, T b) { n   return a * b; n } n template <class T> n T sq(T x) { n   return x * x; n } n template <class T> n T gcd(T a, T b) { n   return b == 0 ? a : gcd(b, a % b); n } n template <class T> n T lcm(T a, T b) { n   return (a / gcd(a, b)) * b; n } n template <class T> n T power(T a, T p) { n   T res = 1, x = a; n   while (p) { n     if (p & 1) res = res * x; n     x = x * x; n     p >>= 1; n   } n   return res; n } n template <class T> n T cordinatlenth(T a, T b, T c, T d) { n   return sqrt(sq(a - c) + sq(b - d)); n } n template <class T> n string toString(T n) { n   ostringstream oss; n   oss << n; n   oss.flush(); n   return oss.str(); n } n int toInt(string s) { n   int r = 0; n   istringstream sin(s); n   sin >> r; n   return r; n } n long long bigmod(long long a, long long p, long long mod) { n   long long res = 1, x = a; n   while (p) { n     if (p & 1) res = (res * x) % mod; n     x = (x * x) % mod; n     p >>= 1; n   } n   return res; n } n int diraction1[] = {-1, 0, 0, 1, 1, -1, -1, 1}; n int diraction2[] = {0, -1, 1, 0, 1, -1, 1, -1}; n int horsed1[] = {-2, -2, -1, 1, 2, 2, 1, -1}; n int horsed2[] = {1, -1, -2, -2, -1, 1, 2, 2}; n void input(); n const int INF = 2147483647; n const long long LINF = 9223372036854775807ll; n int n, in[1000010]; n int main() { n   input(); n   return 0; n } n void input() { n   memset(in, 0, sizeof(in)); n   cin >> n; n   for (int i = 0, tmp; i < n; i++) { n     scanf( %d , &tmp); n     in[tmp]++; n   } n   long long ans = 0; n   for (int i = 0; i < 1000005; i++) { n     if (in[i] == 0 || in[i] == 1) continue; n     while (in[i] > 1) { n       ans++; n       in[i + 1]++; n       in[i]--; n     } n   } n   cout << ans << endl; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int n; n int changed; n int answer1, answer2 = 1023; n int main() { n   cin >> n; n   int i; n   for (i = 0; i < n; i++) { n     char tp; n     cin >> tp; n     if (tp ==  | ) { n       int number; n       cin >> number; n       answer1 |= number; n       answer2 |= number; n       changed |= number; n     } else if (tp ==  & ) { n       int number; n       cin >> number; n       answer1 &= number; n       answer2 &= number; n       number = 1023 - number; n       changed |= number; n     } else { n       int number; n       cin >> number; n       answer1 ^= number; n       answer2 ^= number; n     } n   } n   int answer11 = 0; n   int answer22 = 0; n   int answer33 = 0; n   for (i = 0; i < 10; i++) { n     if ((answer1 & (1 << i)) && (answer2 & (1 << i))) { n       answer11 += 1 << i; n     } else { n       if ((answer1 & (1 << i)) && (!(answer2 & (1 << i)))) { n         answer33 += 1 << i; n         answer22 += 1 << i; n       } n       if ((!(answer1 & (1 << i))) && (answer2 & (1 << i))) { n         answer22 += 1 << i; n       } n     } n   } n   cout << 3 << endl; n   cout <<  &   << answer22 << endl; n   cout <<  |   << answer11 << endl; n   cout <<  ^   << answer33 << endl; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int N = 1e5 + 1; n string s, t; n char c[N]; n int cs[2][N], ct[2][N], q; n int main() { n   scanf(  %s , c); n   s = c; n   scanf(  %s , c); n   t = c; n   int at = 0; n   for (auto &i : s) { n     at++; n     if (i ==  C  || i ==  B ) { n       i =  B ; n       cs[1][at] = cs[1][at - 1] + 1; n     } else { n       cs[1][at] = cs[1][at - 1]; n       cs[0][at] = cs[0][at - 1] + 1; n     } n   } n   at = 0; n   for (auto &i : t) { n     at++; n     if (i ==  C  || i ==  B ) { n       i =  B ; n       ct[1][at] = ct[1][at - 1] + 1; n     } else { n       ct[1][at] = ct[1][at - 1]; n       ct[0][at] = ct[0][at - 1] + 1; n     } n   } n   scanf( %d , &q); n   for (int i = 0, a, b, c, d; i < q; i++) { n     scanf( %d%d%d%d , &a, &b, &c, &d); n     int difs = cs[1][b] - cs[1][a - 1]; n     int dift = ct[1][d] - ct[1][c - 1]; n     bool thereis = 0; n     int need = dift - difs; n     int trails = min(b - a + 1, cs[0][b]); n     int trailt = min(d - c + 1, ct[0][d]); n     if (need & 1) { n       printf( 0 ); n       continue; n     } n     if (need < 0) { n       printf( 0 ); n       continue; n     } n     if (!need) { n       if (trails < trailt || (trails - trailt) % 3) { n         printf( 0 ); n         continue; n       } n       printf( 1 ); n       continue; n     } n     if (need && trails > trailt) { n       trails = trailt; n       thereis = 1; n     } n     if ((trails - trailt) % 3 || trails < trailt) { n       printf( 0 ); n       continue; n     } n     thereis |= difs; n     if (!thereis && need) { n       printf( 0 ); n       continue; n     } n     printf( 1 ); n   } n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n template <typename T> n inline T maxi(T a, T b) { n   return a > b ? a : b; n } n template <typename T> n inline T mini(T a, T b) { n   return a < b ? a : b; n } n template <typename T> n inline T absl(T a) { n   return a > 0 ? a : -a; n } n template <typename T> n inline T gcd(T a, T b) { n   T t; n   if (a < b) { n     while (a) { n       t = a; n       a = b % a; n       b = t; n     } n     return b; n   } else { n     while (b) { n       t = b; n       b = a % b; n       a = t; n     } n     return a; n   } n } n template <typename T> n inline T ceiling(T a, T b) { n   if (b < 0) { n     a *= -1; n     b *= -1; n   } n   if ((double)a / (double)b < 0) return 0; n   { n     if (a % b == 0) return (a / b); n     return ((a / b) + 1); n   } n } n vector<int> adj[500000]; n map<pair<int, int>, int> m; n vector<pair<int, int> > v(500000); n vector<bool> visited(500000, false); n int d; n void dfs(int u, int c) { n   visited[u] = true; n   for (auto it : adj[u]) { n     if (!visited[it]) { n       m[{u, it}] = c % d; n       ++c; n       dfs(it, c); n     } n   } n } n void input() { n   int n, k; n   cin >> n >> k; n   for (int i = 0; i < n - 1; ++i) { n     int s, d; n     cin >> s >> d; n     --s; n     --d; n     adj[s].push_back(d); n     adj[d].push_back(s); n     v[i].first = s; n     v[i].second = d; n   } n   int b[n]; n   for (int i = 0; i < n; ++i) { n     b[i] = adj[i].size(); n   } n   sort(b, b + n, greater<int>()); n   d = b[k]; n   cout << d << endl; n   dfs(0, 0); n   for (int i = 0; i < n - 1; ++i) { n     cout << maxi(m[v[i]], m[{v[i].second, v[i].first}]) + 1 <<    ; n   } n } n int main() { n   input(); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int maxn = 1e5 + 5; n struct node { n   int l, r, sum; n } hjt[maxn * 40]; n int a[maxn], root[maxn], cnt; n int last[maxn]; n void insert(int l, int r, int pre, int &now, int p, int v) { n   hjt[++cnt] = hjt[pre]; n   now = cnt; n   hjt[now].sum = hjt[pre].sum + v; n   if (l == r) return; n   int m = (l + r) >> 1; n   if (p <= m) n     insert(l, m, hjt[pre].l, hjt[now].l, p, v); n   else n     insert(m + 1, r, hjt[pre].r, hjt[now].r, p, v); n } n int query(int now, int l, int r, int k) { n   if (l == r) { n     if (hjt[now].sum <= k) return l; n     return l - 1; n   } n   int mid = (l + r) >> 1; n   int tmp = hjt[hjt[now].l].sum; n   if (tmp > k) n     return query(hjt[now].l, l, mid, k); n   else n     return query(hjt[now].r, mid + 1, r, k - tmp); n } n int main() { n   ios::sync_with_stdio(false); n   cin.tie(0); n   cout.tie(0); n   int n; n   cin >> n; n   for (int i = 1; i <= n; i++) cin >> a[i]; n   for (int i = n; i >= 1; i--) { n     if (last[a[i]]) { n       insert(1, n, root[i + 1], root[i], last[a[i]], -1); n       insert(1, n, root[i], root[i], i, 1); n     } else n       insert(1, n, root[i + 1], root[i], i, 1); n     last[a[i]] = i; n   } n   for (int i = 1; i <= n; i++) { n     int ans = 0, l = 1, r = 0; n     while (l <= n) { n       r = query(root[l], 1, n, i); n       l = r + 1; n       ans++; n     } n     cout << ans; n     if (i == n) n       cout <<   n ; n     else n       cout <<    ; n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int n, m, k; n int num = 0; n int e[21][21]; n int flag[21]; n int dfs(int x, int sum, int mid) { n   if (x > n) { n     num = num + 1; n   } else { n     mid = dfs(x + 1, sum, mid); n     for (int y = 1; y <= n; y++) { n       if (num >= k) { n         break; n       } n       if (flag[y] == 0 && e[x][y] != 0 && sum + e[x][y] <= mid) { n         flag[y] = 1; n         mid = dfs(x + 1, sum + e[x][y], mid); n         flag[y] = 0; n       } n     } n   } n   return mid; n } n int main() { n   int u, v, w; n   cin >> n >> m >> k; n   for (int i = 0; i <= 20; i++) { n     for (int j = 0; j <= 20; j++) { n       e[i][j] = 0; n     } n   } n   int l = 0; n   int h = n * 1000; n   int mid = 0; n   for (int i = 0; i < m; i++) { n     cin >> u >> v >> w; n     e[u][v] = w; n   } n   while (l < h) { n     num = 0; n     mid = (l + h) / 2; n     mid = dfs(1, 0, mid); n     if (num < k) { n       l = mid + 1; n     } else { n       h = mid; n     } n   } n   cout << h << endl; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int MAXN = 50005; n const int MAXD = 55; n const int MOD = 1e9 + 7; n template <typename T> n inline void read(T &AKNOI) { n   T x = 0, flag = 1; n   char ch = getchar(); n   while (!isdigit(ch)) { n     if (ch ==  - ) flag = -1; n     ch = getchar(); n   } n   while (isdigit(ch)) { n     x = x * 10 + ch -  0 ; n     ch = getchar(); n   } n   AKNOI = flag * x; n } n namespace ModCalculator { n inline void Inc(int &x, int y) { n   x += y; n   if (x >= MOD) x -= MOD; n } n inline void Dec(int &x, int y) { n   x -= y; n   if (x < 0) x += MOD; n } n inline int Add(int x, int y) { n   Inc(x, y); n   return x; n } n inline int Sub(int x, int y) { n   Dec(x, y); n   return x; n } n inline int Mul(int x, int y) { return 1LL * x * y % MOD; } n }  // namespace ModCalculator n using namespace ModCalculator; n char s[MAXN], sx[MAXD], sy[MAXD]; n int n, d, dg[MAXD]; n int tot, ch[MAXN][10], fail[MAXN], ed[MAXN], q[MAXN]; n int dp[MAXD][MAXN]; n void Insert(int l, int r) { n   int p = 0; n   for (int i = l; i <= r; ++i) { n     int x = s[i] -  0 ; n     if (!ch[p][x]) ch[p][x] = ++tot; n     p = ch[p][x]; n   } n   ed[p] = 1; n } n void GetFail() { n   int head = 1, tail = 0; n   for (int i = 0; i < 10; ++i) { n     if (ch[0][i]) { n       q[++tail] = ch[0][i]; n     } n   } n   while (head <= tail) { n     int u = q[head++]; n     for (int i = 0; i < 10; ++i) { n       if (ch[u][i]) { n         fail[ch[u][i]] = ch[fail[u]][i]; n         q[++tail] = ch[u][i]; n       } else { n         ch[u][i] = ch[fail[u]][i]; n       } n     } n   } n } n int DP(int i, int j, bool full) { n   if (i > d) return 1; n   if (!full && dp[i][j] != -1) return dp[i][j]; n   int ret = 0, r = (full ? dg[i] : 9); n   for (int k = 0; k <= r; ++k) { n     if (ed[ch[j][k]]) continue; n     Inc(ret, DP(i + 1, ch[j][k], full && (k == r))); n   } n   if (!full) dp[i][j] = ret; n   return ret; n } n int Calc(char *ss) { n   int ret = 0; n   for (int i = 1; i <= d; ++i) { n     ret = Add(Mul(ret, 10), (dg[i] = ss[i] -  0 )); n   } n   return Sub(ret, DP(1, 0, 1)); n } n void init() { n   scanf( %s , s + 1); n   n = strlen(s + 1); n   scanf( %s , sx + 1); n   scanf( %s , sy + 1); n   d = strlen(sx + 1); n   int d2 = d / 2; n   for (int i = 1; i + d2 - 1 <= n; ++i) { n     Insert(i, i + d2 - 1); n   } n   GetFail(); n } n void solve() { n   int p = d; n   for (; sx[p] ==  0 ; sx[p--] =  9 ) n     ; n   sx[p] -= 1; n   memset(dp, -1, sizeof(dp)); n   printf( %d n , Sub(Calc(sy), Calc(sx))); n } n int main() { n   init(); n   solve(); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n long long mdin(long long a, long long m) { n   long long r1 = m, r2 = a, t1 = 0, t2 = 1; n   while (r2 > 0) { n     long long q = r1 / r2; n     long long r = r1 % r2; n     r1 = r2; n     r2 = r; n     long long t = (t1 - q * t2) % m; n     t1 = t2; n     t2 = t; n   } n   return (t1 + m) % m; n } n long long ex(long long a, long long n, long long m) { n   if (n == 0) return 1; n   long long ans = ex((a * a) % m, n / 2, m); n   if (n % 2) ans = (a * ans) % m; n   return ans; n } n void bfs(int r, vector<int> adj[], int n) { n   queue<int> q, l; n   vector<int> vis(n + 1, 0); n   q.push(r); n   l.push(1); n   while (!q.empty()) { n     int nd = q.front(); n     q.pop(); n     int lv = l.front(); n     l.pop(); n     for (auto it : adj[nd]) { n       if (vis[it] == 0) { n         vis[it] = 1; n         q.push(it); n         l.push(lv + 1); n       } n     } n   } n } n int main() { n   ios_base::sync_with_stdio(false); n   cin.tie(NULL); n   long long t = 1; n   while (t--) { n     long long n, k; n     cin >> n >> k; n     if (k > n - 1) { n       cout << 0; n       return 0; n     } n     long long f[n + 1], inf[n + 1]; n     f[0] = 1; n     inf[0] = 1; n     for (long long i = 1; i <= n; i++) { n       f[i] = (i * f[i - 1]) % 998244353; n       inf[i] = mdin(f[i], 998244353); n     } n     if (k == 0) { n       cout << f[n] << endl; n     } else { n       long long ans = (((f[n] * inf[n - k]) % 998244353) * inf[k]) % 998244353; n       k = n - k; n       long long ml = 0; n       int s = 1; n       for (long long i = 0; i <= k - 1; i++) { n         long long cm = (((f[k] * inf[i]) % 998244353) * inf[k - i]) % 998244353; n         long long t = k - i; n         long long et = ex(t, n, 998244353); n         ml = (ml + (cm * et * s) % 998244353 + 998244353) % 998244353; n         s *= -1; n       } n       ans = (((ml * ans) % 998244353) * 2) % 998244353; n       cout << ans << endl; n     } n   } n   return 0; n } n "}
+{"func_code_string": "#include<bits/stdc++.h> n using namespace std; n #define mod        1000000007 n #define pb         push_back n #define mp         make_pair n #define rep(n)     for(int i=0;i<n;i++) n #define repit(x)   for(auto it : x) n #define ll         long long n #define vi         vector<int> n #define vc         vector<char> n #define vs         vector<string> n #define mii        map<int ,int> n #define mci        map<char ,int> n /* bool prime[100001]; n  const int N=100000; n  void sieve() { n  int i,j; n for(i=2;i<=N;i++) n prime[i]=true; n  prime[0]=prime[1]=false; n for(i=2;i*i<=N;i++){ n if(prime[i]){ n for(j=i*i;j<=N;j+=i) n prime[j]=false; n } n } n }*/ n int gcd(int a,int b){ n if(b==0) n return a; n else n return gcd(b,a%b); n } n void swap(int *x,int *y){ n int temp=*x; n *x=*y; n *y=temp; n } n int main() n { n      n ios::sync_with_stdio(0); n cin.tie(0); n cout.tie(0); n int t; n cin>>t; n while(t--){ n int i,n,c=0,j; n cin>>n; n string s,s2; n cin>>s; n map<string,int>m; n for(i=97;i<=122;i++){ n     string s1; n     s1.push_back(i); n     m.insert(make_pair(s1,0)); n } n for(i=0;i<n;i++){ n     string s1; n     s1.push_back(s[i]); n     m[s1]++; n } n for(auto it=m.begin();it!=m.end();it++){ n     if(it->second==0){ n         c=1; n         s2=it->first; n         break; n     } n } n if(c){ n     cout<<s2<<  n ; n } n else{ n     m.clear(); n     for(i=97;i<=122;i++){ n         for(j=97;j<=122;j++){ n             string s1; n             s1.push_back(i); n             s1.push_back(j); n             m.insert(make_pair(s1,0)); n         } n     } n     for(i=0;i<n-1;i++){ n         string s1; n         s1.push_back(s[i]); n         s1.push_back(s[i+1]); n         m[s1]++; n     } n     for(auto it=m.begin();it!=m.end();it++){ n         if(it->second==0){ n             c=1; n             s2=it->first; n             break; n         } n     } n     if(c) n     cout<<s2<<  n ; n     else{ n         m.clear(); n         for(i=97;i<=122;i++){ n             for(j=97;j<=122;j++){ n                 for(int k=97;k<=122;k++){ n                     string s1; n                     s1.push_back(i); n                     s1.push_back(j); n                     s1.push_back(k); n                     m.insert(make_pair(s1,0)); n                 } n             } n         } n         for(i=0;i<n-2;i++){ n             string s1; n             s1.push_back(s[i]); n             s1.push_back(s[i+1]); n             s1.push_back(s[i+2]); n             m[s1]++; n              n         } n         for(auto it=m.begin();it!=m.end();it++){ n             if(it->second==0){ n                 c=1; n                 s2=it->first; n                 break; n             } n         } n         cout<<s2<<  n ; n     } n } n } n return 0; n }"}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int n, m; n int table[1000][1000]; n int main() { n   int k = 0; n   scanf( %d %d %d , &n, &m, &k); n   for (int i = 0; i < n; ++i) { n     for (int j = 0; j < m; ++j) { n       scanf( %d , &table[i][j]); n     } n   } n   while (k) { n     char command; n     int x, y; n     scanf(  %c %d %d , &command, &x, &y); n     if (command ==  g ) n       printf( %d n , table[x - 1][y - 1]); n     else if (command ==  c ) n       for (int i = 0; i < n; ++i) swap(table[i][x - 1], table[i][y - 1]); n     else n       for (int i = 0; i < m; ++i) swap(table[x - 1][i], table[y - 1][i]); n     k--; n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n ifstream Cin( input.txt ); n ofstream Cout( output.txt ); n int main() { n   long long i, n4 = 0, n7 = 0, n; n   string a, b; n   cin >> a >> b; n   for (i = 0; i < a.length(); i++) n     if (a[i] != b[i]) { n       if (a[i] ==  4 ) n         n4++; n       else n         n7++; n     } n   cout << n4 + n7 - min(n4, n7); n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n using ll = long long; n ll min(ll a, ll b) { n   if (a < b) return a; n   return b; n } n void solve() { n   ll testCases; n   cin >> testCases; n   while (testCases--) { n     ll n; n     cin >> n; n     vector<ll> arr(n); n     vector<ll> res(n, 1); n     for (int i = 0; i < n; i++) cin >> arr[i]; n     int i = 0; n     for (i = 0; i < n; i++) { n       if (arr[i] != arr[(i + 1) % n]) break; n     } n     if (i == n) { n       cout <<  1 n ; n       for (i = 0; i < n; i++) cout << 1 <<    ; n       cout <<   n ; n       continue; n     } n     if (n % 2 == 0) { n       cout <<  2 n ; n       for (i = 0; i < n; i++) cout << (i % 2) + 1 <<    ; n       cout <<   n ; n       continue; n     } else { n       bool isTwo = 0; n       for (i = 0; i < n; i++) { n         if (arr[i] == arr[(i + 1) % n]) { n           for (int j = 0, k = i + 1; k < n; k++, j ^= 1) res[k] = j + 1; n           for (int j = 0, k = i; k >= 0; k--, j ^= 1) res[k] = j + 1; n           cout <<  2 n ; n           for (auto e : res) cout << e <<    ; n           cout <<   n ; n           isTwo = 1; n           break; n         } n       } n       if (!isTwo) { n         cout <<  3 n ; n         for (i = 0; i < n - 1; i++) cout << i % 2 + 1 <<    ; n         cout <<  3 n ; n       } n     } n   } n } n int main() { n   { n     ios_base::sync_with_stdio(false); n     cin.tie(NULL); n   }; n   solve(); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int maxN = 3000 + 1; n pair<int, int> a[maxN]; n pair<int, int> b[maxN]; n int nx[maxN], pr[maxN], v[maxN]; n int r, c, n; n inline int gg(int i) { n   pair<int, int> x = {a[i].second, a[i].first}; n   return lower_bound(b, b + n + 2, x) - b; n } n inline int ff(int i) { return b[i].first; } n int nex(int i) { n   if (v[nx[i]]) return nx[i]; n   return nx[i] = nex(nx[i]); n } n int prev(int i) { n   if (v[pr[i]]) return pr[i]; n   return pr[i] = prev(pr[i]); n } n int L[11], R[11]; n int main() { n   cin >> r >> c >> n; n   int k; n   cin >> k; n   for (int i = 0; i < n; i++) { n     cin >> a[i].first >> a[i].second; n     b[i] = {a[i].second, a[i].first}; n   } n   b[n] = {0, 0}, b[n + 1] = {c + 1, 0}; n   sort(a, a + n); n   sort(b, b + n + 2); n   v[0] = v[n + 1] = 1; n   pr[0] = 0, nx[n + 1] = n + 1; n   long long ans = 0; n   for (int i = 1; i <= r; i++) { n     int ind = 0; n     for (; ind < n && a[ind].first < i; ind++) n       ; n     if (ind == n) break; n     for (int j = ind; j < n; j++) v[gg(j)] = 1; n     for (int j = 1; j <= n; j++) { n       nx[j] = j + 1; n       pr[j] = j - 1; n     } n     int curr = 0; n     for (int j = 1; j <= n; j++) n       if (v[j]) { n         int x = j; n         for (int t = 1; t < k; t++, x = nex(x)) n           ; n         curr += (ff(j) - ff(prev(j))) * (c + 1 - ff(x)); n       } n     int ptr = n; n     for (int i2 = r; i2 >= i; i2--) { n       ans += curr; n       for (; ptr > ind && a[ptr - 1].first >= i2; ptr--) { n         L[0] = R[0] = gg(ptr - 1); n         for (int t = 1; t < k; t++) { n           L[t] = prev(L[t - 1]); n           R[t] = nex(R[t - 1]); n         } n         for (int t = 0; t < k; t++) { n           int left = L[t]; n           int right = R[k - t - 1]; n           curr -= (ff(left) - ff(prev(left))) * (ff(nex(right)) - ff(right)); n         } n         v[L[0]] = 0; n       } n     } n   } n   cout << ans << endl; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int arr[500005], brr[500005]; n pair<int, int> tree[500005 * 4]; n vector<int> vv[500005]; n vector<pair<int, int> > qr[500005]; n int ans[500005]; n void build(int node, int b, int e) { n   if (b == e) { n     tree[node] = make_pair(500000000, 500000000); n     return; n   } n   int left = 2 * node, right = left + 1, mid = (b + e) / 2; n   build(left, b, mid); n   build(right, mid + 1, e); n   tree[node] = tree[left]; n } n void update(int node, int b, int e, int i, int v) { n   if (e < i || b > i) return; n   if (b == e && b == i) { n     tree[node] = make_pair(v, arr[b]); n     return; n   } n   int left = 2 * node, right = left + 1, mid = (b + e) / 2; n   update(left, b, mid, i, v); n   update(right, mid + 1, e, i, v); n   if (tree[left].first <= tree[right].first) { n     tree[node] = tree[left]; n   } else n     tree[node] = tree[right]; n } n pair<int, int> query(int node, int b, int e, int l, int r) { n   if (b > r || e < l) return make_pair(500000000, 500000000); n   if (b >= l && e <= r) return tree[node]; n   int left = 2 * node, right = left + 1, mid = (b + e) / 2; n   pair<int, int> p = query(left, b, mid, l, r); n   pair<int, int> q = query(right, mid + 1, e, l, r); n   if (p.first <= q.first) return p; n   return q; n } n int main() { n   int n; n   scanf( %d , &n); n   int mx = 0; n   for (int i = 1; i <= n; i++) { n     scanf( %d , &arr[i]); n     vv[arr[i]].push_back(i); n     mx = max(mx, arr[i]); n   } n   int q; n   scanf( %d , &q); n   for (int i = 1; i <= q; i++) { n     int l, r; n     scanf( %d %d , &l, &r); n     qr[r].push_back(make_pair(l, i)); n   } n   build(1, 1, n); n   for (int i = 1; i <= n; i++) { n     int id = lower_bound(vv[arr[i]].begin(), vv[arr[i]].end(), i) - n              vv[arr[i]].begin(); n     int v; n     if (id == 0) { n       v = 1; n       brr[arr[i]] = i; n     } else { n       v = vv[arr[i]][id - 1] + 1; n       update(1, 1, n, brr[arr[i]], 500000000); n       brr[arr[i]] = i; n     } n     update(1, 1, n, i, v); n     for (int j = 0; j < qr[i].size(); j++) { n       pair<int, int> ret = query(1, 1, n, qr[i][j].first, i); n       if (qr[i][j].first >= ret.first) ans[qr[i][j].second] = ret.second; n     } n   } n   for (int i = 1; i <= q; i++) printf( %d n , ans[i]); n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int N = 2e5 + 10; n const int MAXN = 200000; n int n, tot; n bool bz[N]; n vector<int> g[N], edge[N]; n int e[N * 2][2], gg[N]; n int sz; n long long ans[N]; n void add(int x, int y) { n   e[++tot][0] = y; n   e[tot][1] = gg[x]; n   gg[x] = tot; n } n void dfs(int x) { n   bz[x] = 0; n   sz++; n   for (int i = gg[x]; i; i = e[i][1]) n     if (bz[e[i][0]]) dfs(e[i][0]); n   gg[x] = 0; n } n int main() { n   scanf( %d , &n); n   for (int i = 1; i <= n; i++) { n     int x; n     scanf( %d , &x); n     for (int j = 1; 1ll * j * j <= x; j++) n       if ((x % j) == 0) { n         g[j].push_back(i); n         if (j * j != x) g[x / j].push_back(i); n       } n   } n   for (int i = 1; i < n; i++) { n     int x, y; n     scanf( %d %d , &x, &y); n     edge[x].push_back(y); n     edge[y].push_back(x); n   } n   for (int i = 1; i <= MAXN; i++) n     if (g[i].size()) { n       tot = 0; n       for (auto u : g[i]) bz[u] = 1; n       for (auto u : g[i]) n         for (auto v : edge[u]) n           if (bz[v]) add(u, v); n       for (auto u : g[i]) n         if (bz[u]) { n           sz = 0; n           dfs(u); n           ans[i] += 1ll * sz * (sz - 1) / 2 + sz; n         } n     } n   for (int i = MAXN; i; i--) n     for (int j = 2; 1ll * j * i <= MAXN; j++) ans[i] -= ans[i * j]; n   for (int i = 1; i <= MAXN; i++) n     if (ans[i]) printf( %d %lld n , i, ans[i]); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int main() { n   int k, n; n   scanf( %d%d , &n, &k); n   vector<int> a(n), b(n), distributed(n), p(n); n   vector<vector<int> > cart(k); n   for (int i = 0; i < n; ++i) { n     scanf( %d%d , &a[i], &b[i]); n     distributed[i] = 0; n     p[i] = i; n   } n   for (int i = 0; i < n; ++i) { n     for (int j = i + 1; j < n; ++j) { n       if (a[p[i]] < a[p[j]]) { n         swap(p[i], p[j]); n       } n     } n   } n   int cart_ptr = 0; n   for (int i = 0; i < n && cart_ptr < k; ++i) { n     if (b[p[i]] == 1) { n       distributed[p[i]] = 1; n       cart[cart_ptr].push_back(p[i]); n       ++cart_ptr; n     } n   } n   deque<int> available; n   for (int i = 0; i < n; ++i) { n     if (!distributed[p[i]]) { n       available.push_back(p[i]); n     } n   } n   while (cart_ptr < k) { n     cart[cart_ptr].push_back(available.front()); n     available.pop_front(); n     ++cart_ptr; n   } n   while (!available.empty()) { n     cart[k - 1].push_back(available.front()); n     available.pop_front(); n   } n   long long ans = 0; n   for (int i = 0; i < k; ++i) { n     int min_cost = 2000000000; n     for (int j = 0; j < (int)cart[i].size(); ++j) { n       ans += a[cart[i][j]] * 2; n       min_cost = min(min_cost, a[cart[i][j]]); n     } n     if (b[cart[i][0]] == 1) { n       ans -= min_cost; n     } n   } n   cout << ans / 2; n   if (ans % 2 == 0) { n     cout <<  .0  << endl; n   } else { n     cout <<  .5  << endl; n   } n   for (int i = 0; i < k; ++i) { n     cout << cart[i].size(); n     for (int j = 0; j < (int)cart[i].size(); ++j) { n       cout <<     << cart[i][j] + 1; n     } n     cout << endl; n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int inf = (int)1e9; n const int mod = (int)1e9 + 7; n const double pi = acos(-1.0); n const double eps = 1e-9; n const int maxn = (int)2e6 + 11; n long long n; n long long a[maxn]; n long long sum[maxn]; n int main() { n   cin >> n; n   a[1] = 2; n   sum[1] = 2; n   for (int i = 2; i <= 2000000; i++) { n     a[i] = a[i - 1] + 3; n     sum[i] = sum[i - 1] + a[i]; n   } n   int ans = 0; n   for (int i = 1; sum[i] <= n; i++) { n     if ((n - sum[i]) % 3 == 0) ans++; n   } n   cout << ans << endl; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n map<long long, long long> mp[12]; n long long a[200005], dig[200005]; n long long state[200005][12]; n int main() { n   long long n, k; n   scanf( %lld %lld , &n, &k); n   for (int i = 0; i < n; i++) scanf( %lld , &a[i]); n   for (int i = 0; i < n; i++) { n     dig[i] = log10(a[i]) + 1; n   } n   for (int i = 0; i < n; i++) { n     long long x = a[i]; n     long long tencnt = 1; n     while (tencnt < 11) { n       x = (x * 10LL) % k; n       mp[tencnt][x]++; n       state[i][tencnt] = x; n       tencnt++; n     } n   } n   long long ans = 0; n   for (int i = 0; i < n; i++) { n     long long len = dig[i]; n     long long m = (k - (a[i] % k)) % k; n     if (mp[len].count(m) == 0) continue; n     ans += mp[len][m]; n   } n   for (int i = 0; i < n; i++) { n     long long len = dig[i]; n     long long x = state[i][len]; n     if ((x + a[i]) % k == 0) { n       ans--; n     } n   } n   printf( %lld n , ans); n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const long long LINF = ~0ULL >> 1; n const int N = 1e3 + 7; n const int INF = 2e8 + 7; n const int MOD = 1e9 + 7; n const double PI = acos(-1.0); n const double EPS = 1e-8; n int n; n long long calc(long long A, long long B, long long C) { n   return (A + 1) * (B + 2) * (C + 2); n } n void solve() { n   long long mn = LINF, mx = -LINF, tmp; n   for (int i = 1; 1ll * i * i * i <= n; ++i) { n     if (n % i) continue; n     for (int j = i, J = n / i; 1ll * j * j <= J; ++j) { n       if (J % j) continue; n       int k = n / i / j; n       tmp = calc(i, j, k); n       mn = min(mn, tmp), mx = max(mx, tmp); n       tmp = calc(j, i, k); n       mn = min(mn, tmp), mx = max(mx, tmp); n       tmp = calc(k, i, j); n       mn = min(mn, tmp), mx = max(mx, tmp); n     } n   } n   cout << mn - n <<     << mx - n << endl; n } n int main() { n   std::ios_base::sync_with_stdio(false); n   cin >> n; n   solve(); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int n, x, r[100000], pos[100000], flag = 1, flag2; n pair<int, int> a[100000]; n vector<int> ans, ans2; n int l(int n) { n   if (!n) return 1; n   if (n % 10 == 4 || n % 10 == 7) return l(n / 10); n   return 0; n } n int main() { n   scanf( %d , &n); n   for (int i = 0; i < n; i++) { n     scanf( %d , &x); n     a[i] = pair<int, int>(x, i); n   } n   sort(a, a + n); n   for (int i = 0; i < n; i++) { n     r[a[i].second] = i; n     pos[i] = a[i].second; n     if (a[i].second != i) flag = 0; n     if (!flag2 && l(a[i].first)) x = i, flag2 = 1; n   } n   if (flag) { n     cout << 0 << endl; n     return 0; n   } n   if (!flag2) { n     cout << -1 << endl; n     return 0; n   } n   for (int i = 0; i < n; i++) n     if (i != x) { n       if (pos[i] == i) continue; n       if (pos[x] != i) { n         ans.push_back(pos[x]), ans2.push_back(i); n         int temp = pos[x]; n         swap(pos[x], pos[r[i]]); n         swap(r[temp], r[i]); n       } n       ans.push_back(pos[x]), ans2.push_back(pos[i]); n       swap(pos[x], pos[i]); n       swap(r[pos[x]], r[pos[i]]); n     } n   cout << ans.size() << endl; n   for (int i = 0; i < ans.size(); i++) n     cout << ans[i] + 1 <<     << ans2[i] + 1 << endl; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int MAXN = 1e3 + 10; n const int MOD = 998244353; n const int INF = 10; n int fact[MAXN], invfact[MAXN]; n int add(int a, int b) { n   int sum = a + b; n   return (sum >= MOD ? sum -= MOD : (sum < 0 ? sum += MOD : sum)); n } n int mul(int a, int b) { return 1LL * a * b % MOD; } n int pwr(int a, int b) { n   return (!b ? 1 n              : (b & 1 ? 1LL * a * pwr(1LL * a * a % MOD, b >> 1) % MOD n                       : pwr(1LL * a * a % MOD, b >> 1) % MOD)); n } n int inv(int x) { return pwr(x, MOD - 2); } n void first() { n   fact[0] = 1; n   for (int i = 1; i < MAXN; i++) fact[i] = mul(fact[i - 1], i); n   for (int i = 0; i < MAXN; i++) invfact[i] = inv(fact[i]); n } n int C(int n, int k) { return mul(mul(fact[n], invfact[k]), invfact[n - k]); } n int P(int n, int k) { return mul(fact[n], invfact[n - k]); } n int n, a[MAXN], dp[MAXN]; n int main() { n   ios::sync_with_stdio(false); n   cin.tie(0); n   cout.tie(0); n   first(); n   cin >> n; n   for (int i = 0; i < n; i++) { n     cin >> a[i]; n   } n   dp[n] = 1; n   for (int i = n - 1; i >= 0; i--) { n     if (a[i] <= 0 || a[i] + i - 1 > n - 1) { n       continue; n     } n     for (int j = n - 1; j >= a[i] + i; j--) { n       dp[i] = add(dp[i], mul(dp[j + 1], C(j - i, a[i]))); n     } n   } n   int ans = 0; n   for (int i = 0; i < n; i++) { n     ans = add(ans, dp[i]); n   } n   cout << ans; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int main() { n   int n; n   cin >> n; n   int* m = new int[n]; n   int* r = new int[n]; n   for (int i = 0; i < n; i++) { n     cin >> m[i]; n   } n   for (int i = 0; i < n; i++) { n     cin >> r[i]; n   } n   double total = 0; n   for (int i = 0; i < 1000000; i++) { n     for (int j = 0; j < n; j++) { n       if (i % m[j] == r[j]) { n         total++; n         break; n       } n     } n   } n   double percentage = total / 1000000; n   cout << fixed << setprecision(6) << percentage << endl; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int dx[] = {1, 1, -1, -1}; n int dy[] = {1, -1, -1, 1}; n long long int n, k, d1, d2, rem; n bool _solve(long long int w1, long long int w2, long long int w3) { n   long long int tar = n / 3; n   if (w1 < 0 || w2 < 0 || w3 < 0) return false; n   if (tar >= w1 && tar >= w2 && tar >= w3 && abs(w1 - w2) == d1 && n       abs(w2 - w3) == d2) n     return true; n   return false; n } n bool solve() { n   long long int _d1, w1, w2, w3, _d2; n   for (int i = 0; i < 4; i++) { n     _d1 = d1 * dx[i]; n     _d2 = d2 * dy[i]; n     w1 = (k + 2 * _d1 + _d2) / 3; n     w2 = w1 - _d1; n     w3 = w2 - _d2; n     if (w1 + w2 + w3 != k) continue; n     if (_solve(w1, w2, w3)) return true; n   } n   return false; n } n int main() { n   ios_base ::sync_with_stdio(false); n   cin.tie(0); n   int t; n   cin >> t; n   while (t--) { n     cin >> n >> k >> d1 >> d2; n     if (n % 3 == 0) { n       if (solve()) n         cout <<  yes  << endl; n       else n         cout <<  no  << endl; n     } else n       cout <<  no  << endl; n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int inf = 1.01e9; n const double eps = 1e-9; n const int N = 1010; n char s[N][N]; n char res[N * N]; n int resc = 0; n char ch[4] = { D ,  L ,  R ,  U }; n int dx[4] = {1, 0, 0, -1}; n int dy[4] = {0, -1, 1, 0}; n pair<int, int> q[N * N]; n int st = 0, en = 0; n int d[N][N]; n int n, m; n void bfs(int x, int y) { n   for (int i = 0; (i) < (n); ++i) n     for (int j = 0; (j) < (m); ++j) d[i][j] = inf; n   d[x][y] = 0; n   q[en++] = {x, y}; n   while (st < en) { n     x = q[st].first; n     y = q[st].second; n     st++; n     for (int i = 0; (i) < (4); ++i) { n       int xx = x + dx[i]; n       int yy = y + dy[i]; n       if (0 <= xx && xx < n && 0 <= yy && yy < m && s[xx][yy] ==  .  && n           d[xx][yy] == inf) { n         d[xx][yy] = d[x][y] + 1; n         q[en++] = {xx, yy}; n       } n     } n   } n } n int main() { n   int k; n   scanf( %d%d%d , &n, &m, &k); n   if (k & 1) { n     printf( IMPOSSIBLE n ); n     return 0; n   } n   for (int i = 0; (i) < (n); ++i) scanf( %s , s[i]); n   int px = -1, py = -1; n   for (int i = 0; (i) < (n); ++i) n     for (int j = 0; (j) < (m); ++j) n       if (s[i][j] ==  X ) { n         px = i; n         py = j; n         s[i][j] =  . ; n       } n   bfs(px, py); n   int x = px, y = py; n   for (int it = 0; (it) < (k); ++it) { n     int ok = 0; n     for (int i = 0; (i) < (4); ++i) { n       int xx = x + dx[i]; n       int yy = y + dy[i]; n       if (0 <= xx && xx < n && 0 <= yy && yy < m && d[xx][yy] <= k - it - 1) { n         res[resc++] = ch[i]; n         x = xx; n         y = yy; n         ok = 1; n         break; n       } n     } n     if (!ok) { n       printf( IMPOSSIBLE n ); n       return 0; n     } n   } n   printf( %s n , res); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n char s[100010], a[110], b[110]; n int pa[110], pb[110]; n int main() { n   scanf( %s%s%s , s, a, b); n   int i, j; n   j = -1; n   pa[0] = -1; n   int lena = strlen(a); n   for (i = 1; i < lena; i++) { n     while (j > -1 && a[j + 1] != a[i]) j = pa[j]; n     if (a[j + 1] == a[i]) j++; n     pa[i] = j; n   } n   j = -1; n   pb[0] = -1; n   int lenb = strlen(b); n   for (i = 1; i < lenb; i++) { n     while (j > -1 && b[j + 1] != b[i]) j = pb[j]; n     if (b[j + 1] == b[i]) j++; n     pb[i] = j; n   } n   int len = strlen(s); n   int minn = len + 1; n   j = -1; n   for (i = 0; i < len; i++) { n     while (j > -1 && a[j + 1] != s[i]) j = pa[j]; n     if (a[j + 1] == s[i]) j++; n     if (j == lena - 1) { n       minn = i; n       break; n     } n   } n   bool flag1 = false, flag2 = false; n   j = -1; n   for (i = minn + 1; i < len; i++) { n     while (j > -1 && b[j + 1] != s[i]) j = pb[j]; n     if (b[j + 1] == s[i]) j++; n     if (j == lenb - 1) { n       flag1 = true; n       break; n     } n   } n   for (i = 0; i < len / 2; i++) swap(s[i], s[len - i - 1]); n   j = -1; n   minn = len; n   for (i = 0; i < len; i++) { n     while (j > -1 && a[j + 1] != s[i]) j = pa[j]; n     if (a[j + 1] == s[i]) j++; n     if (j == lena - 1) { n       minn = i; n       break; n     } n   } n   j = -1; n   for (i = minn + 1; i < len; i++) { n     while (j > -1 && b[j + 1] != s[i]) j = pb[j]; n     if (b[j + 1] == s[i]) j++; n     if (j == lenb - 1) { n       flag2 = true; n       break; n     } n   } n   if (flag1 && flag2) n     printf( both n ); n   else if (flag1) n     printf( forward n ); n   else if (flag2) n     printf( backward n ); n   else n     printf( fantasy n ); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n long long N, a[100010], s[100100], cnt[100010]; n void update(long long *t, long long pos, long long val) { n   for (; pos <= N; pos += pos & (-pos)) t[pos] += val; n } n long long query(long long *t, long long r) { n   long long res = 0; n   for (; r > 0; r -= r & (-r)) res += t[r]; n   return res; n } n int main() { n   ios::sync_with_stdio(0); n   cin.tie(0); n   cin >> N; n   int i; n   long long nr, sum; n   long double res = 0; n   for (i = 1; i <= N; i++) { n     cin >> a[i]; n     update(cnt, a[i], 1); n     update(s, a[i], i); n   } n   for (i = 1; i <= N; i++) { n     nr = query(cnt, a[i] - 1); n     sum = query(s, a[i] - 1); n     res += nr - (1.0 * i * (nr * (N + 1) - sum)) / (N * (N + 1)); n     nr = N - i - nr; n     sum = query(s, N) - sum - i; n     res += (1.0 * i * (nr * (N + 1) - sum)) / (N * (N + 1)); n     update(cnt, a[i], -1); n     update(s, a[i], -i); n   } n   cout << fixed << setprecision(15) << res <<   n ; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int res[111]; n int a[111][111]; n bool used[111]; n ; n bool used_j[111]; n int v[111]; n int main() { n   int n, m, k; n   cin >> n >> m >> k; n   for (int i = 0; i < n; i++) { n     for (int j = 0; j < m; j++) { n       cin >> a[i][j]; n     } n   } n   for (int i = 0; i < m; i++) { n     for (int w = 0; w < 111; w++) { n       v[w] = 0; n     } n     for (int j = 0; j < n; j++) { n       if (!used[a[j][i]] && !used_j[j]) n         v[a[j][i]]++; n       else if (!used_j[j] && used[a[j][i]]) { n         if (res[j] == 0) res[j] = i + 1; n         used_j[j] = 1; n       } n     } n     for (int j = 0; j < n; j++) { n       if (v[a[j][i]] > 1 && a[j][i] != 0) { n         if (res[j] == 0) res[j] = i + 1; n         used[a[j][i]] = 1; n         used_j[j] = 1; n       } n     } n   } n   for (int i = 0; i < n; i++) { n     cout << res[i] << endl; n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int mod = 1e9 + 7; n const int N = 1e6 + 10; n const long long INF = 1e18; n const long double EPS = 1e-12; n int a[300005]; n map<int, int> mi; n int l_, r_; n long long pre[300005]; n int b[300005]; n int main() { n   int n; n   scanf( %d , &n); n   for (int i = (int)1; i < (int)n + 1; i++) { n     scanf( %d , &a[i]); n   } n   for (int i = (int)1; i < (int)n + 1; i++) { n     if (mi[a[i]] == 0) mi[a[i]] = i; n   } n   for (int i = (int)1; i < (int)n + 1; i++) { n     pre[i] = pre[i - 1]; n     if (a[i] >= 0) pre[i] += (long long)(a[i]); n   } n   long long ans = -(long long)(1e12); n   l_ = 0; n   r_ = 0; n   for (int i = n; i >= 1; i--) { n     int x = a[i]; n     int l = mi[x]; n     if (i == mi[x]) continue; n     long long net = pre[i - 1] - pre[l]; n     net += 2LL * (long long)(x); n     if (net > ans) { n       ans = net; n       l_ = l; n       r_ = i; n     } n   } n   int cnt = 0; n   for (int i = 0; i < (int)n + 1; i++) b[i] = 0; n   for (int i = (int)1; i < (int)n + 1; i++) { n     if (i == l_ || i == r_) { n       b[i] = 1; n       continue; n     } n     if (l_ < i && i < r_ && a[i] > 0) { n       b[i] = 1; n     } else { n       b[i] = 0; n       cnt++; n     } n   } n   cout << ans <<     << cnt << endl; n   for (int i = (int)1; i < (int)n + 1; i++) { n     if (b[i] == 0) { n       printf( %d  , i); n     } n   } n   cout << endl; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n inline int Read() { n   int x = 0, f = 1, c = getchar(); n   for (; !isdigit(c); c = getchar()) n     if (c ==  - ) f = -1; n   for (; isdigit(c); c = getchar()) x = x * 10 + c -  0 ; n   return x * f; n } n const int MAXN = 300005; n int n, m, a[MAXN], f[MAXN], g[MAXN]; n inline bool Chk(int d) { n   f[0] = g[0] = 1; n   for (int i = 1, j = 1; i <= n; i++) { n     while (a[i] - a[j] > d) j++; n     if (i >= m && g[i - m] - (j == 1 ? 0 : g[j - 2]) > 0) n       f[i] = 1; n     else n       f[i] = 0; n     g[i] = g[i - 1] + f[i]; n   } n   return f[n]; n } n int main() { n   n = Read(), m = Read(); n   for (int i = 1; i <= n; i++) a[i] = Read(); n   sort(a + 1, a + n + 1); n   int l = 0, r = a[n], ret = 0; n   while (l <= r) { n     int mid = l + r >> 1; n     if (Chk(mid)) n       ret = mid, r = mid - 1; n     else n       l = mid + 1; n   } n   return printf( %d n , ret), 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int t; n int main() { n   ios_base::sync_with_stdio(0); n   cin.tie(0); n   cin >> t; n   while (t--) { n     int m; n     int n; n     cin >> m >> n; n     vector<int> a[500]; n     vector<int> b[500]; n     for (int i = 0; i < m; i++) { n       for (int j = 0; j < n; j++) { n         int temp; n         cin >> temp; n         a[i].push_back(temp); n       } n     } n     for (int i = 0; i < n; i++) { n       for (int j = 0; j < m; j++) { n         int temp; n         cin >> temp; n         b[i].push_back(temp); n       } n     } n     pair<int, int> place; n     for (int i = 0; i < n; i++) { n       for (int j = 0; j < m; j++) { n         if (a[0][0] == b[i][j]) { n           place = make_pair(i, j); n         } n       } n     } n     map<int, int> rows; n     for (int i = 0; i < m; i++) { n       rows.insert({a[i][0], i}); n     } n     for (int i = 0; i < m; i++) { n       for (int j = 0; j < n; j++) { n         cout << a[rows[b[place.first][i]]][j] <<    ; n       } n       cout <<   n ; n     } n   } n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n signed main() { n   ios::sync_with_stdio(false); n   cin.tie(0); n   int t; n   cin >> t; n   auto solve = []() { n     int n; n     cin >> n; n     vector<pair<int, int>> a(n); n     for (int i = 0; i < n; i++) { n       cin >> a[i].first; n       a[i].first--; n     } n     vector<int> ans(n + n); n     vector<int> used(n + n); n     for (int i = 0; i < n; i++) { n       ans[i * 2] = a[i].first; n       a[i].second = i * 2; n       used[a[i].first] = 1; n     } n     for (int i = 1; i < n + n; i += 2) { n       int x = ans[i - 1]; n       int j; n       for (j = x + 1; j < n + n && used[j]; j++) n         ; n       if (j == n + n) { n         cout << -1 <<   n ; n         return 0; n       } n       used[j] = 1; n       ans[i] = j; n     } n     for (int i = 0; i < n + n; i++) { n       if (i > 0) cout <<    ; n       cout << ans[i] + 1; n     } n     cout <<   n ; n   }; n   while (t--) solve(); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n long long int res(long long int x) { n   long long int ans = 0; n   if (x > 0) ans = (x * (x - 1)) / 2; n   return ans; n } n int main() { n   long int n; n   long long int d; n   cin >> n >> d; n   vector<long long int> vect; n   long long int x; n   for (long int i = 0; i < n; i++) { n     cin >> x; n     vect.push_back(x); n   } n   vector<long long int>::iterator it, it2; n   long long int ans = 0; n   for (long int i = 2; i < n; i++) { n     it = lower_bound(vect.begin(), vect.end(), vect[i] - d); n     if (it != vect.end()) { n       ans = ans + res(i - (it - vect.begin())); n     } n   } n   cout << ans; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n bool Check(int N, int pos) { return (bool)(N & (1 << pos)); } n int Set(int N, int pos) { return (N | (1 << pos)); } n long long BigMod(long long B, long long P, long long M) { n   long long R = 1; n   while (P > 0) { n     if (P % 2 == 1) { n       R = (R * B) % M; n     } n     P /= 2; n     B = (B * B) % M; n   } n   return R; n } n int n, m; n vector<pair<double, int> > v; n int dp[5005][5005][2]; n inline int call(int pos, int got, int stat) { n   if (got > m) return 10000; n   if (pos == n) { n     if (got == m) n       return 0; n     else n       return 10000; n   } n   if (dp[pos][got][stat] != -1) return dp[pos][got][stat]; n   int ret = 0; n   int g = 0; n   if (v[pos].second != got and stat == 0) g = 1; n   ret = min(call(pos + 1, got, 0), call(pos, got + 1, 1)); n   return dp[pos][got][stat] = ret + g; n } n int main() { n   ios_base::sync_with_stdio(0); n   cin.tie(nullptr); n   memset(dp, -1, sizeof(dp)); n   cin >> n >> m; n   v.resize(n); n   for (int i = 0; i < n; i++) { n     cin >> v[i].second >> v[i].first; n   } n   sort(v.begin(), v.end()); n   int mx = 10000; n   for (int i = 0; i < m; i++) { n     mx = min(mx, call(0, i + 1, 0)); n   } n   cout << mx; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n char bd[1100][1100]; n int n, m; n int rt[1100][1100]; n int down[1100][1100]; n int cnt[1100][1100]; n int check(int width, int height, int x, int y) { n   int filled = 0; n   bool first = true; n   while (true) { n     int godown = down[x][y] - height; n     if (godown < 0) break; n     if (cnt[x][y] - cnt[x][y + width] - cnt[x + down[x][y]][y] + n             cnt[x + down[x][y]][y + width] == n         width * down[x][y]) { n       if (first) { n         filled += width * down[x][y]; n         first = false; n       } else { n         filled += height + width * godown; n       } n     } else n       break; n     if ((y + 1) + width <= m) { n       y++; n       x += godown; n     } else n       break; n   } n   return filled; n } n int main() { n   scanf( %d %d , &n, &m); n   for (int i = 0; i < n; i++) scanf( %s , bd[i]); n   for (int i = n - 1; i >= 0; i--) { n     for (int j = m - 1; j >= 0; j--) { n       if (bd[i][j] ==  . ) { n         rt[i][j] = down[i][j] = 0; n       } else { n         rt[i][j] = 1 + rt[i][j + 1]; n         down[i][j] = 1 + down[i + 1][j]; n       } n     } n   } n   int tlx = -1; n   int tly = -1; n   int tot = 0; n   for (int i = n - 1; i >= 0; i--) { n     for (int j = m - 1; j >= 0; j--) { n       if (bd[i][j] ==  X ) { n         tlx = i; n         tly = j; n         tot++; n       } n       cnt[i][j] = n           (bd[i][j] ==  X ) + cnt[i + 1][j] + cnt[i][j + 1] - cnt[i + 1][j + 1]; n     } n   } n   int best = 1000000000; n   for (int height = 1; height <= down[tlx][tly]; height++) { n     int width = rt[tlx][tly]; n     int filled = check(width, height, tlx, tly); n     if (filled == tot) best = min(best, width * height); n   } n   for (int width = 1; width <= rt[tlx][tly]; width++) { n     int height = down[tlx][tly]; n     int filled = check(width, height, tlx, tly); n     if (filled == tot) best = min(best, width * height); n   } n   printf( %d n , best == 1000000000 ? -1 : best); n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int inf = 1 << 30; n const int N = 100100; n char a[N], b[N]; n int n, m, k, p[27]; n int Par(int i) { return p[i] = (i == p[i]) ? i : Par(p[i]); } n bool same(int i, int j) { return Par(i) == Par(j); } n int comp[27]; n void mrg(int i, int j) { n   if (same(i, j)) return; n   i = Par(i); n   j = Par(j); n   p[i] = p[j]; n   comp[i] += comp[j]; n } n vector<pair<char, char> > v; n int main() { n   scanf( %d , &n); n   scanf( %s , a); n   scanf( %s , b); n   for (int i = 0; i < 26; i++) { n     p[i] = i; n     comp[i] = 1; n   } n   for (int i = 0; i < n; i++) { n     if (same(b[i] -  a , a[i] -  a )) continue; n     mrg(b[i] -  a , a[i] -  a ); n     v.push_back({a[i], b[i]}); n   } n   printf( %d n , v.size()); n   for (auto x : v) printf( %c %c n , x.first, x.second); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n double pi = acos(-1); n struct point { n   int x, y; n } p[2005]; n vector<double> v; n int main() { n   int n; n   scanf( %d , &n); n   for (int i = 1; i <= n; i++) scanf( %d%d , &p[i].x, &p[i].y); n   long long ans = 0; n   for (int i = 1; i <= n; i++) { n     v.clear(); n     for (int j = 1; j <= n; j++) n       if (j != i) v.push_back(atan2(p[j].y - p[i].y, p[j].x - p[i].x)); n     sort(v.begin(), v.end()); n     int k = 0; n     int now = 0; n     for (int j = 0; j < v.size(); j++) { n       while (v[k] + now * pi < v[j] + pi) { n         k++; n         if (k >= v.size()) k = 0, now += 2; n       } n       int w = (j - k >= 0 ? j - k : k - j - 1); n       ans += 1ll * w * (w - 1) / 2 * (n - w - 2) * (n - w - 3) / 2; n     } n   } n   printf( %lld n , ans / 2); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int N = 1e6 + 6, MAX = 2e5 + 5, OO = 1000000009; n long long gcd(long long a, long long b) { return !b ? a : gcd(b, a % b); } n long long lcm(long long x, long long y) { return (x * y / gcd(x, y)); } n long long fact(long long z) { return (z <= 1) ? 1 : z * fact(z - 1); } n int a, b, aa, bb, ans; n void Check(int p) { n   while (a % p == 0) { n     a /= p; n     aa++; n   } n   while (b % p == 0) { n     b /= p; n     bb++; n   } n   ans += abs(aa - bb); n   aa = bb = 0; n } n int main() { n   scanf( %d %d , &a, &b); n   Check(2); n   Check(3); n   Check(5); n   return printf( %d , a == b ? ans : -1), 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int MOD = 1000 * 1000 * 1000 + 7; n const int INF = 2000 * 1000 * 1000; n const double EPS = 1e-9; n const double pi = acos(-1.0); n const int maxn = 100010; n inline long long sqr(int n) { return n * 1ll * n; } n struct Point { n   int x, y; n   Point() {} n   inline bool operator<(const Point& p) const { return y < p.y; } n   inline long long dist_to(const Point& p) const { n     return sqr(x - p.x) + sqr(y - p.y); n   } n }; n Point a[maxn]; n int n, x, sum; n long long minans = INF * 1ll * INF; n inline void update(const Point& p1, const Point& p2) { n   minans = min(minans, p1.dist_to(p2)); n } n inline void go(int l, int r) { n   if (r - l <= 3) { n     for (int i = l; i <= r; i++) n       for (int j = i + 1; j <= r; j++) update(a[i], a[j]); n     sort(a + l, a + r + 1); n     return; n   } n   int mid = (l + r) >> 1; n   int midx = a[mid].x; n   int buf_size = 0; n   go(l, mid - 1); n   go(mid, r); n   static Point buf[maxn]; n   merge(a + l, a + mid, a + mid, a + r + 1, buf); n   copy(buf, buf + (r - l + 1), a + l); n   for (int i = l; i <= r; i++) { n     if (sqr(abs(a[i].x - midx)) < minans) { n       for (int j = buf_size - 1; j >= 0 && sqr(a[i].y - buf[j].y) < minans; j--) n         update(a[i], buf[j]); n       buf[buf_size++] = a[i]; n     } n   } n } n int main() { n   scanf( %d , &n); n   for (int i = 0; i < n; i++) { n     scanf( %d , &x); n     sum += x; n     a[i].x = i + 1; n     a[i].y = sum; n   } n   go(0, n - 1); n   printf( %I64d , minans); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int main() { n   ios::sync_with_stdio(false); n   cin.tie(0); n   long long n, m; n   cin >> n >> m; n   vector<long long> col(m); n   for (long long i = 0; i < m; i++) { n     cin >> col[i]; n   } n   vector<long long> suf(m, 0); n   suf[m - 1] = 0; n   for (long long i = m - 2; i >= 0; i--) { n     suf[i] = suf[i + 1] + col[i + 1]; n   } n   vector<long long> ans; n   for (long long i = 0, cur = 0, r = 0; i < m; i++) { n     ans.push_back(cur); n     r = cur + col[i]; n     if (r > n) { n       cout <<  -1  << endl; n       return 0; n     } n     cur++; n     if (suf[i] < n - r) { n       cout <<  -1  << endl; n       return 0; n     } else if (suf[i] < n - cur) { n       long long pos = n - suf[i]; n       for (long long j = i + 1; j < m; j++) { n         ans.push_back(pos); n         pos += col[j]; n       } n       break; n     } n   } n   for (long long i = 0; i < m; i++) { n     cout << ans[i] + 1 <<    ; n   } n   cout << endl; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const long long MOD = 1e9 + 7; n const int iinf = 1 << 29; n const long long llinf = 1ll << 60; n const double PI = 3.14159265; n mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count()); n long long mrand(long long B) { return (unsigned long long)rng() % B; } n long long cross(pair<long long, long long> p1, pair<long long, long long> p2) { n   return p1.first * p2.second - p2.first * p1.second; n } n bool online(pair<long long, long long> a, pair<long long, long long> b, n             pair<long long, long long> c) { n   pair<long long, long long> p1{b.first - a.first, b.second - a.second}; n   pair<long long, long long> p2{c.first - a.first, c.second - a.second}; n   return cross(p1, p2) == 0; n } n void z_func(vector<int> &z, vector<int> &s, int n) { n   int L = 0, R = 0; n   for (int i = 1; i < n; i++) { n     if (i > R) { n       L = R = i; n       while (R < n && s[R - L] == s[R]) R++; n       z[i] = R - L; n       R--; n     } else { n       int k = i - L; n       if (z[k] < R - i + 1) n         z[i] = z[k]; n       else { n         L = i; n         while (R < n && s[R - L] == s[R]) R++; n         z[i] = R - L; n         R--; n       } n     } n   } n } n const int MXN = 400; n long long ans; n int n, m; n int v[MXN][MXN], up[MXN][MXN], down[MXN][MXN], leftt[MXN][MXN], n     rightt[MXN][MXN], ul[MXN][MXN], ur[MXN][MXN], lol[MXN][MXN], lr[MXN][MXN]; n void populate() { n   for (int i = 0; i < n; ++i) { n     for (int j = 0; j < m; ++j) { n       if (!v[i][j]) continue; n       if (i && v[i - 1][j]) up[i][j] = 1 + up[i - 1][j]; n       if (j && v[i][j - 1]) leftt[i][j] = 1 + leftt[i][j - 1]; n       if (i && j && v[i - 1][j - 1]) ul[i][j] = 1 + ul[i - 1][j - 1]; n       if (i && j != m - 1 && v[i - 1][j + 1]) ur[i][j] = 1 + ur[i - 1][j + 1]; n     } n   } n   for (int i = n - 1; i >= 0; --i) { n     for (int j = m - 1; j >= 0; --j) { n       if (!v[i][j]) continue; n       if (i != n - 1 && v[i + 1][j]) down[i][j] = 1 + down[i + 1][j]; n       if (j != m - 1 && v[i][j + 1]) rightt[i][j] = 1 + rightt[i][j + 1]; n       if (i != n - 1 && j != m - 1 && v[i + 1][j + 1]) n         lr[i][j] = 1 + lr[i + 1][j + 1]; n       if (i != n - 1 && j && v[i + 1][j - 1]) lol[i][j] = 1 + lol[i + 1][j - 1]; n     } n   } n } n void do_lower_leftt(int x, int y) { n   for (int i = x + 1, j = y - 1; i < n && j >= 0 && v[i][j]; ++i, --j) { n     ans += down[x][y] >= 2 * (i - x) && lr[i][j] >= i - x; n     ans += down[x][y] >= i - x && rightt[i][j] >= y - j; n     ans += lr[x][y] >= i - x && rightt[i][j] >= 2 * (y - j); n   } n } n void do_down(int x, int y) { n   for (int i = x + 1; i < n && v[i][y]; ++i) { n     ans += lr[x][y] >= i - x && rightt[i][y] >= i - x; n     ans += rightt[x][y] >= i - x && ur[i][y] >= i - x; n     ans += n         (i - x) % 2 == 0 && lr[x][y] >= (i - x) / 2 && ur[i][y] >= (i - x) / 2; n   } n } n void do_lower_rightt(int x, int y) { n   for (int i = x + 1, j = y + 1; i < n && j < m && v[i][j]; ++i, ++j) { n     ans += rightt[x][y] >= j - y && up[i][j] >= i - x; n     ans += rightt[x][y] >= 2 * (j - y) && ur[i][j] >= i - x; n   } n } n void work() { n   cin >> n >> m; n   for (int i = 0; i < n; ++i) n     for (int j = 0; j < m; ++j) { n       char c; n       cin >> c; n       while (c !=  0  && c !=  1 ) cin >> c; n       v[i][j] = c ==  0  ? 1 : 0; n     } n   populate(); n   for (int i = 0; i < n; ++i) { n     for (int j = 0; j < m; ++j) { n       if (!v[i][j]) continue; n       do_lower_leftt(i, j); n       do_down(i, j); n       do_lower_rightt(i, j); n     } n   } n   cout << ans << endl; n } n int main() { n   ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0); n   work(); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int main() { n   long long int n, i, x, sum = 0; n   long long int c[100009]; n   scanf( %lld %lld , &n, &x); n   for (i = 0; i < n; i++) { n     scanf( %lld , &c[i]); n   } n   sort(c, c + n); n   for (i = 0; i < n; i++) { n     sum = sum + c[i] * x; n     x--; n     if (x == 0) x++; n   } n   printf( %lld n , sum); n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const long long inf = 2147383647; n const double pi = 2 * acos(0.0); n const double eps = 1e-9; n struct debugger { n   template <typename T> n   debugger& operator,(const T& v) { n     cerr << v <<    ; n     return *this; n   } n } dbg; n inline long long gcd(long long a, long long b) { n   a = ((a) < 0 ? -(a) : (a)); n   b = ((b) < 0 ? -(b) : (b)); n   while (b) { n     a = a % b; n     swap(a, b); n   } n   return a; n } n int ext_gcd(int a, int b, int& x, int& y) { n   if (a == 0) { n     x = 0; n     y = 1; n     return b; n   } n   int x1, y1; n   int d = ext_gcd(b % a, a, x1, y1); n   x = y1 - (b / a) * x1; n   y = x1; n   return d; n } n inline long long modInv(int a, int m) { n   int x, y; n   ext_gcd(a, m, x, y); n   if (x < 0) x += m; n   return x; n } n inline long long power(long long a, long long p) { n   long long res = 1, x = a; n   while (p) { n     if (p & 1) res = (res * x); n     x = (x * x); n     p >>= 1; n   } n   return res; n } n inline long long bigmod(long long a, long long p, long long m) { n   long long res = 1, x = a % m; n   while (p) { n     if (p & 1) res = (res * x) % m; n     x = (x * x) % m; n     p >>= 1; n   } n   return res; n } n bool ispalin(string s) { n   string s2 = s; n   reverse(s2.begin(), s2.end()); n   if (s == s2) n     return true; n   else n     return false; n } n int main() { n   string s, t, x; n   cin >> s; n   int len = s.size(); n   for (int i = (0); i <= (len); ++i) { n     for (int j = ( a ); j <= ( z ); ++j) { n       t = s; n       x = j; n       t.insert(i, x); n       if (ispalin(t)) { n         cout << t << endl; n         return 0; n       } n     } n   } n   cout <<  NA  << endl; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int f[4040][4040], n, k, ans; n struct info { n   int be, ti; n } e[4040]; n int main() { n   scanf( %d%d , &n, &k); n   for (int i = 1; i <= n; i++) scanf( %d%d , &e[i].be, &e[i].ti); n   e[n + 1].be = 86401; n   if (n == k) { n     printf( 86400 ); n     return 0; n   } n   f[1][0] = e[1].be + e[1].ti - 1; n   for (int i = 2; i <= n; i++) { n     f[i][0] = max(e[i].be + e[i].ti - 1, f[i - 1][0] + e[i].ti); n     for (int j = 1; j <= min(i, k); j++) { n       if (i - 1 >= j) n         f[i][j] = min(max(f[i - 1][j] + e[i].ti, e[i].be + e[i].ti - 1), n                       f[i - 1][j - 1]); n       else n         f[i][j] = min(e[i].be + e[i].ti - 1, f[i - 1][j - 1]); n     } n   } n   for (int i = 1; i <= n; i++) { n     for (int j = 0; j <= k; j++) { n       ans = max(ans, e[min(n + 1, k - j + i + 1)].be - f[i][j] - 1); n     } n   } n   printf( %d , ans); n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n inline long long fmm(long long a, long long b, long long m = 1000000007) { n   long long r = 0; n   a %= m; n   b %= m; n   while (b > 0) { n     if (b & 1) { n       r += a; n       r %= m; n     } n     a += a; n     a %= m; n     b >>= 1; n   } n   return r % m; n } n inline long long fme(long long a, long long b, long long m = 1000000007) { n   long long r = 1; n   a %= m; n   while (b > 0) { n     if (b & 1) { n       r *= a; n       r %= m; n     } n     a *= a; n     a %= m; n     b >>= 1; n   } n   return r % m; n } n inline long long sfme(long long a, long long b, long long m = 1000000007) { n   long long r = 1; n   a %= m; n   while (b > 0) { n     if (b & 1) r = fmm(r, a, m); n     a = fmm(a, a, m); n     b >>= 1; n   } n   return r % m; n } n std::vector<long long> primes; n long long primsiz; n std::vector<long long> fact; n std::vector<long long> invfact; n inline void sieve(long long n) { n   long long i, j; n   std::vector<bool> a(n); n   a[0] = true; n   a[1] = true; n   for (i = 2; i * i < n; ++i) { n     if (!a[i]) { n       for (j = i * i; j < n; j += i) { n         a[j] = true; n       } n     } n   } n   for (i = 2; i < n; ++i) n     if (!a[i]) primes.push_back(i); n   primsiz = primes.size(); n } n inline void sieve() { n   long long n = 1010000, i, j, k = 0; n   std::vector<bool> a(n); n   primes.resize(79252); n   a[0] = a[1] = true; n   for (i = 2; (j = (i << 1)) < n; ++i) a[j] = true; n   for (i = 3; i * i < n; i += 2) { n     if (!a[i]) { n       k = (i << 1); n       for (j = i * i; j < n; j += k) a[j] = true; n     } n   } n   k = 0; n   for (i = 2; i < n; ++i) n     if (!a[i]) primes[k++] = i; n   primsiz = k; n } n inline bool isPrimeSmall(unsigned long long n) { n   if (((!(n & 1)) && n != 2) || (n < 2) || (n % 3 == 0 && n != 3)) return false; n   for (unsigned long long k = 1; 36 * k * k - 12 * k < n; ++k) n     if ((n % (6 * k + 1) == 0) || (n % (6 * k - 1) == 0)) return false; n   return true; n } n bool _p(unsigned long long a, unsigned long long n) { n   unsigned long long t, u, i, p, c = 0; n   u = n / 2, t = 1; n   while (!(u & 1)) { n     u /= 2; n     ++t; n   } n   p = fme(a, u, n); n   for (i = 1; i <= t; ++i) { n     c = (p * p) % n; n     if ((c == 1) && (p != 1) && (p != n - 1)) return 1; n     p = c; n   } n   if (c != 1) return 1; n   return 0; n } n inline bool isPrime(unsigned long long n) { n   if (((!(n & 1)) && n != 2) || (n < 2) || (n % 3 == 0 && n != 3)) return 0; n   if (n < 1373653) { n     for (unsigned long long k = 1; (((36 * k * k) - (12 * k)) < n); ++k) n       if ((n % (6 * k + 1) == 0) || (n % (6 * k - 1) == 0)) return 0; n     return 1; n   } n   if (n < 9080191) { n     if (_p(31, n) || _p(73, n)) return 0; n     return 1; n   } n   if (_p(2, n) || _p(7, n) || _p(61, n)) return 0; n   return 1; n } n unsigned long long nCk(long long n, long long k, n                        unsigned long long m = 1000000007) { n   if (k < 0 || k > n || n < 0) return 0; n   if (k == 0 || k == n) return 1; n   if (fact.size() >= (unsigned long long)n && isPrime(m)) { n     return (((fact[n] * invfact[k]) % m) * invfact[n - k]) % m; n   } n   unsigned long long i = 0, j = 0, a = 1; n   k = ((k) < (n - k) ? (k) : (n - k)); n   for (; i < (unsigned long long)k; ++i) { n     a = (a * (n - i)) % m; n     while (j < (unsigned long long)k && (a % (j + 1) == 0)) { n       a = a / (j + 1); n       ++j; n     } n   } n   while (j < (unsigned long long)k) { n     a = a / (j + 1); n     ++j; n   } n   return a % m; n } n void nCkInit(unsigned long long m = 1000000007) { n   long long i, mx = 1010000; n   fact.resize(mx + 1); n   invfact.resize(mx + 1); n   fact[0] = 1; n   for (i = 1; i <= mx; ++i) { n     fact[i] = (i * fact[i - 1]) % m; n   } n   invfact[mx] = fme(fact[mx], m - 2, m); n   for (i = mx - 1; i >= 0; --i) { n     invfact[i] = (invfact[i + 1] * (i + 1)) % m; n   } n } n template <class T> n T gcd(T a, T b) { n   if (b == 0) return a; n   return gcd(b, a % b); n } n void extGCD(long long a, long long b, long long &x, long long &y) { n   if (b == 0) { n     x = 1, y = 0; n     return; n   } n   long long x1, y1; n   extGCD(b, a % b, x1, y1); n   x = y1; n   y = x1 - (a / b) * y1; n } n inline void get(long long &x) { n   int n = 0; n   x = 0; n   char c = getchar_unlocked(); n   if (c ==  - ) n = 1; n   while (c <  0  || c >  9 ) { n     c = getchar_unlocked(); n     if (c ==  - ) n = 1; n   } n   while (c >=  0  && c <=  9 ) { n     x = (x << 3) + (x << 1) + c -  0 ; n     c = getchar_unlocked(); n   } n   if (n) x = -x; n } n inline int get(char *p) { n   char c = getchar_unlocked(); n   int i = 0; n   while (c !=   n  && c !=   0  && c !=     && c !=   r  && c != EOF) { n     p[i++] = c; n     c = getchar_unlocked(); n   } n   p[i] =   0 ; n   return i; n } n inline void put(long long a) { n   int n = (a < 0 ? 1 : 0); n   if (n) a = -a; n   char b[20]; n   int i = 0; n   do { n     b[i++] = a % 10 +  0 ; n     a /= 10; n   } while (a); n   if (n) putchar_unlocked( - ); n   i--; n   while (i >= 0) putchar_unlocked(b[i--]); n   putchar_unlocked(   ); n } n inline void putln(long long a) { n   int n = (a < 0 ? 1 : 0); n   if (n) a = -a; n   char b[20]; n   int i = 0; n   do { n     b[i++] = a % 10 +  0 ; n     a /= 10; n   } while (a); n   if (n) putchar_unlocked( - ); n   i--; n   while (i >= 0) putchar_unlocked(b[i--]); n   putchar_unlocked(  n ); n } n const int K = 3; n std::vector<std::vector<long long> > mul(std::vector<std::vector<long long> > a, n                                          std::vector<std::vector<long long> > b, n                                          unsigned long long m = 1000000007) { n   std::vector<std::vector<long long> > c(K, std::vector<long long>(K)); n   for (int ii = 0; ii < (K); ++ii) n     for (int jj = 0; jj < (K); ++jj) n       for (int kk = 0; kk < (K); ++kk) n         c[ii][jj] = (c[ii][jj] + a[ii][kk] * b[kk][jj]) % m; n   return c; n } n std::vector<std::vector<long long> > fme(std::vector<std::vector<long long> > a, n                                          unsigned long long n, n                                          unsigned long long m = 1000000007) { n   if (n == 1) return a; n   if (n & 1) return mul(a, fme(a, n - 1, m), m); n   std::vector<std::vector<long long> > x = fme(a, n / 2, m); n   return mul(x, x, m); n } n int main() { n   std::ios_base::sync_with_stdio(false); n   std::cin.tie(NULL); n   std::cout.tie(NULL); n   long long t = 0, n = 0, m = 0, maxx = 0, minn = 0, curr = 0, k = 0, num = 0, n             siz = 0, n1 = 0, n2 = 0, n3 = 0, n4 = 0, ind = 0; n   long long root = 0, sum = 0, diff = 0, q = 0, choice = 0, d = 0, len = 0, n             begg = 0, endd = 0, pos = 0, cnt = 0, lo = 0, hi = 0, mid = 0, n             ans = 0; n   bool flag = false; n   std::string s1, s2, s3, str; n   char ch, ch1, ch2, ch3, *ptr; n   double dub = 0; n   cin >> n1 >> n2; n   root = 1; n   while (1) { n     if (pos == 0) { n       if (n1 < root) break; n       n1 -= root; n     } else { n       if (n2 < root) break; n       n2 -= root; n     } n     ++root; n     pos = 1 - pos; n   } n   if (pos == 0) n     cout <<  Vladik ; n   else n     cout <<  Valera ; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n long long t = 1; n void solve() { n   long long n, x, y, cnt = 0, p = 1; n   cin >> n; n   vector<long long> arr(n + 1), vis(n + 1, 0); n   vector<vector<long long> > v(n + 1); n   for (long long i = 0; i < n - 1; i += 1) { n     cin >> x >> y; n     v[x].push_back(y); n     v[y].push_back(x); n   } n   queue<long long> q1, q; n   for (long long i = 0; i < n; i += 1) { n     cin >> x; n     arr[i] = x; n     q1.push(x); n   } n   q.push(1); n   q1.pop(); n   while (!q.empty()) { n     x = q.front(); n     vector<long long> vv; n     set<long long> s; n     cnt = 0; n     for (long long i = 0; i < int((v[x]).size()); i += 1) { n       if (vis[v[x][i]] == 0) { n         cnt++; n         vv.push_back(v[x][i]); n       } n     } n     vis[q.front()] = 1; n     q.pop(); n     for (long long i = p; i < p + cnt; i += 1) { n       s.insert(arr[i]); n       q.push(arr[i]); n       vis[arr[i]] = 1; n     } n     for (long long i = 0; i < int((vv).size()); i += 1) { n       if (((s).find(vv[i]) != (s).end())) { n         s.erase(vv[i]); n       } else { n         cout <<  No ; n         return; n       } n     } n     p = p + cnt; n   } n   cout <<  Yes ; n } n int main() { n   ios_base::sync_with_stdio(false); n   cin.tie(0); n   cout.tie(0); n   while (t--) solve(); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n pair<int, int> point[100]; n double ang[100]; n double dp[10000000]; n int i, j, k, N, M, K, l, r; n void clear() {} n void init() { n   scanf( %d%d%d , &N, &l, &r); n   for (i = 0; i <= N - 1; i++) { n     int first; n     scanf( %d%d%d , &point[i].first, &point[i].second, &first); n     ang[i] = (first * 1.0) * 3.1415926535 / 180.0; n   } n } n double func(int a, int h, double ang, double st) { n   double alpha = atan(fabs(a - st) / h); n   if (a > st) { n     double beta = alpha - ang; n     if (beta > 0) { n       double q = h * tan(beta); n       return min(1.0 * r, a - q); n     } else { n       beta *= -1; n       return min(1.0 * r, a + h * tan(beta)); n     } n   } else { n     if (alpha + ang > 3.1415926535 / 2) { n       return 1.0 * r; n     } else { n       double beta = alpha + ang; n       return min(1.0 * r, h * tan(beta) + a); n     } n   } n } n void calc() { n   for (i = 0; i <= (1 << N) - 1; i++) { n     dp[i] = l * 1.0; n   } n   for (i = 0; i <= (1 << N) - 1; i++) { n     for (j = 0; j <= N - 1; j++) { n       if (!(i & (1 << j))) n         dp[i | (1 << j)] = n             max(dp[i | (1 << j)], n                 func(point[j].first, point[j].second, ang[j], dp[i])); n     } n   } n   printf( %.8f n , dp[(1 << N) - 1] - l); n } n int main() { n   clear(); n   init(); n   calc(); n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int vis[100005], n, m, x, y, mi, eg, re; n char t; n vector<vector<pair<int, int> > > adj; n vector<vector<int> > re1; n vector<int> t0, t1; n void dfs(int u, int ty) { n   if (vis[u] == -1) { n     vis[u] = ty; n     if (ty == 0) n       t0.push_back(u); n     else n       t1.push_back(u); n     for (int j = 0; j < adj[u].size(); j++) { n       pair<int, int> te = adj[u][j]; n       if (te.second == eg) n         dfs(te.first, ty); n       else n         dfs(te.first, 1 - ty); n     } n   } else if (vis[u] != ty) { n     mi = -1; n     return; n   } n } n int main() { n   cin >> n >> m; n   adj.assign(n + 1, vector<pair<int, int> >(0)); n   re1.assign(2, vector<int>(0)); n   for (int i = 0; i < m; i++) { n     cin >> x >> y >> t; n     adj[x].push_back(pair<int, int>(y, t ==  B )); n     adj[y].push_back(pair<int, int>(x, t ==  B )); n   } n   memset(vis, -1, sizeof(vis)); n   mi = 0; n   eg = 1; n   for (int i = 1; i <= n; i++) { n     t0.clear(); n     t1.clear(); n     if (vis[i] == -1) dfs(i, 0); n     if (mi == -1) break; n     if (t0.size() < t1.size()) { n       mi += t0.size(); n       for (int j = 0; j < t0.size(); j++) re1[0].push_back(t0[j]); n     } else { n       mi += t1.size(); n       for (int j = 0; j < t1.size(); j++) re1[0].push_back(t1[j]); n     } n   } n   re = mi; n   memset(vis, -1, sizeof(vis)); n   mi = 0; n   eg = 0; n   for (int i = 1; i <= n; i++) { n     t0.clear(); n     t1.clear(); n     if (vis[i] == -1) dfs(i, 0); n     if (mi == -1) break; n     if (t0.size() < t1.size()) { n       mi += t0.size(); n       for (int j = 0; j < t0.size(); j++) re1[1].push_back(t0[j]); n     } else { n       mi += t1.size(); n       for (int j = 0; j < t1.size(); j++) re1[1].push_back(t1[j]); n     } n   } n   if (mi == -1) { n     if (re == -1) n       cout << -1 << endl; n     else { n       cout << re << endl; n       for (int i = 0; i < re1[0].size(); i++) cout << re1[0][i] <<    ; n       cout << endl; n     } n   } else if (re == -1) { n     cout << mi << endl; n     for (int i = 0; i < re1[1].size(); i++) cout << re1[1][i] <<    ; n     cout << endl; n   } else { n     if (mi < re) { n       cout << mi << endl; n       for (int i = 0; i < re1[1].size(); i++) cout << re1[1][i] <<    ; n       cout << endl; n     } else { n       cout << re << endl; n       for (int i = 0; i < re1[0].size(); i++) cout << re1[0][i] <<    ; n       cout << endl; n     } n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int hashCh = 31; n struct HashCh { n   string code; n   int number; n }; n long long getHash(string text) { n   long long hash = 0; n   int size = text.size(); n   for (int i = 0; i < size; i++) { n     int ch = static_cast<int>(text[i]); n     hash += pow(hashCh, i) * ch; n   } n   return hash; n } n int main() { n   vector<string> password; n   map<long long, HashCh> numbers; n   char buf[80]; n   string oneNumber; n   for (int i = 0; i < 80; i++) { n     char ch; n     cin >> ch; n     oneNumber += ch; n     if ((i % 10) == 9) { n       password.push_back(oneNumber); n       oneNumber =   ; n     } n   } n   for (int i = 0; i < 10; i++) { n     string number; n     cin >> number; n     HashCh ch = HashCh(); n     ch.code = number; n     ch.number = i; n     long long hash = getHash(number); n     numbers[hash] = ch; n   } n   vector<int> result; n   for (int i = 0; i < 8; i++) { n     auto it = numbers.find(getHash(password[i])); n     if (it != numbers.end() && it->second.code == password[i]) { n       result.push_back(it->second.number); n     } n   } n   for (auto i = result.begin(); i != result.end(); i++) { n     cout << *i; n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n struct fastIO { n   fastIO() { ios_base::sync_with_stdio(0); } n }; n const int MAXN = 1e6 * 2; n long long n, a[MAXN], x, ans = MAXN, b; n int main() { n   fastIO(); n   cin >> n; n   for (long long i = 0; i < n; i++) cin >> a[i]; n   for (x = 0; x < n; x++) { n     b = 0; n     for (long long i = 0; i < n; i++) { n       b += (abs(x - i) + i + x) * a[i] * 2; n     } n     if (0) cerr << ans << endl; n     ans = min(ans, b); n   } n   cout << ans; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int main() { n   int t; n   cin >> t; n   while (t--) { n     int n, k, x; n     cin >> n >> k; n     char s; n     string str; n     int p = n / k, q = n % k; n     for (int i = 0; i < k; ++i) { n       x = i + 97; n       s = x; n       if (i == k - 1) p = p + q; n       for (int j = 0; j < p; ++j) str += s; n     } n     cout << str << endl; n   } n } n "}
+{"func_code_string": "#include<bits/stdc++.h> n using namespace std; n typedef long long ll; n const int maxn=405; n const int P=998244353; n ll dp[2][maxn][maxn][3][3],sum[maxn][maxn]; n int cur,las,n,c[26]; n void add(ll &dpp,ll add) { n  add%=P; n  while(add<0) add+=P; n  dpp+=add; n  while(dpp>=P) dpp-=P; n } n int main() { n  scanf( %d ,&n); n  for(int i=0;i<26;++i) n   scanf( %d ,&c[i]); n  dp[0][0][0][0][0]=1; n  las=1;cur=0; n  for(int i=1;i<=n;++i) { n   swap(las,cur); n   for(int j=0;j<=i;++j) n    for(int k=0;k<=i;++k) n     for(int l=0;l<3;++l) n      for(int m=0;m<3;++m) n       dp[cur][j][k][l][m]=0; n   for(int j=0;j<=i;++j) n    for(int k=0;k<=i;++k) n     for(int l=0;l<3;++l) n      for(int m=0;m<3;++m) { n       if(!dp[las][j][k][l][m])continue; n       add(dp[cur][j][k][m][0],1LL*dp[las][j][k][l][m]*((l||(i<=2))?24:23)%P); n       if(l!=1) add(dp[cur][j+1][k][m][1],dp[las][j][k][l][m]); n       if(l!=2) add(dp[cur][j][k+1][m][2],dp[las][j][k][l][m]); n      } n  }  n  for(int i=0;i<=n;++i) n   for(int j=0;j<=n;++j) n    for(int k=0;k<3;++k) n     for(int kk=0;kk<3;++kk) n      add(sum[i][j],dp[cur][i][j][k][kk]); n  for(int i=n;i>=0;--i) n   for(int j=n;j>=0;--j) n    add(sum[i][j],sum[i+1][j]+sum[i][j+1]-sum[i+1][j+1]); n  ll res=1; n  for(int i=1;i<=n;++i) n   res=res*((i<=2)?26:25)%P; n  for(int i=0;i<26;++i) n   add(res,-sum[c[i]+1][0]); n  for(int i=0;i<26;++i) n   for(int j=i+1;j<26;++j) n    add(res,sum[c[i]+1][c[j]+1]); n  res+=P; n  res%=P; n  printf( %lld n ,res); n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n long long gcd(long long a, long long b) { n   a = abs(a), b = abs(b); n   if (a < b) swap(a, b); n   return b ? gcd(b, a % b) : a; n } n vector<vector<int> > adj; n set<int> st; n const int dx[] = {0, 0, -1, 1}; n const int dy[] = {-1, 1, 0, 0}; n long long n, ary[300000 + 5] = {4, 8, 15, 16, 23, 42}, dp[300000 + 5]; n int main(void) { n   ios::sync_with_stdio(false), cin.tie(NULL); n   cin >> n; n   for (int i = 0, j, x; i < n; ++i) { n     cin >> x; n     j = lower_bound(ary, ary + 6, x) - ary; n     if (j == 0) n       dp[0] += 1; n     else if (dp[j - 1]) { n       dp[j - 1] -= 1; n       dp[j] += 1; n     } n   } n   cout << n - dp[5] * 6; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n vector<int> v[100001]; n int n, cost[100001]; n int gr, nod, gr2; n void DFS(int x, int t, int val) { n   for (int i = 1; i <= v[x][0]; i++) { n     if (v[x][i] != t) { n       if (val == 0) { n         DFS(v[x][i], x, cost[v[x][i]]); n       } else { n         if (val != cost[v[x][i]]) { n           gr++; n           if (nod != x) gr2++; n           nod = x; n         } n         DFS(v[x][i], x, cost[v[x][i]]); n       } n     } n   } n } n int main() { n   int a, b, i, j; n   cin >> n; n   for (i = 1; i <= n; i++) { n     v[i].push_back(0); n   } n   for (i = 1; i < n; i++) { n     cin >> a >> b; n     v[a][0]++; n     v[b][0]++; n     v[a].push_back(b); n     v[b].push_back(a); n   } n   for (i = 1; i <= n; i++) cin >> cost[i]; n   DFS(1, 0, 0); n   if (gr2 <= 2) { n     if (gr == 0) { n       cout <<  YES  n            <<   n  n            << 1; n     } else { n       gr = 0; n       DFS(nod, 0, 0); n       if (gr != 0) { n         cout <<  NO ; n       } else { n         cout <<  YES ; n         cout <<   n  << nod; n       } n     } n   } else { n     cout <<  NO ; n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int Ans[1001], A[1001], B[1001], C[1001], D[1001], E[1001]; n int value(int Arr[], int i, int j, int k) { n   return (Arr[j] - Arr[i]) * (Arr[k] - Arr[i]); n } n int main() { n   int n; n   cin >> n; n   for (int i = 0; i < n; i++) { n     cin >> A[i] >> B[i] >> C[i] >> D[i] >> E[i]; n   } n   int index = 0; n   for (int i = 0; i < n; i++) { n     for (int j = 0; j < n; j++) { n       if (j != i) { n         for (int k = 0; k < n; k++) { n           if (k != i && k != j) { n             if ((value(A, i, j, k) + value(B, i, j, k) + value(C, i, j, k) + n                  value(D, i, j, k) + value(E, i, j, k)) > 0) { n               Ans[i] = -1; n               break; n             } n           } n         } n       } n     } n   } n   int count = 0; n   for (int i = 0; i < n; i++) { n     if (Ans[i] != -1) { n       count++; n     } n   } n   cout << count << endl; n   for (int i = 0; i < n; i++) { n     if (Ans[i] != -1) { n       cout << i + 1 << endl; n       count++; n     } n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int main() { n   ios_base::sync_with_stdio(false); n   cin.tie(nullptr); n   cout.tie(nullptr); n   int T; n   cin >> T; n   while (T--) { n     int N; n     cin >> N; n     vector<int> a(N); n     ; n     for (int& x : a) cin >> x; n     int ans = (a[0] == 1); n     for (int i = 1; i < N; ++i) { n       if (a[i] == 0) continue; n       int j = i; n       while (j < N && a[j] == 1) ++j; n       ans += (j - i) / 3; n       i = j - 1; n     } n     cout << ans <<   n ; n   } n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n using ll = long long; n using Vi = vector<int>; n using Pii = pair<int, int>; n int uplg(int n) { return 32 - __builtin_clz(n); } n int uplg(ll n) { return 64 - __builtin_clzll(n); } n void run(); n int main() { n   cin.sync_with_stdio(0); n   cin.tie(0); n   cout << fixed << setprecision(12); n   run(); n   cout << flush; n   _Exit(0); n } n ll ch2(ll n) { return n * (n - 1) / 2; } n ll ch3(ll n) { return n * (n - 1) * (n - 2) / 6; } n void run() { n   int n; n   double p; n   cin >> n >> p; n   constexpr ll SCALE = 10000; n   ll pScaled = llround(p * SCALE); n   ll low = pScaled * ch3(n) * 2; n   for (int a = (0); a < (n + 1); a++) { n     ll cur = (ch3(a) * 2 + ch2(a) * (n - a) * 2 + a * ch2(n - a)) * SCALE; n     if (cur >= low) { n       cout << a <<   n ; n       return; n     } n   } n   assert(0); n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int main() { n   string q[41]; n   long long n, p, i, count = 1, check = 1; n   cin >> n >> p; n   for (i = 0; i < n; i++) cin >> q[i]; n   for (i = n - 2; i >= 0; i--) { n     if (q[i] ==  halfplus ) { n       count = count * 2 + 1; n       check++; n     } else n       count = count * 2; n   } n   cout << p * count - (p / 2) * check << endl; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n void solve(); n const int N = 10000005; n long long i, j, n, s; n int main() { n   ios_base::sync_with_stdio(false); n   cin.tie(NULL); n   int t = 1; n   while (t--) { n     solve(); n     cout <<   n ; n   } n   return 0; n } n void solve() { n   cin >> n; n   for (i = 1; i <= n; i = i * 10) { n     s += n - i + 1; n   } n   cout << s; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n long long mod = 1000000007; n int main() { n   long long dp[3001][100][2] = {0}; n   long long n, l; n   cin >> n >> l; n   vector<long long> a(n), b(n); n   for (long long i = 0; i < n; ++i) { n     cin >> a[i] >> b[i]; n     dp[a[i]][i][0] = 1; n     dp[b[i]][i][1] = 1; n   } n   for (long long i = 1; i <= l; ++i) { n     for (long long j = 0; j < n; ++j) { n       for (long long k = 0; k < n; ++k) { n         if (j != k) { n           if (a[j] == b[k] && i - a[j] >= 0) { n             dp[i][j][0] = (dp[i][j][0] + dp[i - a[j]][k][0]) % mod; n           } n           if (a[j] == a[k] && a[k] != b[k] && i - a[j] >= 0) { n             dp[i][j][0] = (dp[i][j][0] + dp[i - a[j]][k][1]) % mod; n           } n           if (b[j] == b[k] && a[j] != b[j] && i - b[j] >= 0) { n             dp[i][j][1] = (dp[i][j][1] + dp[i - b[j]][k][0]) % mod; n           } n           if (b[j] == a[k] && a[j] != b[j] && a[k] != b[k] && i - b[j] >= 0) { n             dp[i][j][1] = (dp[i][j][1] + dp[i - b[j]][k][1]) % mod; n           } n         } n       } n     } n   } n   long long res = 0; n   for (long long i = 0; i < n; ++i) { n     res = (res + dp[l][i][0]) % mod; n     if (a[i] != b[i]) res = (res + dp[l][i][1]) % mod; n   } n   cout << res << endl; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int par[100005], val[100005]; n int lefm[100005], rim[100005]; n int root = 0; n vector<vector<int> > adjl; n int n; n void pre(int node) { n   if (adjl[node].size() == 0) { n     lefm[node] = val[node]; n     rim[node] = val[node]; n     return; n   } n   for (int i = (0); i < (adjl[node].size()); ++i) { n     pre(adjl[node][i]); n     if (val[adjl[node][i]] < val[node]) n       lefm[node] = lefm[adjl[node][i]]; n     else n       rim[node] = rim[adjl[node][i]]; n   } n } n double res[100005]; n pair<int, int> qu[100005]; n void query(int node, int left, int right, long long cost, int dep) { n   if (adjl[node].size() == 0) { n     for (int i = (left); i < (right); ++i) res[qu[i].second] += cost * 1. / dep; n     return; n   } n   int ind = lower_bound(qu + left, qu + right, make_pair(val[node], 0)) - qu; n   if (ind > left && adjl[node].size() == 2) n     query(adjl[node][0], left, ind, cost + lefm[adjl[node][1]], dep + 1); n   if (ind < right && adjl[node].size() == 2) n     query(adjl[node][1], ind, right, cost + rim[adjl[node][0]], dep + 1); n } n int main() { n   int x, y, k; n   scanf( %d , &n); n   adjl.clear(); n   adjl.resize(n); n   for (int i = (0); i < (n); ++i) { n     scanf( %d %d , &x, &y); n     x--; n     val[i] = y; n     par[i] = x; n     if (x >= 0) adjl[x].push_back(i); n     if (x < 0) root = i; n   } n   for (int i = (0); i < (adjl.size()); ++i) { n     if (adjl[i].size() == 2) n       if (val[adjl[i][0]] > val[adjl[i][1]]) swap(adjl[i][0], adjl[i][1]); n     if (adjl[i].size() == 1) throw 2; n   } n   pre(root); n   scanf( %d , &k); n   for (int i = (0); i < (k); ++i) scanf( %d , &qu[i].first), qu[i].second = i; n   sort(qu, qu + k); n   query(root, 0, k, 0, 0); n   for (int i = (0); i < (k); ++i) printf( %.12lf n , res[i]); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n long double judge1(long long k, long long d, long long t) { n   long double ans; n   long double unit = k + (d - k) * 1.0 / 2; n   ans = floor(t / unit) * d; n   long double res = t * 1.0 - floor(t / unit) * unit; n   if (res <= k) { n     ans += res; n     return ans; n   } else { n     ans += k; n     res -= k; n   } n   ans += (res * 2); n   return ans; n } n long double judge2(long long k, long long d, long long t) { n   long double ans; n   ans = t; n   return ans; n } n long double judge3(long long k, long long d, long long t) { n   long double ans; n   long double unitt = (k / d + 1) * d * 1.0; n   long double unitw = k + (unitt - k) / 2.0; n   ans += floor(t / unitw) * unitt; n   long double res = t - floor(t / unitw) * unitw; n   if (fabs(res - k) <= 1e-9 || res < k) { n     ans += res; n     return ans; n   } else { n     ans += k; n     res -= k; n   } n   ans += (res * 2.0); n   return ans; n } n int main() { n   ios::sync_with_stdio(false); n   long long k, d, t; n   while (cin >> k >> d >> t) { n     long double ans; n     if (k < d) n       ans = judge1(k, d, t); n     else if (k % d == 0) n       ans = judge2(k, d, t); n     else n       ans = judge3(k, d, t); n     cout << fixed << setprecision(1) << ans << endl; n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int main() { n   ios_base::sync_with_stdio(0); n   cin.tie(0); n   cout.tie(0); n   int n, k; n   cin >> n >> k; n   vector<bool> pref(1 << n); n   for (int i = 0; i < k; i++) { n     int x; n     cin >> x; n     pref[x - 1] = true; n   } n   const int oo = -1; n   vector<vector<vector<int>>> dp( n       4, vector<vector<int>>(n + 1, vector<int>(1 << n, oo))); n   for (int i = 0; i < (1 << n); i += 2) { n     if (pref[i] && pref[i + 1]) n       dp[3][1][i] = 1; n     else if (pref[i] || pref[i + 1]) n       dp[1][1][i] = dp[2][1][i] = 1; n     else n       dp[0][1][i] = 0; n   } n   for (int i = 2; i <= n; i++) n     for (int j = 0; j < (1 << n); j += (1 << i)) n       for (int p = 0; p < 4; p++) n         for (int q = 0; q < 4; q++) n           if (dp[p][i - 1][j] != -1 && dp[q][i - 1][j + (1 << (i - 1))] != -1) { n             int t = dp[p][i - 1][j] + dp[q][i - 1][j + (1 << (i - 1))]; n             int upper = ((p & 2) > 0) + ((q & 2) > 0); n             int lower = ((p & 1) + (q & 1)); n             if (upper == 2) { n               t += (lower > 0) + 2; n               dp[3][i][j] = max(dp[3][i][j], t); n               if (lower < 2) dp[2][i][j] = max(dp[2][i][j], t); n             } else if (upper == 1) { n               t += (lower > 0) + 1; n               if (lower == 0) { n                 dp[2][i][j] = max(dp[2][i][j], t); n                 dp[1][i][j] = max(dp[1][i][j], t + 1); n                 dp[0][i][j] = max(dp[0][i][j], t + 1); n               } n               if (lower == 1) { n                 dp[3][i][j] = max(dp[3][i][j], t + 1); n                 dp[2][i][j] = max(dp[2][i][j], t + 1); n                 dp[1][i][j] = max(dp[1][i][j], t + 1); n                 dp[0][i][j] = max(dp[0][i][j], t + 1); n               } n               if (lower == 2) { n                 dp[3][i][j] = max(dp[3][i][j], t + 1); n                 dp[2][i][j] = max(dp[2][i][j], t + 1); n                 dp[1][i][j] = max(dp[1][i][j], t + 1); n               } n             } else if (upper == 0) { n               t += (lower > 0); n               if (lower == 0) dp[0][i][j] = max(dp[0][i][j], t); n               if (lower == 1) { n                 dp[1][i][j] = max(dp[1][i][j], t + 1); n                 dp[0][i][j] = max(dp[0][i][j], t + 1); n               } n               if (lower == 2) { n                 dp[1][i][j] = max(dp[1][i][j], t + 1); n                 dp[0][i][j] = max(dp[0][i][j], t + 1); n               } n             } n           } n   int ans = 0; n   for (int p = 0; p < 4; p++) ans = max(dp[p][n][0] + (p > 0), ans); n   cout << ans <<   n ; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int n; n int l[2005], r[2005]; n long long k, w[2005]; n long long s[2005][2005]; n long long f[2005]; n long long h[2005]; n long long up(long long x) { return (x / k + (x % k > 0)); } n int main() { n   cin >> n >> k; n   for (int i = (1); i <= (n); i++) cin >> l[i] >> r[i] >> w[i]; n   for (int i = (1); i <= (n); i++) h[i] = -1; n   for (int i = (1); i <= (n); i++) n     for (int j = (1); j <= (n); j++) s[i][j] = -1; n   for (int i = (1); i <= (n); i++) { n     long long start = k; n     long long has = 0; n     for (int j = (i); j <= (n); j++) { n       if (start >= w[j]) { n         if (l[j] < l[j + 1]) s[i][j] = has + start; n         has += w[j]; n         start -= w[j]; n         if (j == n) h[i] = has; n       } else { n         long long t = up(w[j] - start) + 1; n         if (t > r[j] - l[j] + 1) break; n         if (l[j] + t - 1 < l[j + 1]) s[i][j] = has + (t - 1) * k + start; n         has += w[j]; n         if (j == n) h[i] = has; n         start = start + (t - 1) * k - w[j]; n       } n     } n   } n   for (int i = (1); i <= (n - 1); i++) { n     f[i] = -1; n     for (int j = (i - 1); j >= (0); j--) { n       if (s[j + 1][i] >= 0 && f[j] >= 0) n         if (f[i] < 0 || f[j] + s[j + 1][i] < f[i]) f[i] = f[j] + s[j + 1][i]; n     } n   } n   long long ans = -1; n   for (int i = (0); i <= (n - 1); i++) n     if (f[i] >= 0 && h[i + 1] >= 0) { n       if (ans < 0 || f[i] + h[i + 1] < ans) ans = f[i] + h[i + 1]; n     } n   cout << ans << endl; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int maxn = 310; n int n, a[maxn]; n int main() { n   scanf( %d , &n); n   for (int i = (1); i <= (n); ++i) scanf( %d , &a[i]); n   for (int i = (1); i <= (n - 1); ++i) { n     for (int j = (1); j <= (a[i]); ++j) printf( PRL ); n     printf( R ); n   } n   for (int j = (1); j <= (a[n]); ++j) printf( LRP ); n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n long long n, h, ok; n long long cal(long long dep, long long pos, int tag) { n   if (ok) return 0; n   if (dep == 0) { n     ok = 1; n     return 0; n   } n   long long tmp; n   if (!tag) { n     if (pos > (1LL << (dep - 1))) n       tmp = (1LL << dep) + cal(dep - 1, pos - (1LL << (dep - 1)), 0); n     else n       tmp = 1LL + cal(dep - 1, pos, 1); n   } else { n     if (pos > (1LL << (dep - 1))) n       tmp = 1LL + cal(dep - 1, pos - (1LL << (dep - 1)), 0); n     else n       tmp = (1LL << dep) + cal(dep - 1, pos, 1); n   } n   return tmp; n } n int main() { n   while (cin >> h >> n) { n     ok = 0; n     cout << cal(h, n, 0) << endl; n   } n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n long long a[100][100]; n using namespace std; n struct DynamicDisjointSetDS { n   std::unordered_map<int, int> parent, degree; n   int N; n   DynamicDisjointSetDS(int n) { N = n; } n   int getParent(int vertex) { n     if (parent.find(vertex) != parent.end()) { n       if (parent[vertex] != vertex) { n         parent[vertex] = getParent(parent[vertex]); n         return parent[vertex]; n       } n     } else { n       parent.insert(make_pair(vertex, vertex)); n       degree.insert(make_pair(vertex, 1)); n     } n     return vertex; n   } n   void Union(int vertexA, int vertexB) { n     int x = getParent(vertexA); n     int y = getParent(vertexB); n     if (x == y) return; n     if (degree[x] > degree[y]) { n       parent[y] = x; n       degree[x] = degree[x] + degree[y]; n     } else { n       parent[x] = y; n       degree[y] = degree[y] + degree[x]; n     } n   } n   int GetTotalComponent() { n     unordered_set<int> total; n     for (auto itr = parent.begin(); itr != parent.end(); itr++) { n       total.insert(getParent(itr->first)); n     } n     return N - parent.size() + total.size(); n   } n }; n int main() { n   using namespace std; n   long long n, m, q; n   cin >> n >> m >> q; n   unordered_set<long long> s, s2; n   for (long long i = 1; i <= n; i++) { n     s.insert(i); n   } n   for (long long i = 1; i <= m; i++) { n     s2.insert(i); n   } n   DynamicDisjointSetDS ds(m + 1); n   vector<vector<long long>> v(m + 1); n   while (q--) { n     long long r, c; n     cin >> r >> c; n     v[c].push_back(r); n     s.erase(r); n     s2.erase(c); n   } n   for (vector<long long> v2 : v) { n     for (long long i = 1; i < v2.size(); i++) { n       ds.Union(v2[i], v2[i - 1]); n     } n   } n   unordered_set<long long> sc; n   for (long long i = 1; i <= n; i++) { n     sc.insert(ds.getParent(i)); n   } n   cout << (s2.size() + sc.size() - 1) << endl; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int read() { n   int f = 1, x = 0; n   char c = getchar(); n   while (c <  0  || c >  9 ) { n     if (c ==  - ) f = -f; n     c = getchar(); n   } n   while (c >=  0  && c <=  9 ) x = x * 10 + c -  0 , c = getchar(); n   return f * x; n } n inline int lowbit(int x) { return x & (-x); } n inline int modadd(int x, int y) { n   return (x + y >= 1000000007 ? x + y - 1000000007 : x + y); n } n inline int sgn(int x) { return (x < 0 ? -1 : (x > 0 ? 1 : 0)); } n template <typename T> n T gcd(T a, T b) { n   return (!b) ? a : gcd(b, a % b); n } n int poww(int a, int b) { n   int res = 1; n   while (b > 0) { n     if (b & 1) res = 1ll * res * a % 1000000007; n     a = 1ll * a * a % 1000000007, b >>= 1; n   } n   return res; n } n const int dx[] = {-1, 0, 1, 0}, dy[] = {0, 1, 0, -1}; n const int ddx[] = {-1, -1, -1, 0, 0, 1, 1, 1}, n           ddy[] = {-1, 0, 1, -1, 1, -1, 0, 1}; n int n, a[100005]; n void init() { n   n = read(); n   for (int i = 1; i <= n; ++i) a[i] = read(); n } n bool check1() { n   long long tot = 0; n   for (int i = n - 1; i >= 1; --i) { n     if (a[i] < tot) return false; n     if (a[i] > a[i + 1]) tot += a[i] - a[i + 1]; n   } n   return true; n } n bool check2() { n   long long tot = 0; n   for (int i = 2; i <= n; ++i) { n     if (a[i] < tot) return false; n     if (a[i] > a[i - 1]) tot += a[i] - a[i - 1]; n   } n   return true; n } n void solve() { n   if (check1()) n     printf( YES n ); n   else if (check2()) n     printf( YES n ); n   else n     printf( NO n ); n } n int main() { n   int T = read(); n   while (T--) { n     init(); n     solve(); n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n struct grp { n   long long to, wt, edgeCode; n   char type; n }; n struct Node { n   long long x, dis; n }; n struct comp { n   inline bool operator()(const Node& n1, const Node& n2) const { n     if (n1.dis != n2.dis) return n1.dis < n2.dis; n     return n1.x < n2.x; n   } n }; n void dijkstra(long long n, vector<vector<grp> >& edges, vector<long long>& dis, n               vector<bool>& visited, vector<pair<long long, long long> >& par) { n   set<Node, comp> myset; n   for (long long i = 1; i <= n; ++i) { n     Node node; n     node.x = i, node.dis = dis[i]; n     myset.insert(node); n   } n   while (myset.size()) { n     set<Node>::iterator it = myset.begin(); n     Node node = *it; n     myset.erase(it); n     visited[node.x] = true; n     for (long long i = 0; i < edges[node.x].size(); ++i) { n       grp& edge = edges[node.x][i]; n       if (visited[edge.to]) { n         continue; n       } n       long long newDis = dis[node.x] + edge.wt; n       if (newDis < dis[edge.to] || n           (newDis == dis[edge.to] && edge.type ==  r )) { n         Node prevNode, newNode; n         prevNode.x = edge.to, prevNode.dis = dis[edge.to]; n         newNode.x = edge.to, newNode.dis = newDis; n         dis[edge.to] = newDis; n         par[edge.to] = {node.x, edge.edgeCode}; n         myset.erase(myset.find(prevNode)); n         myset.insert(newNode); n       } n     } n   } n } n int main() { n   ios_base::sync_with_stdio(0); n   cin.tie(0); n   long long n, m, k; n   cin >> n >> m >> k; n   vector<vector<grp> > edges(n + 1); n   long long edgeCode = 0; n   for (long long i = 0; i < m; i++) { n     long long x, y, w; n     cin >> x >> y >> w; n     grp g; n     g.to = y, g.wt = w, g.type =  r , g.edgeCode = edgeCode++; n     edges[x].push_back(g); n     g.to = x, g.edgeCode = edgeCode++; n     edges[y].push_back(g); n   } n   vector<pair<long long, long long> > trainPaths(k); n   for (long long i = 0; i < k; ++i) { n     long long y, w; n     cin >> y >> w; n     trainPaths[i] = {y, edgeCode}; n     grp g; n     g.to = y, g.wt = w, g.type =  t , g.edgeCode = edgeCode++; n     edges[1].push_back(g); n   } n   vector<long long> dis(n + 1, 100000000000000000); n   vector<bool> visited(n + 1, false); n   vector<pair<long long, long long> > par(n + 1, {-1, -1}); n   dis[1] = 0; n   dijkstra(n, edges, dis, visited, par); n   long long ans = 0; n   for (long long i = 0; i < k; ++i) { n     long long dest = trainPaths[i].first, edgeCode = trainPaths[i].second; n     if (par[dest].first == 1 && par[dest].second == edgeCode) { n       continue; n     } n     ++ans; n   } n   cout << ans << endl; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n long long int power(long long int x, long long int b) { n   long long int p = 1; n   while (b > 0) { n     if (b & 1) { n       p = p * x; n       p %= 1000000007; n     } n     b >>= 1; n     x *= x; n     x %= 1000000007; n   } n   return p % 1000000007; n } n using namespace std; n struct lex_compare { n   bool operator()( n       const pair<long long int, pair<long long int, long long int> > p1, n       const pair<long long int, pair<long long int, long long int> > p2) { n     return (p1.first == p2.first) ? p1.second.first < p2.second.first n                                   : p1.first > p2.first; n   } n }; n long long int n, m, b, mo; n long long int dp[2][500 + 1][500 + 1]; n int main() { n   ios_base::sync_with_stdio(false); n   cin.tie(NULL); n   ; n   long long int w, m; n   cin >> w >> m; n   bool f = 1; n   map<long long int, long long int> coeff; n   long long int term = 1; n   while (m >= term && term <= 10000000000) { n     long long int x = (term * (m / term) - (w * term) * (m / (w * term))); n     x /= term; n     if (x <= 1) { n       term *= w; n     } else { n       if (x != (w - 1)) { n         f = 0; n         break; n       } else { n         m += (w * term - term); n       } n       term *= w; n     } n   } n   if (f) n     cout <<  YES  n          <<   n ; n   else n     cout <<  NO  n          <<   n ; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n vector<int> di[100003]; n struct trie { n   trie *zero, *one; n   int val; n   trie() { n     zero = one = NULL; n     val = 100003; n   } n } * root[100003]; n void add(trie *cur, int a) { n   int i, ck; n   for (i = 20; i >= 0; i--) { n     ck = (1 << i & a); n     if (ck == 0) { n       cur->val = min(cur->val, a); n       if (cur->zero == NULL) cur->zero = new trie(); n       cur = cur->zero; n       cur->val = min(cur->val, a); n     } else { n       cur->val = min(cur->val, a); n       if (cur->one == NULL) cur->one = new trie(); n       cur = cur->one; n       cur->val = min(cur->val, a); n     } n   } n } n int query(trie *cur, int a, int lim) { n   int i, ck, ans; n   for (i = 20; i >= 0; i--) { n     ck = (1 << i & a); n     if (ck == 0) { n       if (cur->one != NULL && cur->one->val + a <= lim) n         cur = cur->one; n       else if (cur->zero != NULL) n         cur = cur->zero; n       ans = cur->val; n     } else { n       if (cur->zero != NULL && cur->zero->val + a <= lim) n         cur = cur->zero; n       else if (cur->one != NULL) n         cur = cur->one; n       ans = cur->val; n     } n   } n   return ans; n } n void pre() { n   for (int i = 1; i < 100003; i++) { n     for (int j = i; j < 100003; j += i) di[j].push_back(i); n     root[i] = new trie(); n   } n } n int main() { n   pre(); n   int q, a, k, s, v, ty; n   scanf( %d , &q); n   while (q--) { n     scanf( %d , &ty); n     if (ty == 1) { n       scanf( %d , &a); n       for (int x : di[a]) { n         add(root[x], a); n       } n     } else { n       scanf( %d %d %d , &v, &k, &s); n       if (root[k]->val + v > s || root[k]->val == 0 || v % k) n         printf( -1 n ); n       else n         printf( %d n , query(root[k], v, s)); n     } n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n bool isPrime(int n) { n   if (n <= 1) return false; n   for (int i = 2; i < n; i++) n     if (n % i == 0) return false; n   return true; n } n int main() { n   long long int t; n   cin >> t; n   while (t--) { n     long long int n; n     cin >> n; n     vector<long long int> v; n     for (long long int i = 0; i < n; i++) { n       long long int x; n       cin >> x; n       v.push_back(x); n     } n     if (v[0] + v[1] <= v[n - 1]) { n       cout << 1 <<     << 2 <<     << n <<   n ; n     } else { n       cout << -1 <<   n ; n     } n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n char bb[111][111]; n int in[111][111]; n int main() { n   int n, m; n   cin >> n >> m; n   for (int i = 0; i < n; i++) scanf( %s , bb[i]); n   vector<pair<pair<int, int>, int>> stars; n   for (int i = 1; i < n - 1; i++) { n     for (int j = 1; j < m - 1; j++) { n       if (bb[i][j] !=  * ) continue; n       int l, r, u, d; n       l = r = i; n       u = d = j; n       for (int k = i; k < n; k++) n         if (bb[k][j] ==  * ) n           r = k; n         else n           break; n       for (int k = i; k >= 0; k--) n         if (bb[k][j] ==  * ) n           l = k; n         else n           break; n       for (int k = j; k < m; k++) n         if (bb[i][k] ==  * ) n           d = k; n         else n           break; n       for (int k = j; k >= 0; k--) n         if (bb[i][k] ==  * ) n           u = k; n         else n           break; n       int starLevel = min(min(r - i, i - l), min(d - j, j - u)); n       if (starLevel) { n         for (int k = i - starLevel; k <= i + starLevel; k++) in[k][j] = 1; n         for (int k = j - starLevel; k <= j + starLevel; k++) in[i][k] = 1; n         stars.push_back({{i + 1, j + 1}, starLevel}); n       } n     } n   } n   for (int i = 0; i < n; i++) n     for (int j = 0; j < m; j++) n       if ((bb[i][j] ==  *  && in[i][j] == 0) || n           (in[i][j] == 1 && bb[i][j] ==  . )) n         return puts( -1 ); n   cout << stars.size() << endl; n   for (auto u : stars) { n     printf( %d %d %d n , u.first.first, u.first.second, u.second); n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int N = 1e6 + 500; n const int LN = 21; n const long long mod = 1e9 + 7; n const long long INF = 1LL << 57; n long long n, m, u, v, k, t, q, a, x, d; n int tree[4 * N]; n int sum[4 * N]; n int lim = 1e6 + 2; n int arr[N], brr[N]; n bool print = false; n void modify(int i, int l, int r, int index, int val) { n   if (l == r) { n     tree[i] += val; n     sum[i] = tree[i]; n     return; n   } n   int mid = (l + r) / 2; n   if (index <= mid) n     modify(i + 1 + i, l, mid, index, val); n   else n     modify(i + 2 + i, mid + 1, r, index, val); n   tree[i] = max(tree[i + 2 + i], tree[i + 1 + i] + sum[i + 2 + i]); n   sum[i] = sum[i + 1 + i] + sum[i + 2 + i]; n } n int find(int i, int l, int r, int sumx) { n   if (l == r) return l; n   int mid = (l + r) / 2; n   if (tree[i + 2 + i] + sumx > 0) { n     return find(i + 2 + i, mid + 1, r, sumx); n   } else n     return find(i + 1 + i, l, mid, sumx + sum[i + 2 + i]); n } n int main() { n   ios::sync_with_stdio(false); n   cin.tie(0); n   cin >> n >> m; n   for (int i = 1; i <= n; ++i) { n     cin >> arr[i]; n   } n   for (int i = 1; i <= m; ++i) cin >> brr[i]; n   for (int i = 1; i <= n; ++i) { n     modify(0, 0, lim, arr[i], 1); n   } n   for (int i = 1; i <= m; ++i) { n     modify(0, 0, lim, brr[i], -1); n   } n   cin >> q; n   while (q--) { n     int type; n     cin >> type; n     if (type == 1) { n       int i, x; n       cin >> i >> x; n       modify(0, 0, lim, arr[i], -1); n       modify(0, 0, lim, x, 1); n       arr[i] = x; n       int price = find(0, 0, lim, 0); n       if (price == 0) n         cout << -1 <<   n ; n       else n         cout << price <<   n ; n     } else { n       int i, x; n       cin >> i >> x; n       modify(0, 0, lim, brr[i], 1); n       modify(0, 0, lim, x, -1); n       brr[i] = x; n       int price = find(0, 0, lim, 0); n       if (price == 0) n         cout << -1 <<   n ; n       else n         cout << price <<   n ; n     } n   } n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int main() { n   ios_base::sync_with_stdio(false); n   cin.tie(NULL); n   cout.tie(NULL); n   int n, k, d; n   cin >> n >> k >> d; n   long long a[101], b[101]; n   memset(a, 0, sizeof(a)); n   memset(b, 0, sizeof(b)); n   a[0] = 1; n   long long sum = 0; n   for (int i = 0; i < k; i++) { n     sum += a[i]; n     sum = (sum) % 1000000007; n     a[i + 1] = sum; n   } n   for (int i = k; i < n; i++) { n     sum += a[i]; n     sum -= a[i - k]; n     sum = ((sum % 1000000007) + 1000000007) % 1000000007; n     a[i + 1] = sum; n   } n   for (int i = 1; i < d; i++) { n     b[i] = 0; n   } n   b[d] = 1; n   for (int i = d + 1; i <= k; i++) { n     b[i] = b[i - 1] + b[i - 1] - b[i - d] + a[i - d]; n     b[i] = ((b[i] % 1000000007) + 1000000007) % 1000000007; n   } n   for (int i = k + 1; i <= n; i++) { n     b[i] = b[i - 1] + b[i - 1] - b[i - d] + a[i - d] - a[i - k - 1]; n     b[i] = ((b[i] % 1000000007) + 1000000007) % 1000000007; n   } n   cout << b[n] << endl; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n template <typename T> n void read(T &a) { n   T x = 0, f = 1; n   char ch = getchar(); n   while (ch <  0  || ch >  9 ) { n     if (ch ==  - ) f = -1; n     ch = getchar(); n   } n   while (ch >=  0  && ch <=  9 ) { n     x = (x << 1) + (x << 3) + (ch ^ 48); n     ch = getchar(); n   } n   a = x * f; n } n template <typename T, typename... Args> n void read(T &t, Args &...args) { n   read(t); n   read(args...); n } n long long n, k, a[100005]; n struct node { n   long long len, k; n   bool operator<(const node &x) const { n     long long tmp1 = (len / k) * (len / k) * (k - len % k) + n                      (len / k + 1) * (len / k + 1) * (len % k); n     long long tmp2 = (x.len / x.k) * (x.len / x.k) * (x.k - x.len % x.k) + n                      (x.len / x.k + 1) * (x.len / x.k + 1) * (x.len % x.k); n     long long kk = k + 1; n     long long tmpp1 = (len / kk) * (len / kk) * (kk - len % kk) + n                       (len / kk + 1) * (len / kk + 1) * (len % kk); n     kk = x.k + 1; n     long long tmpp2 = (x.len / kk) * (x.len / kk) * (kk - x.len % kk) + n                       (x.len / kk + 1) * (x.len / kk + 1) * (x.len % kk); n     tmp1 -= tmpp1; n     tmp2 -= tmpp2; n     if (k == len) tmp1 = 0; n     if (x.k == x.len) tmp2 = 0; n     return tmp1 < tmp2; n   } n }; n priority_queue<node> q; n void update(long long &ans, node &x) { n   ans -= (x.len / x.k) * (x.len / x.k) * (x.k - x.len % x.k) + n          (x.len / x.k + 1) * (x.len / x.k + 1) * (x.len % x.k); n   x.k++; n   ans += (x.len / x.k) * (x.len / x.k) * (x.k - x.len % x.k) + n          (x.len / x.k + 1) * (x.len / x.k + 1) * (x.len % x.k); n } n signed main() { n   read(n, k); n   long long ans = 0; n   for (long long i = 1; i <= n; i++) { n     read(a[i]); n     node tmp; n     tmp.len = a[i]; n     tmp.k = 1; n     q.push(tmp); n   } n   for (long long i = 1; i <= n; i++) ans += a[i] * a[i]; n   k -= n; n   while (k) { n     k += 19260817; n     node x = q.top(); n     q.pop(); n     update(ans, x); n     q.push(x); n     k -= 19260818; n   } n   printf( %lld n , ans +  O  -  O ); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n long long n, l, v1, v2, k; n long double dn, dl, dv1, dv2, dk; n long long times; n long double x; n double T; n int main() { n   scanf( %lld%lld%lld%lld%lld , &n, &l, &v1, &v2, &k); n   dn = n; n   dl = l; n   dv1 = v1; n   dv2 = v2; n   dk = k; n   times = (n - 1) / k + 1; n   x = l / (v2 * times - (dv2 - dv1) / (dv2 + dv1) * dv2 * (times - 1)); n   T = x * (times + (dv2 - dv1) / (dv2 + dv1) * (times - 1)); n   printf( %lf n , T); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int const N = 3e5; n int n, p1[N], p2[N], p3[N], num1[N], num2[N], F[N][2], T[N * 4]; n void buildT(int v, int tl, int tr) { n   if (tl == tr) { n     T[v] = 1; n   } else { n     int tm = (tl + tr) / 2; n     buildT(v * 2, tl, tm); n     buildT(v * 2 + 1, tm + 1, tr); n     T[v] = T[v * 2] + T[v * 2 + 1]; n   } n } n void updT(int v, int tl, int tr, int p) { n   if (tl == tr) { n     T[v] = 0; n   } else { n     int tm = (tl + tr) / 2; n     if (tm >= p) n       updT(v * 2, tl, tm, p); n     else n       updT(v * 2 + 1, tm + 1, tr, p); n     T[v] = T[v * 2] + T[v * 2 + 1]; n   } n } n int getT(int v, int tl, int tr, int k) { n   if (tl == tr) { n     return tl; n   } else { n     int tm = (tl + tr) / 2; n     if (T[v * 2] >= k) n       return getT(v * 2, tl, tm, k); n     else n       return getT(v * 2 + 1, tm + 1, tr, k - T[v * 2]); n   } n } n void upd(int x, int t) { n   while (x < n) { n     ++F[x][t]; n     x |= (x + 1); n   } n } n int get(int x, int t) { n   int r = 0; n   while (x >= 0) { n     r += F[x][t]; n     x = (x & (x + 1)) - 1; n   } n   return r; n } n int main() { n   scanf( %d , &n); n   for (int i = 0; i < n; ++i) scanf( %d , &p1[i]); n   for (int i = 0; i < n; ++i) scanf( %d , &p2[i]); n   for (int i = 0; i < n; ++i) { n     num1[i] = p1[i] - get(p1[i], 0); n     upd(p1[i] + 1, 0); n     num2[i] = p2[i] - get(p2[i], 1); n     upd(p2[i] + 1, 1); n   } n   for (int i = n - 1; i >= 0; --i) { n     num1[i] += num2[i]; n     if (i) num1[i - 1] += num1[i] / (n - i); n     num1[i] %= (n - i); n   } n   buildT(1, 0, n - 1); n   for (int i = 0; i < n; ++i) { n     int need = num1[i] + 1; n     int val = getT(1, 0, n - 1, need); n     p3[i] = val; n     updT(1, 0, n - 1, val); n   } n   for (int i = 0; i < n; ++i) printf( %d  , p3[i]); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n vector<long long> v; n long long x, y, z, a, b, c, sum, ans, total, t, cnt, n, m, k, p, kase; n string s1, s2; n map<long long, long long> mp; n set<long long> s; n map<long long, long long>::iterator itr1, ptr1; n set<long long>::iterator itr, ptr; n int main() { n   ios_base::sync_with_stdio(false); n   cin.tie(NULL); n   cout.tie(NULL); n   cin >> t; n   while (t--) { n     long long x1, x2, y1, y2; n     cin >> x1 >> y1 >> x2 >> y2; n     ans = abs(x1 - x2); n     ans *= abs(y1 - y2); n     cout << ans + 1 << endl; n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int N = 3e5 + 10; n long long n, sum, n1, pick, ans, t, a[N], b[N], f[N], f1[N], m, t1; n int main() { n   scanf( %lld , &n); n   for (int i = 1; i <= 8; i++) { n     scanf( %lld , &a[i]); n     sum = sum + a[i] * i; n   } n   if (sum <= n) return printf( %lld n , sum), 0; n   n1 = std::max((long long)0, n - 840), n = n - n1; n   for (int i = 1; i <= 8; i++) { n     if (a[i] < n1 / i) n       pick = a[i]; n     else n       pick = n1 / i; n     if (a[i] - pick < 10) pick = std::max((long long)0, a[i] - 10); n     ans = ans + pick * i, n1 = n1 - pick * i, a[i] = a[i] - pick; n   } n   n += n1; n   for (int i = 1; i <= 8; i++) { n     t = 1; n     while (a[i] > 0) { n       t1 = std::min(t, a[i]); n       a[i] = a[i] - t1; n       f[++m] = t1 * i; n       t <<= 1; n     } n   } n   for (long long i = 1; i <= m; i++) n     for (long long j = n; j >= f[i]; j--) n       f1[j] = std::max(f1[j], f1[j - f[i]] + f[i]); n   printf( %lld n , ans + f1[n]); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n string st[5050]; n int fr[27]; n int main() { n   memset(fr, 0, sizeof(fr)); n   ios::sync_with_stdio(0); n   cin.tie(0); n   cout.tie(0); n   int n, k; n   cin >> k >> n; n   for (int i = 0; i < k; i++) { n     cin >> st[i]; n   } n   string res = st[0]; n   memset(fr, 0, sizeof(fr)); n   bool du = false; n   for (int i = 0; i < n; i++) { n     fr[res[i] -  a ]++; n     if (fr[res[i] -  a ] > 1) { n       du = true; n     } n   } n   int ma = 0; n   int mi = 0; n   bool po = true; n   for (int i = 1; i < k; i++) { n     int df = 0; n     int ct[27] = {0}; n     for (int j = 0; j < n; j++) { n       ct[st[i][j] -  a ]++; n       if (st[i][j] != res[j]) { n         df++; n       } n     } n     if (df > 4) { n       po = false; n       break; n     } n     for (int j = 0; j < 27; j++) { n       if (ct[j] != fr[j]) { n         po = false; n         break; n       } n     } n     if (df > ma) { n       ma = df; n       mi = i; n     } n   } n   if (!po) { n     cout << -1 <<   n ; n     return 0; n   } n   if (ma == 0) { n     swap(res[0], res[1]); n     cout << res <<   n ; n     return 0; n   } n   if (ma == 2) { n     if (!du) { n       cout << -1 <<   n ; n       return 0; n       cout << -1 <<   n ; n       return 0; n     } n     cout << res <<   n ; n     return 0; n   } n   int q[4]; n   int ctr = 0; n   for (int i = 0; i < n; i++) { n     if (res[i] != st[mi][i]) { n       q[ctr++] = i; n     } n   } n   po = false; n   int tr[2] = {0, 0}; n   for (int id = 0; id < 3; id++) { n     if (ma < 4) { n       q[3] = q[id]; n     } else if (id > 0) n       break; n     for (int i = 0; i < 4; i++) { n       for (int j = 0; j < 4; j++) { n         if (po) break; n         int md = 0; n         swap(res[q[i]], res[q[j]]); n         for (int c = 1; c < k; c++) { n           int df = 0; n           for (int l = 0; l < n; l++) { n             if (res[l] != st[c][l]) { n               df++; n             } n           } n           md = max(md, df); n         } n         swap(res[q[i]], res[q[j]]); n         if (md == 2) { n           po = true; n           tr[0] = i; n           tr[1] = j; n         } n       } n     } n   } n   if (po) { n     swap(res[q[tr[0]]], res[q[tr[1]]]); n     cout << res <<   n ; n   } else { n     cout << -1 <<   n ; n   } n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int a[5]; n int main() { n   scanf( %d%d%d%d , &a[0], &a[1], &a[2], &a[3]); n   while (a[0] != 1 || a[1] != 1 || a[2] != 1 || a[3] != 1) { n     bool f = 1; n     for (int i = 0; i < 4; i++) n       if (a[i] % 2 == 0 && a[(i + 1) % 4] % 2 == 0) { n         printf( /%d n , i + 1); n         a[i] >>= 1; n         a[(i + 1) % 4] >>= 1; n         f = 0; n         break; n       } n     if (f) { n       for (int i = 0; i < 4; i++) n         if (a[i] % 2 == 1 && a[(i + 1) % 4] % 2 == 1 && n             !(a[i] == 1 && a[(i + 1) % 4] == 1)) { n           a[i]++; n           a[(i + 1) % 4]++; n           printf( +%d n , i + 1); n           f = 0; n           break; n         } n       if (f) n         for (int i = 0; i < 4; i++) n           if (a[i] % 2 == 1 && a[(i + 1) % 4] % 2 == 0 && n               a[(i + 2) % 4] % 2 == 1) { n             printf( +%d n+%d n , i + 1, (i + 1) % 4 + 1); n             a[i]++; n             a[(i + 2) % 4]++; n             a[(i + 1) % 4] += 2; n             break; n           } n     } n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n string multiply(string num1, string num2) { n   int len1 = num1.size(); n   int len2 = num2.size(); n   if (len1 == 0 || len2 == 0) return  0 ; n   vector<int> result(len1 + len2, 0); n   int i_n1 = 0; n   int i_n2 = 0; n   for (int i = len1 - 1; i >= 0; i--) { n     int carry = 0; n     int n1 = num1[i] -  0 ; n     i_n2 = 0; n     for (int j = len2 - 1; j >= 0; j--) { n       int n2 = num2[j] -  0 ; n       int sum = n1 * n2 + result[i_n1 + i_n2] + carry; n       carry = sum / 10; n       result[i_n1 + i_n2] = sum % 10; n       i_n2++; n     } n     if (carry > 0) result[i_n1 + i_n2] += carry; n     i_n1++; n   } n   int i = result.size() - 1; n   while (i >= 0 && result[i] == 0) i--; n   if (i == -1) return  0 ; n   string s =   ; n   while (i >= 0) s += std::to_string(result[i--]); n   return s; n } n int main() { n   ios_base::sync_with_stdio(false); n   cin.tie(NULL); n   cout.tie(NULL); n   int T; n   cin >> T; n   while (T--) { n     long int n; n     cin >> n; n     n = n / 2; n     string n1, n2, n3, ans1, ans; n     int temp; n     if (n % 3 == 0) { n       temp = 4 * n / 3; n       n1 = to_string(temp); n       n2 = to_string(n + 1); n       n3 = to_string(2 * n + 1); n       ans1 = multiply(n1, n2); n       ans = multiply(ans1, n3); n     } else if (n % 3 == 2) { n       temp = 4 * (n + 1) / 3; n       n1 = to_string(temp); n       n2 = to_string(n); n       n3 = to_string(2 * n + 1); n       ans1 = multiply(n1, n2); n       ans = multiply(ans1, n3); n     } else { n       temp = 4 * (2 * n + 1) / 3; n       n1 = to_string(temp); n       n2 = to_string(n + 1); n       n3 = to_string(n); n       ans1 = multiply(n1, n2); n       ans = multiply(ans1, n3); n     } n     cout << ans << endl; n   } n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int N = 100010; n int n, x[N], y[N], xs[N], ys[N], cnt[2][2]; n int main() { n   scanf( %d , &n); n   for (int i = 1; i <= n; i++) { n     scanf( %d%d , &x[i], &y[i]); n     xs[i] = x[i], ys[i] = y[i]; n   } n   sort(xs + 1, xs + n + 1); n   sort(ys + 1, ys + n + 1); n   int m = (n + 1) / 2; n   int cx = xs[m], cy = ys[m]; n   int dx = xs[m + 1] - xs[m], dy = ys[m + 1] - ys[m]; n   if (n & 1) { n     dx = min(dx, xs[m] - xs[m - 1]); n     dy = min(dy, ys[m] - ys[m - 1]); n   } n   long long ans = 0; n   bool flag = 0; n   for (int i = 1; i <= n; i++) { n     ans += abs(x[i] - cx) + abs(y[i] - cy); n     ++cnt[x[i] <= cx][y[i] <= cy]; n     if (x[i] == cx && y[i] == cy) flag = 1; n   } n   if (cnt[0][0] && cnt[0][1] && cnt[1][1] && cnt[1][0]) { n     if (n % 2 == 0 || flag) ans -= min(dx, dy); n   } n   printf( %lld n , ans * 2); n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int main() { n   cout << fixed; n   double d, L, v1, v2; n   cin >> d >> L >> v1 >> v2; n   cout << setprecision(8) << (L - d) / (v1 + v2) << endl; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n long long scan_d() { n   char t = getchar(); n   long long you = 0; n   while (t >  9  || t <  0 ) t = getchar(); n   while (t <=  9  && t >=  0 ) { n     you *= 10; n     you += t -  0 ; n     t = getchar(); n   } n   return you; n } n long long dp[1050][1050]; n long long op[1001]; n int main() { n   for (int i = 0; i <= 1010; i++) dp[1][i] = 1; n   for (int i = 2; i <= 1010; i++) n     for (int o = i - 1; o <= 1010; o++) { n       dp[i][o] = dp[i - 1][o - 1] + dp[i][o - 1]; n       dp[i][o] %= 1000000007; n     } n   long long y; n   y = scan_d(); n   long long sum = 0; n   for (int i = 1; i <= y; i++) { n     op[i] = scan_d(); n   } n   long long ans = 1; n   for (int i = 1; i <= y; i++) { n     sum += op[i]; n     ans *= dp[op[i]][sum - 1]; n     ans %= 1000000007; n   } n   cout << ans << endl; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n template <class T> n void read(T &x) { n   int f = 0; n   x = 0; n   char ch = getchar(); n   for (; !isdigit(ch); ch = getchar()) f |= (ch ==  - ); n   for (; isdigit(ch); ch = getchar()) x = x * 10 + ch -  0 ; n   if (f) x = -x; n } n const int N = 20, mod = 998244353; n int f[N][N][N][N][2][2]; n int g[N][N][N][N][2][2]; n int x[N], y[N], n, m; n void add(int &x, int y) { x = (x + y >= mod ? x + y - mod : x + y); } n int main() { n   read(n), read(m); n   for (int i = (1); i <= (n); i++) read(x[i]), read(y[i]); n   f[0][0][0][0][0][0] = 1; n   for (; m; m >>= 1) { n     memset(g, 0, sizeof g); n     for (int px = 0; px < (N); px++) n       for (int nx = 0; nx < (N); nx++) n         for (int py = 0; py < (N); py++) n           for (int ny = 0; ny < (N); ny++) n             for (int fx = 0; fx < (2); fx++) n               for (int fy = 0; fy < (2); fy++) { n                 int t = f[px][nx][py][ny][fx][fy]; n                 if (!t) continue; n                 for (int s = 0; s < (1 << n); s++) { n                   int Px = px, Nx = nx, Py = py, Ny = ny; n                   for (int i = (1); i <= (n); i++) n                     if (s >> (i - 1) & 1) { n                       Px += max(x[i], 0); n                       Nx -= min(x[i], 0); n                       Py += max(y[i], 0); n                       Ny -= min(y[i], 0); n                     } n                   if ((Px & 1) != (Nx & 1) || (Py & 1) != (Ny & 1)) continue; n                   int gx = n                       ((Px & 1) < (m & 1) ? 0 : ((Px & 1) > (m & 1) ? 1 : fx)); n                   int gy = n                       ((Py & 1) < (m & 1) ? 0 : ((Py & 1) > (m & 1) ? 1 : fy)); n                   Px >>= 1, Nx >>= 1, Py >>= 1, Ny >>= 1; n                   add(g[Px][Nx][Py][Ny][gx][gy], t); n                 } n               } n     swap(f, g); n   } n   cout << ((f[0][0][0][0][0][0] + mod - 1) % mod) << endl; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const long long INF = 1e18; n const long long mod = 1e9 + 7; n const long long N = 1e5 + 10; n inline long long add(long long x, long long y) { n   x += y; n   if (x >= mod) x -= mod; n   return x; n } n inline long long mul(long long x, long long y) { n   x = (1LL * x * y) % mod; n   return x; n } n int main() { n   ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0); n   long long n; n   cin >> n; n   n--; n   cout <<  0 0  << endl; n   fflush(stdout); n   if (n == 0) { n     cout <<  1 0 1 1 ; n     fflush(stdout); n     return 0; n   } n   string prev; n   cin >> prev; n   long long l = 0; n   long long r = 1e9; n   long long i = 1; n   while (i <= n) { n     long long m = (l + r) / 2; n     cout << m <<     n          <<  0  << endl; n     fflush(stdout); n     string s; n     cin >> s; n     if (s == prev) { n       l = m; n     } else { n       r = m; n     } n     i++; n   } n   if (r - l < 2) { n     cout << r <<   1   << (r + 1) <<     << (2 * (r + 1) - 2 * l - 1); n     fflush(stdout); n     return 0; n   } n   long long m = (l + r) / 2; n   cout << m <<   0   << m <<   1 ; n   fflush(stdout); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n vector<int> c; n vector<bool> used; n void dfs(int u, vector<vector<int>>& v) { n   used[u] = 1; n   for (int i = 0; i < v[u].size(); i++) { n     if (c[u] == c[v[u][i]] && !used[v[u][i]]) { n       dfs(v[u][i], v); n     } n   } n } n int main() { n   int n; n   cin >> n; n   vector<vector<int>> v(n); n   c.resize(n); n   used.resize(n, 0); n   vector<int> cnt(110000); n   for (int i = 0; i < n - 1; i++) { n     int a, b; n     cin >> a >> b; n     a--; n     b--; n     v[a].push_back(b); n     v[b].push_back(a); n   } n   for (int i = 0; i < n; i++) { n     cin >> c[i]; n   } n   for (int i = 0; i < n; i++) { n     if (!used[i]) { n       cnt[c[i]]++; n       dfs(i, v); n     } n   } n   multiset<int> data; n   for (int i = 0; i < 100010; i++) { n     for (int j = 0; j < cnt[i]; j++) { n       data.insert(i); n     } n   } n   for (int i = 0; i < n; i++) { n     bool check = 0; n     multiset<int> tmp; n     for (int j = 0; j < v[i].size(); j++) { n       if (c[v[i][j]] == c[i]) { n         check = 1; n       } n       tmp.insert(c[v[i][j]]); n     } n     if (!check) { n       tmp.insert(c[i]); n     } n     if (tmp == data) { n       cout <<  YES  << endl; n       cout << i + 1 << endl; n       return 0; n     } n   } n   cout <<  NO  << endl; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n void fastio() { n   ios_base::sync_with_stdio(false); n   cin.tie(NULL); n } n long long power(long long a, long long b) { n   if (b == 0) { n     return 1; n   } else { n     if (b % 2 == 0) { n       return (a * power((a * a) % 1000000007, b / 2)) % 1000000007; n     } else { n       return power((a * a) % 1000000007, b / 2); n     } n   } n } n int main() { n   fastio(); n   long long l, r; n   cin >> l >> r; n   long long even1 = 0, odd1 = 0; n   long long p = 0; n   l--; n   while (l > 0) { n     long long t = min((long long)pow(2LL, p), l); n     if (p % 2 == 0) { n       odd1 += t; n       odd1 %= 1000000007; n     } else { n       even1 += t; n       even1 %= 1000000007; n     } n     p++; n     l -= t; n   } n   long long even2 = 0, odd2 = 0; n   p = 0; n   while (r > 0) { n     long long t = min((long long)pow(2LL, p), r); n     if (p % 2 == 0) { n       odd2 += t; n       odd2 %= 1000000007; n     } else { n       even2 += t; n       even2 %= 1000000007; n     } n     p++; n     r -= t; n   } n   long long sum1 = (even1 * (even1 + 1)) % 1000000007; n   sum1 = (sum1 + (odd1 * odd1) % 1000000007) % 1000000007; n   long long sum2 = (even2 * (even2 + 1)) % 1000000007; n   sum2 = (sum2 + (odd2 * odd2) % 1000000007) % 1000000007; n   cout << (sum2 - sum1 + 1000000007) % 1000000007; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int inf = 0x3f3f3f3f; n struct node { n   double x, y; n } po[1010]; n double dis(node a, node b) { n   return sqrt((a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y)); n } n node mark; n double cha(node a, node b, node c) { n   return (b.x - a.x) * (c.y - a.y) - (c.x - a.x) * (b.y - a.y); n } n double get(node a, node b, node c) { n   return abs(cha(a, b, c)) / dis(a, b) / 2.0; n } n int main() { n   int n; n   cin >> n; n   double ans = 1e9; n   for (int i = (0); i < (n); ++i) cin >> po[i].x >> po[i].y; n   for (int i = (0); i < (n); ++i) { n     ans = min(ans, get(po[(i - 1 + n) % n], po[(i + 1) % n], po[i])); n   } n   cout << fixed << setprecision(10) << ans <<   n ; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n long long n, x, c, cnt; n vector<long long> v1, v2; n int main() { n   ios_base::sync_with_stdio(0); n   cin.tie(0); n   cout.tie(0); n   cin >> n; n   while (n--) { n     cin >> x; n     if (x > 0) n       v1.push_back(x), c += x; n     else n       v2.push_back(abs(x)), cnt += abs(x); n   } n   if (c > cnt) { n     cout <<  first n ; n     return 0; n   } n   if (cnt > c) { n     cout <<  second n ; n     return 0; n   } n   bool a = 0; n   for (int i = 0; i < min(v1.size(), v2.size()); i++) { n     if (v1[i] > v2[i]) { n       cout <<  first n ; n       return 0; n     } else if (v1[i] < v2[i]) { n       cout <<  second n ; n       return 0; n     } n   } n   if (x < 0) n     cout <<  second  << endl; n   else n     cout <<  first  << endl; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n long long n, t, ans; n short i, j, k; n char cnt, l; n long long C[43][43]; n int main() { n   scanf( %I64d %I64d , &n, &t); n   for (i = 0; (1ll << i) < t; ++i) n     ; n   if ((1ll << i) ^ t) { n     puts( 0 ); n     return 0; n   } n   k = i + 1; n   for (i = 0; i < 43; ++i) C[0][i] = 1ll; n   for (i = 1; i < 43; ++i) n     for (j = 1; j <= i; ++j) C[j][i] = C[j - 1][i - 1] + C[j][i - 1]; n   ++n; n   for (cnt = i = 0; (1ll << i) <= n; ++i) n     if ((1ll << i) & n) ++cnt; n   for (l = i = 0; (1ll << i) <= n; ++i) n     if (n & (1ll << i)) { n       ++l; n       if (k - cnt + l >= 0) ans += C[k - cnt + l][i]; n     } n   if (cnt == k) ++ans; n   if (k == 1) --ans; n   printf( %I64d n , ans); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int MAX_N = 1001; n int dp2[MAX_N][MAX_N], dp5[MAX_N][MAX_N]; n int n; n string findPath(int (*p)[MAX_N]) { n   int i = n - 1, j = n - 1; n   string path =   ; n   while (i != 0 && j != 0) { n     if (p[i - 1][j] > p[i][j - 1]) { n       path.insert(0,  R ); n       j--; n     } else { n       path.insert(0,  D ); n       i--; n     } n   } n   if (i == 0) { n     while (j != 0) { n       path.insert(0,  R ); n       j--; n     } n   } else { n     while (i != 0) { n       path.insert(0,  D ); n       i--; n     } n   } n   return path; n } n int main() { n   std::ios::sync_with_stdio(false); n   cin >> n; n   int temp1, temp2, zeroI = -1; n   for (int i = 0; i < n; i++) n     for (int j = 0; j < n; j++) { n       cin >> temp1; n       if (!temp1) { n         zeroI = i; n         continue; n       } n       temp2 = temp1; n       while (!(temp1 & 1)) { n         dp2[i][j]++; n         temp1 >>= 1; n       } n       while (!(temp2 % 5)) { n         dp5[i][j]++; n         temp2 /= 5; n       } n     } n   for (int i = 1; i < n; i++) { n     dp2[i][0] += dp2[i - 1][0]; n     dp5[i][0] += dp5[i - 1][0]; n     dp2[0][i] += dp2[0][i - 1]; n     dp5[0][i] += dp5[0][i - 1]; n   } n   for (int i = 1; i < n; i++) { n     for (int j = 1; j < n; j++) { n       dp2[i][j] += min(dp2[i - 1][j], dp2[i][j - 1]); n       dp5[i][j] += min(dp5[i - 1][j], dp5[i][j - 1]); n     } n   } n   int(*p)[MAX_N] = (dp2[n - 1][n - 1] < dp5[n - 1][n - 1]) ? dp2 : dp5; n   if ((~zeroI) && p[n - 1][n - 1] > 1) { n     cout <<  1  << endl; n     for (int i = 0; i < zeroI; i++) cout <<  D  << flush; n     for (int j = 1; j < n; j++) cout <<  R  << flush; n     for (int i = zeroI + 1; i < n; i++) cout <<  D  << flush; n     return 0; n   } else { n     cout << p[n - 1][n - 1] << endl; n     cout << findPath(p) << flush; n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int B, n, m; n int li[500008], ri[500008], mx[500008], tag[500008]; n short g[480][100008]; n int bel[500008], de[500008], ai[500008], pa[500008]; n short size[500008]; n int find(int x) { n   if (pa[x] == x) return x; n   return pa[x] = find(pa[x]); n } n void link(int x, int y) { n   if (x == y) return; n   if (size[x] > size[y]) swap(x, y); n   pa[x] = y; n   size[y] += size[x]; n } n int tot; n int lst[500008], stamp[500008]; n void makeup(int id) { n   ++tot; n   mx[id] = 0; n   for (int i = li[id]; i <= ri[id]; i++) pa[i] = i, size[i] = 1; n   for (int i = li[id]; i <= ri[id]; i++) { n     int x = ai[i]; n     mx[id] = max(mx[id], x); n     if (stamp[x] != tot) n       stamp[x] = tot, g[id][x] = lst[x] = i - li[id]; n     else n       link(i, g[id][x] + li[id]), g[id][x] = find(g[id][x] + li[id]) - li[id]; n   } n } n void pushdown(int id) { n   for (int i = li[id]; i <= ri[id]; i++) g[id][ai[i]] = -1; n   for (int i = li[id]; i <= ri[id]; i++) { n     g[id][ai[i] + de[i]] = -1; n     if (find(i) == i) ai[i] = ai[i] + de[i] - tag[id]; n     de[i] = 0; n   } n   for (int i = li[id]; i <= ri[id]; i++) ai[i] = ai[find(i)]; n   tag[id] = 0; n } n void refresh(int id) { n   while (-1 == g[id][mx[id]]) mx[id]--; n } n int cnt = 0; n void subtract(int id, int x) { n   if (mx[id] - tag[id] <= x) return; n   if (mx[id] - tag[id] > x * 2 + 1 and 1) { n     for (int i = tag[id] + 1; i <= x + tag[id]; i++) n       if (g[id][i] != -1) { n         int j = i + x; n         de[g[id][i] + li[id]] += x; n         if (g[id][j] != -1) n           link(g[id][i] + li[id], g[id][j] + li[id]), n               g[id][j] = find(g[id][j] + li[id]) - li[id]; n         else n           g[id][j] = g[id][i]; n         g[id][i] = -1; n       } n     tag[id] += x; n   } else { n     for (int i = x + 1 + tag[id]; i <= mx[id]; i++) n       if (g[id][i] != -1) { n         int j = i - x; n         de[g[id][i] + li[id]] -= x; n         if (g[id][j] != -1) n           link(g[id][j] + li[id], g[id][i] + li[id]), n               g[id][j] = find(g[id][j] + li[id]) - li[id]; n         else n           g[id][j] = g[id][i]; n         g[id][i] = -1; n       } n     refresh(id); n   } n } n int ask(int id, int x) { n   if (x + tag[id] > 100001) return 0; n   if (g[id][x + tag[id]] == -1) return 0; n   g[id][x + tag[id]] = find(g[id][x + tag[id]] + li[id]) - li[id]; n   return size[g[id][x + tag[id]] + li[id]]; n } n signed main() { n   memset(g, -1, sizeof g); n   scanf( %d%d , &n, &m); n   for (int i = 1; i <= n; i++) scanf( %d , &ai[i]); n   B = sqrt(n); n   B = max(B, n / 475); n   memset(li, 0x3f, sizeof li); n   for (int i = 1; i <= n; i++) { n     bel[i] = i / B; n     li[bel[i]] = min(li[bel[i]], i); n     ri[bel[i]] = i; n   } n   for (int i = 0; i <= n / B; i++) makeup(i); n   while (m--) { n     int op, l, r, x; n     scanf( %d%d%d%d , &op, &l, &r, &x); n     if (op == 1) { n       if (bel[l] == bel[r]) { n         pushdown(bel[l]); n         for (int i = l; i <= r; i++) n           if (ai[i] > x) ai[i] -= x; n         makeup(bel[l]); n       } else { n         pushdown(bel[l]); n         for (int i = l; i <= ri[bel[l]]; i++) n           if (ai[i] > x) ai[i] -= x; n         pushdown(bel[r]); n         for (int i = li[bel[r]]; i <= r; i++) n           if (ai[i] > x) ai[i] -= x; n         makeup(bel[l]); n         makeup(bel[r]); n         for (int i = bel[l] + 1; i < bel[r]; i++) subtract(i, x); n       } n     } else { n       int ans = 0; n       if (bel[l] == bel[r]) { n         pushdown(bel[l]); n         for (int i = l; i <= r; i++) n           if (ai[i] == x) ans++; n         makeup(bel[l]); n         printf( %d n , ans); n       } else { n         pushdown(bel[l]); n         for (int i = l; i <= ri[bel[l]]; i++) ans += (ai[i] == x); n         pushdown(bel[r]); n         for (int i = li[bel[r]]; i <= r; i++) ans += (ai[i] == x); n         makeup(bel[l]); n         makeup(bel[r]); n         for (int i = bel[l] + 1; i < bel[r]; i++) ans += ask(i, x); n         printf( %d n , ans); n       } n     } n     ++cnt; n     if (cnt < -7) { n       for (int i = 0; i <= n / B; i++) pushdown(i); n       for (int i = 1; i <= n; i++) cout << ai[i] <<    ; n       cout << g[2][30] <<  : n n ; n       for (int i = 0; i <= n / B; i++) makeup(i); n     } n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int N = 100010; n long long a[N]; n int n; n bool check(long long x) { n   long long sum = 0; n   for (int i = 2; i <= n; ++i) { n     if (x - a[i] < 0) return false; n     sum += x - a[i]; n   } n   return (sum >= a[1]); n } n int main() { n   scanf( %d , &n); n   for (int i = 1; i <= n; ++i) scanf( %I64d , &a[i]); n   sort(a + 1, a + n + 1); n   long long l = 0, r = (long long)1e14 + 1; n   while (l + 1 < r) { n     long long mid = (l + r) / 2; n     if (check(mid)) n       r = mid; n     else n       l = mid; n   } n   if (check(l)) n     printf( %I64d , l); n   else n     printf( %I64d , r); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n bool isPowerOfTwo(int n) { n   if (n == 0) return false; n   return (ceil(log2(n)) == floor(log2(n))); n } n void asquare() { n   long long n, c = 0, ans = LONG_LONG_MAX; n   cin >> n; n   string sn; n   if (isPowerOfTwo(n) == true) n     cout <<  0 n ; n   else { n     long long j = 0, k = 0, nn = 1; n     string s = to_string(n); n     for (int i = 0; i <= 60; i++) { n       nn = (long long)pow(2, i); n       sn = to_string(nn); n       c = 0, j = 0, k = 0; n       bool bb; n       while (j != s.length() && k != sn.length()) { n         if (s[j] == sn[k]) { n           j++; n           k++; n           bb = true; n         } else { n           j++; n           c++; n           bb = false; n         } n       } n       if (bb = true) { n         if (j == s.length()) { n           k--; n           c += sn.length() - k - 1; n         } else if (k == sn.length()) { n           j--; n           c += s.length() - j - 1; n         } n       } else { n         k--; n         c += sn.length() - k - 1; n       } n       if (c == 1) { n         ans = 1; n         break; n       } else n         ans = min(ans, c); n     } n     cout << ans <<   n ; n   } n } n int main() { n   ios_base::sync_with_stdio(false); n   cin.tie(NULL); n   cout.tie(NULL); n   long long t; n   cin >> t; n   while (t--) { n     asquare(); n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int main() { n   ios_base::sync_with_stdio(false); n   cin.tie(0); n   cout.tie(0); n   int x, y; n   cin >> x >> y; n   int ans = 0; n   int d = max(abs(x), abs(y)); n   if (d == 0) { n     cout << 0 <<   n ; n     return 0; n   } else n     ans = (d - 1) * 4; n   if (x == d && y != -1 * (d - 1) && y != -1 * (d)) ans++; n   if (y == d && x != d) ans += 2; n   if (x == -1 * d && y != d) ans += 3; n   if (y == -1 * d && x != -1 * d) ans += 4; n   cout << ans <<   n ; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n struct Aho { n   Aho *son[26]; n   Aho *fail; n   int cntstr, faildp; n   Aho() { n     for (int i = 0; i < 26; ++i) son[i] = NULL; n     fail = NULL; n     cntstr = 0; n     faildp = -1; n   } n }; n void insert(Aho *x, int i, const string &str) { n   if (i < str.size()) { n     if (x->son[str[i] -  a ] == NULL) { n       x->son[str[i] -  a ] = new Aho(); n     } n     insert(x->son[str[i] -  a ], i + 1, str); n   } else { n     x->cntstr++; n   } n } n void calcFailEdges(Aho *root) { n   deque<Aho *> q; n   root->fail = root; n   q.push_back(root); n   while (!q.empty()) { n     Aho *x = q.front(); n     q.pop_front(); n     for (int i = 0; i < 26; ++i) { n       if (x->son[i] != NULL) { n         q.push_back(x->son[i]); n         Aho *pnt = x->fail; n         if (x == root) n           x->son[i]->fail = root; n         else { n           while (pnt != root && pnt->son[i] == NULL) { n             pnt = pnt->fail; n           } n           if (pnt->son[i] != NULL) n             x->son[i]->fail = pnt->son[i]; n           else n             x->son[i]->fail = root; n         } n       } n     } n   } n } n int getDp(Aho *t) { n   if (t->faildp == -1) { n     t->faildp = t->cntstr; n     t->faildp += getDp(t->fail); n   } n   return t->faildp; n } n const int MAX_N = 200000; n Aho *state[1 + MAX_N]; n Aho *advance(Aho *t, char ch) { n   while (t->fail != t && t->son[ch -  a ] == NULL) t = t->fail; n   if (t->son[ch -  a ] == NULL) return t; n   return t->son[ch -  a ]; n } n Aho *state1[MAX_N], *state2[MAX_N]; n void doStuff(int n, Aho **state, const string &str, const vector<string> &vec) { n   Aho *T = new Aho(); n   for (int i = 0; i < n; ++i) insert(T, 0, vec[i]); n   T->faildp = T->cntstr; n   calcFailEdges(T); n   Aho *pnt = T; n   for (int i = 1; i <= str.size(); ++i) { n     pnt = advance(pnt, str[i - 1]); n     state[i] = pnt; n   } n } n int main() { n   int n; n   string str; n   cin >> str >> n; n   vector<string> vec; n   for (int i = 0; i < n; ++i) { n     string p; n     cin >> p; n     vec.push_back(p); n   } n   doStuff(n, state1, str, vec); n   for (int i = 0; i < n; ++i) reverse(vec[i].begin(), vec[i].end()); n   reverse(str.begin(), str.end()); n   doStuff(n, state2, str, vec); n   long long rez = 0LL; n   for (int i = 1; i < str.size(); ++i) n     rez = (long long)getDp(state1[i]) * getDp(state2[str.size() - i]) + rez; n   printf( %lld , rez); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int inf = 0x3f3f3f3f; n const int MOD = 1e9 + 7; n const int base = 101; n inline void chmax(int& x, int y) { n   if (x < y) x = y; n } n inline void chmin(int& x, int y) { n   if (x > y) x = y; n } n inline int LSB(int i) { return (i & -i); } n int n, m, dp[10005]; n char s[10005], str[10005]; n map<long long, string> mp; n vector<string> v; n inline long long Hash(int a, int b) { return (1LL * a * base + b) % MOD; } n int main() { n   scanf( %d%s%d , &n, &s, &m); n   for (int i = 0; i < m; i++) { n     scanf( %s , &str); n     long long h = 1; n     for (int j = 0; j < strlen(str); j++) { n       h = Hash(h, tolower(str[j])); n     } n     mp[h] = str; n   } n   fill(dp, dp + n, -1); n   dp[0] = 0; n   for (int i = 0; i < n; i++) { n     long long h = 1; n     for (int j = i; j >= 0; j--) { n       h = Hash(h, s[j]); n       if (dp[j] != -1 && mp.find(h) != mp.end()) { n         dp[i + 1] = h; n         break; n       } n     } n   } n   int p = n; n   while (p > 0) { n     v.push_back(mp[dp[p]]); n     p -= mp[dp[p]].length(); n   } n   reverse(v.begin(), v.end()); n   for (string& i : v) printf( %s  , &i[0]); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const long long p = 1e9 + 7; n int mk[705][705][3][3]; n char s[705]; n long long ck(int l, int r, int lc, int rc) { n   if (l > r) return !lc || !rc || lc != rc; n   if (mk[l][r][lc][rc]) return mk[l][r][lc][rc]; n   for (int i = l, cnt = 0;; i++) { n     if (s[i] ==  ) ) n       cnt++; n     else n       cnt--; n     if (!cnt) { n       long long m = ck(l + 1, i - 1, 0, 1) * ck(i + 1, r, 1, rc) % p + n                     ck(l + 1, i - 1, 0, 2) * ck(i + 1, r, 2, rc); n       if (lc != 1) m += ck(l + 1, i - 1, 1, 0) * ck(i + 1, r, 0, rc); n       if (lc != 2) m += ck(l + 1, i - 1, 2, 0) * ck(i + 1, r, 0, rc); n       return mk[l][r][lc][rc] = m % p; n     } n   } n } n int main() { n   scanf( %s , s + 1); n   printf( %lld , ck(1, strlen(s + 1), 0, 0)); n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n #pragma GCC optimize( Ofast ) n #pragma GCC target( avx,avx2,fma ) n using namespace std; n using ll = long long; n using ull = unsigned long long; n template <typename T> n void print(vector<T> v) { n   for (T i : v) cout << i <<    ; n   cout <<   n ; n } n template <typename T> n void print(vector<vector<T>>& v) { n   for (vector<T>& vv : v) { n     for (T& i : vv) cout << i <<    ; n     cout <<   n ; n   } n } n template <typename T> n void print(T&& t) { n   cout << t <<   n ; n } n template <typename T, typename... Args> n void print(T&& t, Args&&... args) { n   cout << t <<    ; n   print(forward<Args>(args)...); n } n template <typename T> n istream& operator>>(istream& is, vector<T>& v) { n   for (auto& i : v) is >> i; n   return is; n } n template <typename T> n ostream& operator<<(ostream& os, vector<T>& v) { n   for (auto& i : v) os << i <<    ; n   return os; n } n void __print(int x) { cerr << x; } n void __print(long x) { cerr << x; } n void __print(long long x) { cerr << x; } n void __print(unsigned x) { cerr << x; } n void __print(unsigned long x) { cerr << x; } n void __print(unsigned long long x) { cerr << x; } n void __print(float x) { cerr << x; } n void __print(double x) { cerr << x; } n void __print(long double x) { cerr << x; } n void __print(char x) { cerr <<      << x <<     ; } n void __print(const char* x) { cerr <<     << x <<    ; } n void __print(const string& x) { cerr <<     << x <<    ; } n void __print(bool x) { cerr << (x ?  true  :  false ); } n template <typename T, typename V> n void __print(const pair<T, V>& x) { n   cerr <<  { ; n   __print(x.first); n   cerr <<  , ; n   __print(x.second); n   cerr <<  } ; n } n template <typename T> n void __print(const T& x) { n   int f = 0; n   cerr <<  { ; n   for (auto& i : x) cerr << (f++ ?  ,  :   ), __print(i); n   cerr <<  } ; n } n void _print() { cerr <<  ] n ; } n template <typename T, typename... V> n void _print(T t, V... v) { n   __print(t); n   if (sizeof...(v)) cerr <<  ,  ; n   _print(v...); n } n void loop() { n   ll n; n   cin >> n; n   vector<ll> a(n); n   cin >> a; n   if (n == 1) { n     print( Alice ); n     return; n   } n   vector<ll> inc, dec; n   inc.push_back(a[0]); n   for (ll i = 0; i < n - 1; i++) { n     if (a[i] < a[i + 1]) { n       inc.push_back(a[i + 1]); n     } else n       break; n   } n   dec.push_back(a[n - 1]); n   for (ll i = n - 1; i > 0; i--) { n     if (a[i] < a[i - 1]) { n       dec.push_back(a[i - 1]); n     } else n       break; n   } n   if (dec.size() % 2) { n     print( Alice ); n     return; n   } else if ((inc.size() - 1 + dec.size()) % 2 == 0) { n     print( Alice ); n     return; n   } n   print( Bob ); n } n int32_t main() { n   ios_base::sync_with_stdio(false); n   cin.tie(NULL); n   cout.tie(NULL); n   ll t; n   t = 1; n   while (t--) { n     loop(); n   } n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int maxn = 1e5 + 10; n const int INF = 0x3f3f3f3f; n int n, m, a[maxn], b[maxn], f[maxn], g[maxn], l[maxn], p[maxn], ans[maxn]; n bool vis[maxn]; n int main() { n   scanf( %d , &n); n   for (int i = (1), _end_ = (n); i <= _end_; ++i) scanf( %d , &a[i]); n   a[++n] = INF; n   scanf( %d , &m); n   for (int i = (1), _end_ = (m); i <= _end_; ++i) scanf( %d , &b[i]); n   sort(b + 1, b + m + 1); n   for (int i = (1), _end_ = (n + 1); i <= _end_; ++i) f[i] = INF; n   for (int i = (1), _end_ = (n); i <= _end_; ++i) n     if (a[i] != -1) { n       int L = 1, R = n, pos = 0; n       while (L <= R) { n         int Mid = L + R >> 1; n         if (f[Mid] < a[i]) { n           pos = Mid; n           L = Mid + 1; n         } else n           R = Mid - 1; n       } n       f[pos + 1] = a[i]; n       g[pos + 1] = i; n       l[i] = pos + 1; n       p[i] = g[pos]; n     } else { n       int pos = n; n       for (int j = m; j >= 1; --j) { n         while (f[pos] >= b[j]) --pos; n         f[pos + 1] = b[j]; n         g[pos + 1] = i; n       } n     } n   for (int len = l[n], pos = n, val = a[n]; len >= 1; --len) n     if (a[pos] != -1) { n       if (a[p[pos]] != -1) { n         pos = p[pos]; n         val = a[pos]; n       } else { n         int t = lower_bound(b + 1, b + m + 1, val) - b - 1; n         vis[t] = true; n         pos = p[pos]; n         val = ans[pos] = b[t]; n       } n     } else { n       for (int i = pos - 1; i >= 1; --i) n         if (a[i] != -1 && l[i] == len - 1 && a[i] < val) { n           pos = i; n           val = a[i]; n           goto Next; n         } n       for (int i = pos - 1; i >= 1; --i) n         if (a[i] == -1) { n           int t = lower_bound(b + 1, b + m + 1, val) - b - 1; n           vis[t] = true; n           pos = i; n           val = ans[pos] = b[t]; n           goto Next; n         } n     Next:; n     } n   int pos = 1; n   for (int i = (1), _end_ = (n - 1); i <= _end_; ++i) n     if (a[i] != -1) n       ans[i] = a[i]; n     else if (!ans[i]) { n       while (vis[pos]) ++pos; n       ans[i] = b[pos]; n       ++pos; n     } n   for (int i = (1), _end_ = (n - 1); i <= _end_; ++i) printf( %d  , ans[i]); n   puts(  ); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int getChar(char c) { n   if (c ==  + ) return 1; n   return 0; n } n string s; n stack<int> mystack; n int main() { n   cin >> s; n   int n = s.size(); n   int temp; n   for (int i = 0; i < n; i++) { n     temp = getChar(s[i]); n     if (mystack.empty()) n       mystack.push(temp); n     else { n       if (mystack.top() == temp) n         mystack.pop(); n       else n         mystack.push(temp); n     } n   } n   if (mystack.empty()) { n     cout <<  Yes  << endl; n     return 0; n   } n   cout <<  No  << endl; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int inf = 2000000000; n const double eps = 1e-9, Pi = 2 * acos(0); n int main() { n   ifstream fin( input.txt ); n   ofstream fout( output.txt ); n   string s; n   cin >> s; n   map<string, int> make_pair; n   for (int i = 0; i <= 9; i++) { n     string x; n     cin >> x; n     make_pair[x] = i; n   } n   for (int i = 0; i < 8; i++) { n     string x =   ; n     for (int j = i * 10; j < (i + 1) * 10; j++) x += s[j]; n     cout << make_pair[x]; n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int N, memo[1 << 25]; n pair<int, int> arr[30]; n int dist(int a, int n) { n   int k1 = arr[n].first - arr[a].first; n   int k2 = arr[n].second - arr[a].second; n   return k1 * k1 + k2 * k2; n } n int dp(int mask) { n   if (__builtin_popcount(mask) == N) { n     return 0; n   } n   if (memo[mask] != 0) return memo[mask]; n   int res = 1e9; n   for (int i = 1; i <= N; i++) { n     if (!((mask >> (i - 1) & 1))) { n       res = min(res, dp(mask | (1 << (i - 1))) + 2 * dist(i, 0)); n       for (int j = i + 1; j <= N; j++) { n         if (!(mask >> (j - 1) & 1) and i != j) { n           res = min(res, dp(mask | (1 << (i - 1)) | (1 << (j - 1))) + n                              dist(i, 0) + dist(i, j) + dist(j, 0)); n         } n       } n       break; n     } n   } n   memo[mask] = res; n   return res; n } n void backtrack(int mask) { n   if (__builtin_popcount(mask) == N) { n     return; n   } n   for (int i = 1; i <= N; i++) { n     if (!((mask >> (i - 1) & 1))) { n       if (dp(mask | (1 << (i - 1))) + 2 * dist(i, 0) == dp(mask)) { n         cout << 0 <<     << i <<    ; n         backtrack(mask | (1 << (i - 1))); n         return; n       } n       for (int j = i + 1; j <= N; j++) { n         if (!(mask >> (j - 1) & 1) and i != j) { n           if (dp(mask | (1 << (i - 1)) | (1 << (j - 1))) + dist(i, 0) + n                   dist(i, j) + dist(j, 0) == n               dp(mask)) { n             cout << 0 <<     << i <<     << j <<    ; n             backtrack(mask | (1 << (i - 1)) | (1 << (j - 1))); n             return; n           } n         } n       } n       break; n     } n   } n   return; n } n int main() { n   ios_base::sync_with_stdio(0); n   cin.tie(0), cout.tie(0); n   cin >> arr[0].first >> arr[0].second; n   cin >> N; n   for (int i = 1; i <= N; i++) cin >> arr[i].first >> arr[i].second; n   cout << dp(0) << endl; n   backtrack(0); n   cout << 0 << endl; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n char a[51][51]; n int main() { n   memset(a,  0 , sizeof(a)); n   int n; n   cin >> n; n   for (int i = 1; i <= n; i++) n     for (int j = 1; j <= n; j++) cin >> a[i][j]; n   for (int i = 1; i <= n; i++) n     for (int j = 1; j <= n; j++) { n       int x = a[i][j] -  0 ; n       if (x != 0) { n         if (a[i - 1][j - 1] !=  0 ) x--; n         if (a[i - 1][j + 1] !=  0 ) x--; n         if (a[i + 1][j - 1] !=  0 ) x--; n         if (a[i + 1][j + 1] !=  0 ) x--; n         if (x != 0) return cout <<  No , 0; n       } n     } n   cout <<  Yes ; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n char str[2][400000 + 10]; n int n; n void sortstr(int t, int l, int r) { n   if ((r - l + 1) & 1) return; n   int md = (l + r) / 2; n   sortstr(t, l, (l + r) / 2), sortstr(t, (l + r) / 2 + 1, r); n   bool needswap = false; n   for (int i = l, j = md + 1; i <= md; i++, j++) { n     if (str[t][i] < str[t][j]) break; n     if (str[t][i] > str[t][j]) { n       needswap = true; n       break; n     } n   } n   if (needswap) { n     for (int i = l, j = md + 1; i <= md; i++, j++) swap(str[t][i], str[t][j]); n   } n } n int main() { n   for (int i = 0; i < 2; i++) n     scanf( %s , str[i]), n = strlen(str[i]), sortstr(i, 0, n - 1); n   bool equ = true; n   for (int i = 0; i < n; i++) n     if (str[0][i] != str[1][i]) equ = false; n   printf( %s n , equ ?  YES  :  NO ); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int n, m, gxx; n pair<int, int> a[411111]; n int p[411111]; n int Gxx[411111], bb[411111]; n int degree[411111]; n int h, t; n void make_ans(int x, int y, int tot) { n   int now_x = degree[x] - 1 - tot; n   int need_x = max(h - now_x, 0); n   int now_y = degree[y] - 1 - tot; n   int need_y = max(t - now_y, 0); n   for (int i = p[x]; i < p[x + 1]; i++) Gxx[a[i].second] = 1; n   for (int i = p[y]; i < p[y + 1]; i++) n     if (Gxx[a[i].second] == 1) bb[a[i].second] = 1; n   printf( YES n ); n   printf( %d %d n , x, y); n   bool bo = false; n   for (int i = p[x]; i < p[x + 1]; i++) n     if ((bb[a[i].second] == 0 || need_x) && a[i].second != y && h) { n       h--; n       if (bb[a[i].second]) { n         bb[a[i].second] = -1; n         need_x--; n       } n       if (bo) printf(   ); n       bo = true; n       printf( %d , a[i].second); n     } n   printf(  n ); n   bo = false; n   for (int i = p[y]; i < p[y + 1]; i++) n     if ((bb[a[i].second] == 0 || need_y) && a[i].second != x && t && n         bb[a[i].second] != -1) { n       t--; n       if (bb[a[i].second]) need_y--; n       if (bo) printf(   ); n       bo = true; n       printf( %d , a[i].second); n     } n   printf(  n ); n } n int find(int x, int y) { n   int ans = 0; n   for (int i = p[x]; i < p[x + 1]; i++) n     if (a[i].second != y) { n       int t = n           lower_bound(a + p[y], a + p[y + 1], make_pair(y, a[i].second)) - a; n       if (a[t].second == a[i].second) ans++; n     } n   return ans; n } n int main() { n   scanf( %d%d%d%d , &n, &m, &h, &t); n   for (int i = 1; i <= m; i++) { n     scanf( %d%d , &a[i].first, &a[i].second); n     degree[a[i].first]++; n     degree[a[i].second]++; n     a[i + m].second = a[i].first; n     a[i + m].first = a[i].second; n   } n   int M = m * 2; n   sort(a + 1, a + M + 1); n   a[0].first = 0; n   a[M + 1].first = n + 1; n   int now = 0; n   for (int i = 1; i <= M + 1; i++) n     while (now != a[i].first) { n       now++; n       p[now] = i; n     } n   p[0] = 0; n   for (int i = 1; i <= M; i++) n     if (degree[a[i].first] > h && degree[a[i].second] > t) { n       int t1 = a[i].first; n       int t2 = a[i].second; n       int tot = 0; n       if (t1 < t2) n         tot = find(t1, t2); n       else n         tot = find(t2, t1); n       if (degree[t1] + degree[t2] - 2 - tot >= h + t) { n         make_ans(t1, t2, tot); n         return 0; n       } n     } n   printf( NO n ); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int n, k; n int v[100000 + 1]; n int mx, rez; n pair<int, int> rz[100000 + 1]; n int stkLen; n int stkLen2; n int stk[100000 + 1]; n int stk2[100000 + 1]; n int s, s2; n void readFile() { n   ios::sync_with_stdio(false); n   cin.tie(0); n   cout.tie(); n   cin >> n >> k; n   for (int i = 1; i <= n; i++) cin >> v[i]; n } n int cautBin(int nr, int stk[], int stkLen) { n   int i = 0; n   int pas = 1 << 16; n   while (pas != 0) { n     if (i + pas <= stkLen && abs(v[stk[i + pas]] - nr) > k) i += pas; n     pas >>= 1; n   } n   return stk[i] + 1; n } n bool verif(int st, int dr) { n   while (s < stkLen && stk[s] < st) s++; n   while (s2 < stkLen2 && stk2[s2] < st) s2++; n   return (abs(v[stk[s]] - v[stk2[s2]]) <= k); n } n void solve() { n   stkLen = 0; n   int st = 1; n   s = s2 = 1; n   for (int i = 1; i <= n; i++) { n     while (stkLen >= s && v[i] >= v[stk[stkLen]]) stkLen--; n     stk[++stkLen] = i; n     while (stkLen2 >= s2 && v[i] <= v[stk2[stkLen2]]) stkLen2--; n     stk2[++stkLen2] = i; n     while (st < i && verif(st, i) == 0) st++; n     int len = i - st + 1; n     if (len > mx) { n       mx = len; n       rez = 0; n     } n     if (len == mx) rz[++rez] = {st, i}; n   } n } n void printFile() { n   cout << mx <<     << rez <<   n ; n   for (int i = 1; i <= rez; i++) n     cout << rz[i].first <<     << rz[i].second <<   n ; n } n int main() { n   readFile(); n   solve(); n   printFile(); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n long long ar[200010]; n void solve() { n   long long a, b, c = 0, i, j, t, k, lie, m, n, o, x, y, z; n   long long p = 0, sm = 0, cnt = 0; n   scanf( %lld , &n); n   string s; n   cin >> s; n   if (n == 1) { n     printf( Yes n ); n     return; n   } n   for (i = 0; i < n; i++) ar[s[i] -  a ]++; n   for (i = 0; i < 26; i++) { n     if (ar[i] > 1) { n       printf( Yes n ); n       return; n     } n   } n   printf( No n ); n } n int main() { n   solve(); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const double eps = 1e-8; n const int mod = 1e9 + 7; n const int N = 1e6 + 10; n const int inf = 1e9; n int t, n, k; n char s[N]; n int cnt[N]; n int a[N], b[N]; n int main() { n   ios::sync_with_stdio(false); n   cin >> t; n   while (t--) { n     cin >> n >> k; n     cin >> s + 1; n     for (int i = 1; i <= n; i++) { n       cnt[i] = cnt[i - 1]; n       if (s[i] ==  1 ) cnt[i]++; n     } n     int ans = inf; n     for (int i = 1; i <= k; i++) { n       int ret = 0, mn = inf, tp = inf, l = 0; n       vector<int> q; n       q.push_back(0); n       for (int j = i; j <= n; j += k) { n         int tmp = cnt[j - 1] - cnt[l]; n         ret += tmp; n         q.push_back(cnt[j] - cnt[j - 1]); n         l = j; n       } n       ret += cnt[n] - cnt[l]; n       int sz = q.size() - 1; n       for (int i = 1; i <= sz; i++) { n         a[i] = a[i - 1]; n         b[i] = b[i - 1]; n         if (q[i] == 1) n           a[i]++; n         else n           b[i]++; n       } n       tp = a[sz]; n       for (int i = sz; i >= 1; i--) { n         mn = min(mn, b[i] - a[i] + a[sz]); n         tp = min(tp, a[i - 1] - b[i - 1] + mn); n       } n       ans = min(ans, ret + tp); n     } n     cout << ans <<   n ; n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using std::string; n using std::vector; n namespace Template { n struct IN { n   template <class T> n   void fr(T& a) { n     T s = 0; n     int w = 1; n     char ch = getchar(); n     while (ch <  0  || ch >  9 ) { n       if (ch ==  - ) w = -1; n       ch = getchar(); n     } n     while (ch >=  0  && ch <=  9 ) s = s * 10 + ch -  0 , ch = getchar(); n     a = w * s; n   } n   template <class T> n   T fr() { n     T a; n     fr(a); n     return a; n   } n   IN& operator>>(long long& x) { return fr(x), *this; } n   IN& operator>>(signed& x) { return fr(x), *this; } n   IN& operator>>(unsigned& x) { return fr(x), *this; } n   IN& operator>>(char& c) { n     while (isspace(c = getchar())) n       ; n     return *this; n   } n   IN& operator>>(string& str) { n     char ch; n     while (isspace(ch = getchar())) n       ; n     str = ch; n     while (!isspace(ch = getchar())) str += ch; n     return *this; n   } n } cin; n struct OUT { n   char D[1 << 27], *A = D - 1; n   ~OUT() { fwrite(D, 1, A - D + 1, stdout); } n   template <class T> n   void fw(T x) { n     static char C[20]; n     static int f; n     x < 0 ? * ++A =  - , x = -x : 0; n     while (C[++f] = 48 + x % 10, x /= 10) n       ; n     while (*++A = C[f], --f) n       ; n   } n   OUT& operator<<(char c) { return *++A = c, *this; } n   OUT& operator<<(string str) { n     int len = str.length(); n     for (int i = 0; i < len; i++) *++A = str[i]; n     return *this; n   } n   OUT& operator<<(long long x) { return fw(x), *this; } n   OUT& operator<<(signed x) { return fw(x), *this; } n   OUT& operator<<(unsigned x) { return fw(x), *this; } n } cout; n char endl =   n ; n int DEBUG = 0; n template <class T> n T sqr(T a) { n   return a * a; n } n template <class T> n T abs(T a) { n   return a < 0 ? -a : a; n } n template <class T> n T cmin(T a, T b) { n   return a < b ? a : b; n } n template <class T> n T cmax(T a, T b) { n   return a > b ? a : b; n } n template <class T> n void cswp(T& a, T& b) { n   T t = a; n   a = b; n   b = t; n } n }  // namespace Template n using namespace Template; n const int N = 1e5; n int n, blo, tot = 0, fa[N + 10], len[N + 10], arr[N + 10]; n vector<int> E[N + 10]; n void adde(int u, int v) { E[u].push_back(v); } n void dfs(int u, int f) { n   fa[u] = f, arr[++tot] = u; n   for (int v : E[u]) n     if (v != f) dfs(v, u); n } n int calc(int k) { n   int ret = 0; n   for (int i = 1; i <= n; i++) len[i] = 1; n   for (int i = n; i > 1; i--) { n     int u = arr[i], f = fa[u]; n     if (len[f] != -1 && len[u] != -1) { n       if (len[f] + len[u] >= k) n         ret++, len[f] = -1; n       else n         len[f] = cmax(len[f], len[u] + 1); n     } n   } n   return ret; n } n int main() { n   cin >> n; n   blo = sqrt(n * log2(n)); n   for (int i = 1; i < n; ++i) { n     int u, v; n     cin >> u >> v; n     adde(u, v), adde(v, u); n   } n   dfs(1, 0), cout << n << endl; n   for (int i = 2; i <= blo; i++) cout << calc(i) << endl; n   for (int i = blo + 1; i <= n;) { n     int f = calc(i), l = i, r = n, pos = 0; n     while (l <= r) { n       int mid = (l + r) >> 1; n       if (calc(mid) == f) n         l = mid + 1, pos = mid; n       else n         r = mid - 1; n     } n     for (; i <= pos; i++) cout << f << endl; n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n template <typename T> n void MACRO_VAR_Scan(T& t) { n   std::cin >> t; n } n template <typename First, typename... Rest> n void MACRO_VAR_Scan(First& first, Rest&... rest) { n   std::cin >> first; n   MACRO_VAR_Scan(rest...); n } n template <typename T> n void MACRO_VEC_ROW_Init(int n, T& t) { n   t.resize(n); n } n template <typename First, typename... Rest> n void MACRO_VEC_ROW_Init(int n, First& first, Rest&... rest) { n   first.resize(n); n   MACRO_VEC_ROW_Init(n, rest...); n } n template <typename T> n void MACRO_VEC_ROW_Scan(int p, T& t) { n   std::cin >> t[p]; n } n template <typename First, typename... Rest> n void MACRO_VEC_ROW_Scan(int p, First& first, Rest&... rest) { n   std::cin >> first[p]; n   MACRO_VEC_ROW_Scan(p, rest...); n } n template <class T> n inline T CHMAX(T& a, const T b) { n   return a = (a < b) ? b : a; n } n template <class T> n inline T CHMIN(T& a, const T b) { n   return a = (a > b) ? b : a; n } n template <class T> n using V = std::vector<T>; n template <class T> n using VV = V<V<T>>; n template <typename S, typename T> n std::ostream& operator<<(std::ostream& os, std::pair<S, T> p) { n   os <<  (  << p.first <<  ,   << p.second <<  ) ; n   return os; n } n using ll = long long; n using ull = unsigned long long; n using ld = long double; n using PAIR = std::pair<ll, ll>; n using PAIRLL = std::pair<ll, ll>; n constexpr ll INFINT = 1 << 30; n constexpr ll INFINT_LIM = (1LL << 31) - 1; n constexpr ll INFLL = 1LL << 60; n constexpr ll INFLL_LIM = (1LL << 62) - 1 + (1LL << 62); n constexpr double EPS = 1e-6; n constexpr ll MOD = 1000000007; n constexpr double PI = 3.141592653589793238462643383279; n template <class T, size_t N> n void FILL(T (&a)[N], const T& val) { n   for (auto& x : a) x = val; n } n template <class ARY, size_t N, size_t M, class T> n void FILL(ARY (&a)[N][M], const T& val) { n   for (auto& b : a) FILL(b, val); n } n template <class T> n void FILL(std::vector<T>& a, const T& val) { n   for (auto& x : a) x = val; n } n template <class ARY, class T> n void FILL(std::vector<std::vector<ARY>>& a, const T& val) { n   for (auto& b : a) FILL(b, val); n } n struct Trie { n   std::vector<std::vector<ll>> g; n   ll p; n   Trie() : p(0) { n     g.emplace_back(std::vector<ll>(2, -1)); n     ++p; n   } n   void add(const std::string& s) { n     size_t par = 0; n     for (size_t i = 0; i < s.size(); ++i) { n       ll t = s[i] -  0 ; n       if (g[par][t] == -1) { n         g.emplace_back(std::vector<ll>(2, -1)); n         g[par][t] = p++; n       } n       par = g[par][t]; n     } n   } n   ll next(size_t par, char c) { n     ll t = c -  0 ; n     return g[par][t]; n   } n }; n bool ng(std::string s) { n   return s ==  1100  || s ==  1010  || s ==  0111  || s ==  1111 ; n } n signed main() { n   std::ios::sync_with_stdio(false); n   std::cin.tie(0); n   ; n   ll n; n   MACRO_VAR_Scan(n); n   ; n   std::string s; n   for (ll i = 0; i < ll(n); ++i) { n     char c; n     MACRO_VAR_Scan(c); n     ; n     s += c; n   } n   Trie tr; n   std::vector<ll> c(n, 0); n   for (ll i = 0; i < ll(n); ++i) { n     auto S = s.substr(0, i + 1); n     std::reverse((S).begin(), (S).end()); n     std::vector<ll> dp(S.size() + 1, 0); n     dp[0] = 1; n     for (ll j = 0; j < ll(S.size()); ++j) { n       for (ll k = 0; k < ll(4); ++k) { n         if (j < k) break; n         if (k == 3) { n           if (ng(S.substr(j - 3, 4))) continue; n         } n         (dp[j + 1] += dp[j - k]) %= MOD; n       } n     } n     ll p = 0; n     ll len = 0; n     for (ll j = 0; j < ll(S.size()); ++j) { n       ll ne = tr.next(p, S[j]); n       if (ne == -1) break; n       p = ne; n       dp[++len] = 0; n     } n     tr.add(S); n     for (ll j = (1); j < (S.size() + 1); ++j) { n       (c[i] += dp[j]) %= MOD; n     } n   } n   for (ll i = 0; i < ll(n - 1); ++i) (c[i + 1] += c[i]) %= MOD; n   for (ll i = 0; i < ll(n); ++i) { n     std::cout << (c[i]); n     std::cout <<   n ; n     ; n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n template <typename A, typename B, typename C> n struct triple { n   A X; n   B Y; n   C Z; n   triple(A a = 0, B b = 0, C c = 0) : X(a), Y(b), Z(c) {} n }; n template <typename A, typename B, typename C> n triple<A, B, C> make_triple(A a = 0, B b = 0, C c = 0) { n   return triple<A, B, C>(a, b, c); n } n template <typename A, typename B, typename C> n bool operator<(const triple<A, B, C>& a, const triple<A, B, C>& b) { n   if (a.X != b.X) return a.X < b.X; n   if (a.Y != b.Y) return a.Y < b.Y; n   return a.Z < b.Z; n } n template <typename T, typename SS> n ostream& operator<<(ostream& ofs, const pair<T, SS>& p) { n   ofs <<  (   << p.first <<   ,   << p.second <<   ) ; n   return ofs; n } n template <typename T> n void print(T a) { n   for (auto i : a) cout << i <<    ; n   cout <<   n ; n } n template <typename T> n T max(T a, T b, T c) { n   return max(a, max(b, c)); n } n template <typename T> n T min(T a, T b, T c) { n   return min(a, min(b, c)); n } n template <typename T, typename D> n D min(T a) { n   return *min_element(a.begin(), a.end()); n } n template <typename T, typename D> n D max(T a) { n   return *max_element(a.begin(), a.end()); n } n struct custom_hash { n   static uint64_t splitmix64(uint64_t x) { n     x += 0x9e3779b97f4a7c15; n     x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9; n     x = (x ^ (x >> 27)) * 0x94d049bb133111eb; n     return x ^ (x >> 31); n   } n   size_t operator()(uint64_t x) const { n     static const uint64_t FIXED_RANDOM = n         chrono::steady_clock::now().time_since_epoch().count(); n     return splitmix64(x + FIXED_RANDOM); n   } n }; n void solve() { n   string s; n   cin >> s; n   if ((long long)(s.size()) & 1) s =  0  + s; n   long long n = (long long)(s.size()); n   for (long long i = 0; i < (n); i++) s[i] -=  0 ; n   reverse(s.begin(), s.end()); n   vector<vector<long long> > dp(n / 2 + 1, vector<long long>(4)); n   dp[0][0] = 1; n   for (long long i = 0; i < (n / 2); i++) n     for (long long j = 0; j < (4); j++) { n       long long x = 2 * i, y = x + 1; n       long long dx = j & 1, dy = j >> 1; n       for (long long d11 = 0; d11 < (10); d11++) n         for (long long d12 = 0; d12 < (10); d12++) { n           long long sx = d11 + d12 + dx; n           if (sx % 10 != s[x]) continue; n           long long nmask = (sx >= 10); n           for (long long d21 = 0; d21 < (10); d21++) n             for (long long d22 = 0; d22 < (10); d22++) { n               long long sy = d21 + d22 + dy; n               if (sy % 10 != s[y]) continue; n               if (sy >= 10) nmask |= 2; n               dp[i + 1][nmask] += dp[i][j]; n             } n         } n     } n   cout << dp[n / 2][0] - 2 <<   n ; n }; n signed main() { n   if (0) { n     freopen( n          a  n          .in , n          r , stdin); n     freopen( n          a  n          .out , n          w , stdout); n   } n   srand(time(NULL)); n   cin.tie(0); n   cout.tie(0); n   ios_base::sync_with_stdio(false); n   long long t = 1; n   cin >> t; n   for (long long _ = 0; _ < (t); _++) solve(); n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int inf = 1000000000 + 7; n const int N = 1000006; n int n, a[305], ar[6], s, aa, bb, cc, mn = inf, x, t; n int main() { n   cin >> n >> s; n   for (int i = 1; i <= n; i++) { n     scanf( %d , &x); n     ar[x]++; n   } n   for (int i = s / n; i >= 0; i--) { n     for (int j = (s - i * ar[3]) / (ar[4] + ar[5]); j >= i; j--) { n       t = (s - i * ar[3] - j * ar[4]) / ar[5]; n       if (t * ar[5] - j * ar[4] >= mn) break; n       if (i * ar[3] + j * ar[4] + t * ar[5] == s && j <= t) { n         if (mn > abs(i * ar[3] - j * ar[4]) + abs(j * ar[4] - t * ar[5])) { n           aa = i; n           bb = j; n           cc = t; n           mn = abs(i * ar[3] - j * ar[4]) + abs(j * ar[4] - t * ar[5]); n         } n       } n     } n   } n   if (mn == inf) n     cout << -1 << endl; n   else n     cout << aa <<     << bb <<     << cc << endl; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const double pi = acos(-1.0); n const int MAXN = 200005; n int n, x[MAXN]; n long long a[MAXN], t; n long long b[MAXN]; n void solve() { n   for (int i = 0; i + 1 < n; i++) { n     if (x[i] > x[i + 1]) { n       cout <<  No  << endl; n       return; n     } n   } n   for (int i = 0; i < n; i++) { n     if (i > x[i]) { n       cout <<  No  << endl; n       return; n     } n   } n   for (int i = 0; i < n;) { n     int pos = x[i]; n     int j = i; n     while (j < n && x[j] == pos) { n       j++; n     } n     if (j < x[i] + 1) { n       cout <<  No  << endl; n       return; n     } n     long long num = a[j - 1]; n     for (int k = i; k + 1 < j; k++) { n       b[k] = a[k + 1] + t; n     } n     b[j - 1] = a[j - 1] + t + (j - i > 1); n     if (j < n && b[j - 1] >= a[j] + t) { n       cout <<  No  << endl; n       return; n     } n     i = j; n   } n   cout <<  Yes  << endl; n   for (int i = 0; i < n; i++) { n     cout << b[i] <<    ; n   } n   cout << endl; n } n int main() { n   ios_base::sync_with_stdio(false); n   while (cin >> n >> t) { n     for (int i = 0; i < n; i++) { n       cin >> a[i]; n     } n     for (int i = 0; i < n; i++) { n       cin >> x[i]; n       x[i]--; n     } n     solve(); n   } n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int N, Q, C, Rt, L[200005], R[200005], G[200005], F[200005], ch[200005][2]; n struct Nod { n   int Now, Max, Min, Laz; n   Nod() { n     Min = 1 << 30; n     Max = -Min; n   } n } T[200005]; n vector<int> son[200005]; n void Upd(int x, int k) { n   if (x) T[x].Now += k, T[x].Max += k, T[x].Min += k, T[x].Laz += k; n } n void Up(int x) { n   int l = ch[x][0], r = ch[x][1]; n   T[x].Max = max(T[x].Now, max(T[l].Max, T[r].Max)); n   T[x].Min = min(T[x].Now, min(T[l].Min, T[r].Min)); n } n void Dn(int x) { n   int k = T[x].Laz; n   if (k) Upd(ch[x][0], k), Upd(ch[x][1], k), T[x].Laz = 0; n } n void Rot(int x) { n   int y = F[x], z = F[y], k = ch[y][0] == x, t; n   if (t = ch[y][!k] = ch[x][k]) F[t] = y; n   if (F[x] = z) ch[z][ch[z][1] == y] = x; n   ch[F[y] = x][k] = y; n   Up(y); n } n void Splay(int x, int Aim) { n   for (Dn(x); F[x] ^ Aim; Rot(x)) { n     int y = F[x], z = F[y]; n     Dn(z); n     Dn(y); n     Dn(x); n     if (F[y] ^ Aim) (ch[z][0] == y ^ ch[y][0] == x) ? Rot(x) : Rot(y); n   } n   Up(x); n   if (!Aim) Rt = x; n } n void DFS(int u, int d) { n   L[u] = ++C; n   G[C] = u; n   T[C].Now = d; n   for (int i = 1, lim = son[u].size(); i <= lim; i++) DFS(son[u][i - 1], d + 1); n   R[u] = ++C; n   G[C] = u; n   T[C].Now = d; n } n void Build(int& u, int l, int r, int fa) { n   F[u = l + r >> 1] = fa; n   if (l < u) Build(ch[u][0], l, u - 1, u); n   if (u < r) Build(ch[u][1], u + 1, r, u); n   Up(u); n } n int Find(int x, int k) { n   int l = ch[x][0], r = ch[x][1]; n   Dn(x); n   if (T[r].Min <= k && k <= T[r].Max) return Find(r, k); n   return T[x].Now == k ? x : Find(l, k); n } n int Pre(int x) { n   Splay(x, 0); n   x = ch[x][0]; n   for (; ch[x][1]; x = ch[x][1]) Dn(x); n   return x; n } n int Suf(int x) { n   Splay(x, 0); n   x = ch[x][1]; n   for (; ch[x][0]; x = ch[x][0]) Dn(x); n   return x; n } n void Get(int x, int y) { n   Splay(x, 0); n   Splay(y, x); n } n int main() { n   scanf( %d%d , &N, &Q); n   for (int i = 1, lim = N; i <= lim; i++) { n     int x, t; n     scanf( %d , &x); n     for (; x--;) scanf( %d , &t), son[i].push_back(t); n   } n   C++; n   DFS(1, 1); n   C++; n   Build(Rt, 1, C, 0); n   for (int k, x, y, z, l, r, w, t; Q--;) { n     scanf( %d , &k); n     if (k == 1) { n       scanf( %d%d , &x, &y); n       if (x == y) n         puts( 0 ); n       else { n         x = L[x]; n         y = L[y]; n         Get(x, y); n         z = (ch[x][0] == y ? T[ch[y][1]] : T[ch[y][0]]).Min; n         printf( %d n , n                T[x].Now + T[y].Now - 2 * min(z - 1, min(T[x].Now, T[y].Now))); n       } n     } else if (k == 2) { n       scanf( %d%d , &x, &y); n       Get(1, L[x]); n       w = G[Find(ch[L[x]][0], T[L[x]].Now - y)]; n       l = Pre(L[x]); n       r = Suf(R[x]); n       Get(l, r); n       t = ch[r][0]; n       ch[r][0] = 0; n       Up(r); n       Up(l); n       r = R[w]; n       l = Pre(r); n       Get(l, r); n       ch[r][0] = t; n       F[t] = r; n       Upd(t, -y + 1); n       Splay(t, 0); n     } else n       scanf( %d , &x), printf( %d n , G[Find(Rt, x + 1)]); n   } n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const long long N = 112, INF = 1e18; n long long t, n, m, a[N]; n long long B10(string s) { n   reverse(s.begin(), s.end()); n   long long ret = 0; n   for (long long i = 0; i < s.size(); i++) { n     if (s[i] ==  1 ) ret += (1ll << i); n   } n   return ret; n } n string B2(long long a) { n   string ret; n   for (long long i = 0; i < m; i++) { n     if (a & (1ll << i)) n       ret +=  1 ; n     else n       ret +=  0 ; n   } n   reverse(ret.begin(), ret.end()); n   return ret; n } n long long BS() { n   long long low = 0, high = (1ll << m); n   while (high - low > 1) { n     long long mid = (low + high) >> 1; n     long long v1 = mid - (lower_bound(a, a + n, mid) - a); n     long long v2 = ((1ll << m) - n - 1) / 2; n     if (v1 <= v2) n       low = mid; n     else n       high = mid; n   } n   return low; n } n int32_t main() { n   ios::sync_with_stdio(0); n   cin.tie(0); n   cout.tie(0); n   cin >> t; n   while (t--) { n     cin >> n >> m; n     for (long long i = 0; i < n; i++) { n       string s; n       cin >> s; n       a[i] = B10(s); n     } n     sort(a, a + n); n     cout << B2(BS()) <<   n ; n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int p[100100]; n int main() { n   int n, a, b, t, cn = 1; n   cin >> n; n   for (int i = 0; i < n; i++) { n     cin >> a; n     p[i] = a; n   } n   sort(p, p + n); n   int ans = 0; n   vector<int> v; n   for (int i = 0; i < n; i++) { n     int j = 0; n     for (j = 0; j < v.size(); j++) { n       if (p[i] >= v[j]) { n         v[j]++; n         break; n       } n     } n     if (j == v.size()) { n       v.push_back(1); n     } n   } n   cout << v.size() << endl; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int N = 2100; n char mp[N][N]; n int n, m, lp, rp, dis[N][N]; n bool vis[N][N]; n struct poi { n   int x, y; n } q[N * N], st; n void expan(int x, int y, int di) { n   int i; n   for (i = x; mp[i][y] !=  * ; i--) { n     q[++rp] = (poi){i, y}; n     dis[i][y] = di; n     vis[i][y] = 1; n   } n   for (i = x + 1; mp[i][y] !=  * ; i++) { n     q[++rp] = (poi){i, y}; n     dis[i][y] = di; n     vis[i][y] = 1; n   } n } n int main() { n   int i, j, k, le, ri, x, y; n   scanf( %d%d%d%d%d%d , &n, &m, &st.x, &st.y, &le, &ri); n   for (i = 1; i <= n; i++) scanf( %s , mp[i] + 1); n   for (i = 0; i <= m + 1; i++) mp[0][i] = mp[n + 1][i] =  * ; n   for (i = 0; i <= n + 1; i++) mp[i][0] = mp[i][m + 1] =  * ; n   lp = 1; n   rp = 0; n   expan(st.x, st.y, 0); n   while (lp <= rp) { n     poi now = q[lp++]; n     x = now.x; n     y = now.y; n     if ((!vis[x][y - 1]) && (mp[x][y - 1] !=  * )) n       expan(x, y - 1, dis[x][y] + 1); n     if ((!vis[x][y + 1]) && (mp[x][y + 1] !=  * )) n       expan(x, y + 1, dis[x][y] + 1); n   } n   int ans = 0; n   for (i = 1; i <= n; i++) n     for (j = 1; j <= m; j++) { n       int fix = st.y - j; n       if ((vis[i][j]) && (mp[i][j] !=  * ) && n           (le >= ((dis[i][j] + fix) >> 1)) && (ri >= ((dis[i][j] - fix) >> 1))) n         ans++; n     } n   printf( %d n , ans); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n char buf[25]; n struct node { n   long long x, y; n   bool operator<(node tp) const { n     if (x != tp.x) return x < tp.x; n     return y < tp.y; n   } n }; n map<long long, long long> h1, h2; n map<node, long long> t, q; n const long long inf = 1e17; n const long long maxn = 200010; n long long L1[maxn], R1[maxn], l1[maxn], r1[maxn], s1[maxn], a[maxn]; n long long L2[maxn], R2[maxn], l2[maxn], r2[maxn], s2[maxn]; n long long n, m, sum1, sum2; n long long ans; n long long read() { n   long long x = 0, f = 0; n   char ch; n   do { n     ch = getchar(); n     if (ch ==  - ) f = 1; n   } while (ch <  0  || ch >  9 ); n   while (ch >=  0  && ch <=  9 ) { n     x = (x << 1) + (x << 3) + (ch ^ 48); n     ch = getchar(); n   } n   return f ? -x : x; n } n void write(long long x) { n   if (x < 0) { n     putchar( - ); n     x = -x; n   } n   if (!x) { n     putchar( 0 ); n     return; n   } n   long long cnt = 0; n   while (x) { n     buf[++cnt] =  0  + x % 10; n     x /= 10; n   } n   for (long long i = cnt; i >= 1; --i) putchar(buf[i]); n } n signed main() { n   srand(19267180); n   n = read(); n   m = read(); n   for (long long i = 1; i <= n; ++i) { n     h1[i] = (1ll * rand() * rand() * rand() * rand() % inf + inf) % inf; n     h2[i] = (1ll * rand() * rand() * rand() * rand() % inf + inf) % inf; n     sum1 = h1[i] ^ sum1; n     sum2 = h2[i] ^ sum2; n   } n   for (long long i = 1; i <= n; ++i) { n     long long l = read(), r = read(); n     ++a[l]; n     --a[r + 1]; n     s1[l] ^= h1[i]; n     s1[r + 1] ^= h1[i]; n     L1[l - 1] ^= h1[i]; n     R1[r + 1] ^= h1[i]; n     s2[l] ^= h2[i]; n     s2[r + 1] ^= h2[i]; n     L2[l - 1] ^= h2[i]; n     R2[r + 1] ^= h2[i]; n   } n   for (long long i = m - 1; i >= 1; --i) L1[i] ^= L1[i + 1], L2[i] ^= L2[i + 1]; n   for (long long i = 2; i <= m; ++i) { n     R1[i] ^= R1[i - 1], s1[i] ^= s1[i - 1]; n     R2[i] ^= R2[i - 1], s2[i] ^= s2[i - 1]; n   } n   for (long long i = 2; i <= m; ++i) s1[i] ^= s1[i - 1], s2[i] ^= s2[i - 1]; n   for (long long i = 1; i <= m; ++i) { n     l1[i] = s1[i - 1] ^ R1[i], r1[i] = s1[i] ^ L1[i]; n     l2[i] = s2[i - 1] ^ R2[i], r2[i] = s2[i] ^ L2[i]; n   } n   for (long long i = m; i >= 1; --i) { n     t[(node){r1[i], r2[i]}] += 1; n     q[(node){r1[i], r2[i]}] += i; n     long long x_1 = sum1 ^ l1[i], x_2 = sum2 ^ l2[i]; n     ans += q[(node){x_1, x_2}] - 1ll * t[(node){x_1, x_2}] * (i - 1); n   } n   for (long long i = 1; i <= m; ++i) a[i] += a[i - 1]; n   long long x = 0; n   for (long long i = 1; i <= m; ++i) { n     if (a[i] == 0) n       ++x; n     else n       x = 0; n     if (x) n       if (i == m || a[i + 1] != 0) n         for (long long j = 1; j <= x; ++j) ans -= 1ll * j * (x - j + 1); n   } n   write(ans); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n void RI() {} n template <typename... T> n void RI(int& head, T&... tail) { n   scanf( %d , &head); n   RI(tail...); n } n template <typename T> n void _dump(const char* s, T&& head) { n   cerr << s <<  =  << head << endl; n } n template <typename T, typename... Args> n void _dump(const char* s, T&& head, Args&&... tail) { n   int c = 0; n   while (*s !=  ,  || c != 0) { n     if (*s ==  (  || *s ==  [  || *s ==  { ) c++; n     if (*s ==  )  || *s ==  ]  || *s ==  } ) c--; n     cerr << *s++; n   } n   cerr <<  =  << head <<  ,  ; n   _dump(s + 1, tail...); n } n template <typename Iter> n ostream& _out(ostream& s, Iter b, Iter e) { n   s <<  [ ; n   for (auto it = b; it != e; it++) s << (it == b ?    :    ) << *it; n   s <<  ] ; n   return s; n } n template <typename A, typename B> n ostream& operator<<(ostream& s, const pair<A, B>& p) { n   return s <<  (  << p.first <<  ,  << p.second <<  ) ; n } n template <typename T> n ostream& operator<<(ostream& s, const vector<T>& c) { n   return _out(s, begin(c), end(c)); n } n template <typename T> n ostream& operator<<(ostream& s, const set<T>& c) { n   return _out(s, begin(c), end(c)); n } n template <typename A, typename B> n ostream& operator<<(ostream& s, const map<A, B>& c) { n   return _out(s, begin(c), end(c)); n } n vector<int> app[1000010]; n int ask(int l, int r, int v) { n   auto it = lower_bound(begin(app[v]), end(app[v]), l); n   auto jt = upper_bound(begin(app[v]), end(app[v]), r); n   return jt - it; n } n int n, m, a[300010], sa[300010], ord[300010], l[300010], r[300010]; n bool vis[300010]; n bool cmp(int x, int y) { return a[x] < a[y]; } n long long calc(int l1, int r1, int l2, int r2, int mx) { n   long long ans = 0; n   mx %= m; n   if (r1 - l1 <= r2 - l2) { n     for (int i = (l1 - 1); i <= int(r1 - 1); i++) { n       int x = sa[i] + mx; n       if (x >= m) x -= m; n       int now = ask(l2, r2, x); n       ans += now; n     } n   } else { n     for (int i = (l2); i <= int(r2); i++) { n       int x = sa[i] - mx; n       if (x < 0) x += m; n       int now = ask(l1 - 1, r1 - 1, x); n       ans += now; n     } n   } n   return ans; n } n int main() { n   RI(n, m); n   for (int i = (1); i <= int(n); i++) RI(a[i]); n   for (int i = (1); i <= int(n); i++) l[i] = r[i] = i; n   for (int i = (1); i <= int(n); i++) ord[i] = i; n   for (int i = (1); i <= int(n); i++) sa[i] = (sa[i - 1] + a[i]) % m; n   for (int i = (0); i <= int(n); i++) app[sa[i]].push_back(i); n   sort(ord + 1, ord + n + 1, cmp); n   long long ans = 0; n   for (int ii = (1); ii <= int(n); ii++) { n     int i = ord[ii]; n     vis[i] = 1; n     if (i > 1 && vis[i - 1]) { n       ans += calc(l[i - 1], i - 1, i, i, a[i]); n       l[i] = l[i - 1]; n       r[l[i - 1]] = i; n     } n     if (i < n && vis[i + 1]) { n       ans += calc(l[i], i, i + 1, r[i + 1], a[i]); n       r[l[i]] = r[i + 1]; n       l[r[i + 1]] = l[i]; n     } n   } n   cout << ans << endl; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int n, m; n long long a, b[100100], p[100100]; n int main() { n   ios::sync_with_stdio(false); n   cin.tie(NULL); n   cout.tie(NULL); n   cin >> n >> m >> a; n   for (int i = 1; i <= n; i++) cin >> b[i]; n   for (int i = 1; i <= m; i++) cin >> p[i]; n   sort(b + 1, b + n + 1); n   sort(p + 1, p + m + 1); n   int le = -1, ri = min(n, m) + 1; n   while (le + 1 < ri) { n     int mi = (le + ri) / 2; n     long long cnt = 0; n     for (int i = 1; i <= mi; i++) { n       cnt += max(0LL, p[mi + 1 - i] - b[n + 1 - i]); n     } n     if (cnt > a) { n       ri = mi; n     } else { n       le = mi; n     } n   } n   long long tot = 0; n   for (int i = 1; i <= le; i++) tot += p[i]; n   cout << le <<     << max(tot - a, 0LL) << endl; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int n, a[100000], outpalsz, inn, b[100000]; n long long result; n int inicount[100001], iniodd; n int ccount[100001], codd; n int main() { n   cin.sync_with_stdio(false); n   cin >> n; n   for (int i = 0; i < n; i++) cin >> a[i]; n   for (int i = 0; i < n - 1 - i && a[i] == a[n - 1 - i]; i++) outpalsz++; n   for (int i = outpalsz; i < n - outpalsz; i++) { n     inicount[a[i]]++; n     if (inicount[a[i]] % 2) n       iniodd++; n     else n       iniodd--; n     b[inn++] = a[i]; n   } n   if (inn <= 1) { n     cout << 1LL * n * (n + 1) / 2 <<   n ; n     return 0; n   } n   if (iniodd <= 1) result = 1LL * (outpalsz + 1) * (outpalsz + 1); n   for (int i = 0; i <= 100000; i++) ccount[i] = inicount[i]; n   codd = iniodd; n   for (int i = 0; i < inn; i++) { n     ccount[b[i]] -= 2; n     if (i * 2 + 1 == inn) ccount[b[i]]++; n     if (i > inn - 1 - i && b[i] == b[inn - 1 - i]) ccount[b[i]] += 2; n     if (ccount[b[i]] < 0) break; n     if (codd <= 1) result += outpalsz + 1; n   } n   for (int i = 0; i <= 100000; i++) ccount[i] = inicount[i]; n   codd = iniodd; n   for (int i = inn - 1; i >= 0; i--) { n     ccount[b[i]] -= 2; n     if (i * 2 + 1 == inn) ccount[b[i]]++; n     if (i < inn - 1 - i && b[i] == b[inn - 1 - i]) ccount[b[i]] += 2; n     if (ccount[b[i]] < 0) break; n     if (codd <= 1) result += outpalsz + 1; n   } n   cout << result <<   n ; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n long long get(string a) { n   long long len = a.length(); n   long long b = 0; n   long long cnt = 1; n   for (int i = len - 1; i >= 0; i--) { n     b += ((a[i] -  0 ) % 2) * cnt; n     cnt *= 2; n   } n   return b; n } n int p[262150]; n int main() { n   int t; n   cin >> t; n   while (t--) { n     char c; n     cin >> c; n     string a; n     cin >> a; n     long long b = get(a); n     switch (c) { n       case  + : { n         p[b]++; n         break; n       } n       case  - : { n         p[b]--; n         break; n       } n       case  ? : { n         cout << p[b] << endl; n         break; n       } n     } n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int MOD = (int)1e9 + 7; n const int INF = (int)1e9; n const long long LINF = (long long)1e18; n const long double PI = acos((long double)-1); n const long double EPS = 1e-9; n inline long long gcd(long long a, long long b) { n   long long r; n   while (b) { n     r = a % b; n     a = b; n     b = r; n   } n   return a; n } n inline long long lcm(long long a, long long b) { return a / gcd(a, b) * b; } n inline long long fpow(long long n, long long k, int p = MOD) { n   long long r = 1; n   for (; k; k >>= 1) { n     if (k & 1) r = r * n % p; n     n = n * n % p; n   } n   return r; n } n template <class T> n inline int chkmin(T& a, const T& val) { n   return val < a ? a = val, 1 : 0; n } n template <class T> n inline int chkmax(T& a, const T& val) { n   return a < val ? a = val, 1 : 0; n } n template <class T> n inline T isqrt(T k) { n   T r = sqrt(k) + 1; n   while (r * r > k) r--; n   return r; n } n template <class T> n inline T icbrt(T k) { n   T r = cbrt(k) + 1; n   while (r * r * r > k) r--; n   return r; n } n inline void addmod(int& a, int val, int p = MOD) { n   if ((a = (a + val)) >= p) a -= p; n } n inline void submod(int& a, int val, int p = MOD) { n   if ((a = (a - val)) < 0) a += p; n } n inline int mult(int a, int b, int p = MOD) { return (long long)a * b % p; } n inline int inv(int a, int p = MOD) { return fpow(a, p - 2, p); } n const int maxn = 2000 + 10; n const int maxm = 500000 + 10; n int n, m; n int a[maxm]; n int b[maxm]; n bitset<maxn << 1> mat[maxn]; n void solve() { n   cin >> n >> m; n   for (int i = (0); i < (m); i++) { n     cin >> a[i] >> b[i], a[i]--, b[i]--; n     mat[b[i]][a[i]] = 1; n   } n   for (int i = (0); i < (n); i++) n     for (int j = (0); j < (n); j++) mat[i][j + n] = i == j; n   for (int i = (0); i < (n); i++) { n     if (!mat[i][i]) { n       for (int j = (i + 1); j < (n); j++) n         if (mat[j][i]) { n           mat[i] ^= mat[j]; n           break; n         } n     } n     for (int j = (0); j < (n); j++) { n       if (j == i) continue; n       if (mat[j][i]) { n         mat[j] ^= mat[i]; n       } n     } n   } n   for (int i = (0); i < (m); i++) { n     if (!mat[a[i]][b[i] + n]) { n       cout <<  YES n ; n     } else { n       cout <<  NO n ; n     } n   } n } n int main() { n   ios_base::sync_with_stdio(0); n   cin.tie(0); n   solve(); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int main() { n   string str; n   cin >> str; n   int ans(0); n   for (int i = 0; i < str.size(); ++i) n     if (str[i] != str[str.size() - 1 - i]) ++ans; n   if (ans == 2 || (ans == 0 && str.size() % 2 == 1)) n     cout <<  YES  << endl; n   else n     cout <<  NO  << endl; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n #pragma comment(linker,  /STACK:256000000 ) n using namespace std; n int main() { n   srand(1373737); n   ios_base::sync_with_stdio(false); n   cin.tie(NULL); n   cout.tie(NULL); n   int n, t, k, d, q; n   cin >> n >> q; n   vector<int> arr(n); n   for (int i = 0; i < (int)q; i++) { n     cin >> t >> k >> d; n     int free = 0; n     for (int j = 0; j < (int)n; j++) { n       if (arr[j] <= t) free++; n     } n     if (free < k) { n       cout << -1 <<   n ; n       continue; n     } n     int res = 0; n     for (int j = 0; j < n && k; j++) { n       if (arr[j] <= t) { n         arr[j] = t + d; n         k--; n         res += j + 1; n       } n     } n     cout << res <<   n ; n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n template <class T> n inline bool uin(T& a, T b) { n   return a > b ? (a = b, true) : false; n } n template <class T> n inline bool uax(T& a, T b) { n   return a < b ? (a = b, true) : false; n } n int main() { n   ios::sync_with_stdio(false); n   cin.tie(0); n   long long N, K; n   cin >> N >> K; n   if (K == 1) { n     cout << N <<   n ; n     return 0; n   } n   string be, en; n   cin >> be >> en; n   long long ans = 0, cur = 1; n   for (int i = 0; i < N; ++i) { n     cur *= 2LL; n     if (be[i] ==  b ) --cur; n     if (en[i] ==  a ) --cur; n     uin(cur, K); n     ans += cur; n   } n   cout << ans <<   n ; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n #pragma GCC optimize( O2 ) n #pragma GCC optimize( unroll-loops ) n struct POINT { n   int x, y; n   POINT() : x(0), y(0) {} n   POINT(int x, int y) : x(x), y(y) {} n   POINT operator+(const POINT &t) const { return POINT(x + t.x, y + t.y); } n   POINT operator-(const POINT &t) const { return POINT(x - t.x, y - t.y); } n   POINT operator!() const { return POINT(-y, x); } n }; n inline long long dot(const POINT &a, const POINT &b) { n   return (long long)a.x * b.x + (long long)a.y * b.y; n } n inline long long cross(const POINT &a, const POINT &b) { n   return (long long)a.x * b.y - (long long)a.y * b.x; n } n inline long long cross(const POINT &a, const POINT &b, const POINT &c) { n   return cross(a - c, b - c); n } n inline bool halfPlane(const POINT &p) { n   if (p.y == 0) return p.x < 0; n   return p.y < 0; n } n inline bool angSortCmp(const POINT &a, const POINT &b) { n   bool ha = halfPlane(a); n   bool hb = halfPlane(b); n   if (ha != hb) return ha < hb; n   return cross(a, b) > 0; n } n const int N = 2000; n int n; n long long S; n POINT tab[N + 7]; n int poz[N + 7]; n POINT stab[N + 7]; n struct kierunek { n   POINT wek; n   int p, q; n }; n int main() { n   ios_base::sync_with_stdio(0); n   cin >> n >> S; n   S *= 2; n   for (int i = 1; i <= n; ++i) cin >> tab[i].x >> tab[i].y; n   sort(tab + 1, tab + n + 1, [](const POINT &a, const POINT &b) -> bool { n     if (a.x == b.x) return a.y > b.y; n     return a.x < b.x; n   }); n   for (int i = 1; i <= n; ++i) { n     poz[i] = i; n     stab[i] = tab[i]; n   } n   vector<kierunek> kol((n * (n - 1)) / 2); n   int it = 0; n   for (int i = 1; i <= n; ++i) { n     for (int j = i + 1; j <= n; ++j) { n       kol[it].wek = !(tab[j] - tab[i]); n       kol[it].p = i; n       kol[it].q = j; n       it++; n     } n   } n   sort(kol.begin(), kol.end(), n        [](const kierunek &a, const kierunek &b) -> bool { n          return angSortCmp(a.wek, b.wek); n        }); n   for (kierunek u : kol) { n     int p = u.p; n     int q = u.q; n     swap(stab[poz[p]], stab[poz[q]]); n     swap(poz[p], poz[q]); n     int l = 1; n     int r = n; n     while (l <= r) { n       int s = (l + r) / 2; n       long long ww = cross(tab[q], stab[s], tab[p]); n       if (ww == S) { n         cout <<  Yes  << endl; n         cout << tab[p].x <<     << tab[p].y << endl; n         cout << tab[q].x <<     << tab[q].y << endl; n         cout << stab[s].x <<     << stab[s].y << endl; n         exit(0); n       } n       if (ww > S) n         r = s - 1; n       else n         l = s + 1; n     } n     l = 1; n     r = n; n     while (l <= r) { n       int s = (l + r) / 2; n       long long ww = cross(tab[q], stab[s], tab[p]); n       if (ww == -S) { n         cout <<  Yes  << endl; n         cout << tab[p].x <<     << tab[p].y << endl; n         cout << tab[q].x <<     << tab[q].y << endl; n         cout << stab[s].x <<     << stab[s].y << endl; n         exit(0); n       } n       if (ww > -S) n         r = s - 1; n       else n         l = s + 1; n     } n   } n   cout <<  No  << endl; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int main() { n   ios::sync_with_stdio(0); n   int i, j, n, m, k, l, r; n   cin >> n >> m; n   int a[n][m]; n   pair<int, int> start_end[n][m]; n   for (i = 0; i < n; i += 1) n     for (j = 0; j < m; j += 1) { n       cin >> a[i][j]; n       start_end[i][j].first = i; n       start_end[i][j].second = i; n     } n   for (j = 0; j < m; j += 1) n     for (i = 1; i < n; i += 1) n       if (a[i][j] >= a[i - 1][j]) n         start_end[i][j].first = start_end[i - 1][j].first; n   int min_l[n]; n   for (i = 0; i < n; i++) min_l[i] = 100010; n   for (i = 0; i < n; i += 1) n     for (j = 0; j < m; j += 1) n       if (start_end[i][j].first < min_l[i]) min_l[i] = start_end[i][j].first; n   cin >> k; n   while (k--) { n     cin >> l >> r; n     cout << ((min_l[r - 1] <= l - 1) ?  Yes n  :  No n ); n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n template <typename T> n void read(T &x) { n   x = 0; n   char ch = getchar(); n   long long fh = 1; n   while (ch <  0  || ch >  9 ) { n     if (ch ==  - ) fh = -1; n     ch = getchar(); n   } n   while (ch >=  0  && ch <=  9 ) x = x * 10 + ch -  0 , ch = getchar(); n   x *= fh; n } n template <typename T> n void write(T x) { n   if (x < 0) x = -x, putchar( - ); n   if (x > 9) write(x / 10); n   putchar(x % 10 +  0 ); n } n template <typename T> n void writeln(T x) { n   write(x); n   puts(  ); n } n long long n, a[100005]; n signed main() { n   ios::sync_with_stdio(false); n   cin.tie(0); n   cout.tie(0); n   long long t; n   cin >> t; n   while (t--) { n     cin >> n; n     for (long long i = 1; i <= n; i++) cin >> a[i]; n     long long x = 0; n     for (long long i = n; i >= 1; i--) n       if (a[i] < 0) n         x += -a[i]; n       else if (x >= a[i]) n         x -= a[i]; n       else n         x = 0; n     cout << x << endl; n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int main() { n   ios_base::sync_with_stdio(false); n   cin.tie(0); n   cout.tie(0); n   int n, m, h; n   cin >> n >> m >> h; n   vector<int> ms(m), ns(n); n   vector<vector<int> > ok(n, vector<int>(m)); n   for (int i = 0; i < m; i++) { n     cin >> ms[i]; n   } n   for (int i = 0; i < n; i++) { n     cin >> ns[i]; n   } n   for (int i = 0; i < n; i++) { n     for (int j = 0; j < m; j++) { n       cin >> ok[i][j]; n     } n   } n   for (int i = 0; i < n; i++) { n     for (int j = 0; j < m; j++) { n       if (ok[i][j] == 0) { n         cout << 0 <<    ; n       } else { n         cout << min(ms[j], ns[i]) <<    ; n       } n     } n     cout << endl; n   } n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int r, g, j, f[200001], sc, kq, mod = round(1e9) + 7; n long long i, h; n int main() { n   cin >> r >> g; n   f[0] = 1; n   for (i = 1; i * (i + 1) / 2 <= r + g; i++) { n     for (j = r; j >= 0; j--) { n       if (j >= i) f[j] = (f[j] + f[j - i]) % mod; n     } n   } n   h = i - 1; n   for (i = 0; i <= r; i++) n     if (h * (h + 1) / 2 - i <= g) kq = (kq + f[i]) % mod; n   cout << kq; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int maxn = 1e5 + 7; n vector<pair<int, int> > s; n int co[maxn], deg[maxn]; n int main() { n   int n; n   cin >> n; n   for (int i = 0; i < n - 1; i++) { n     pair<int, int> q; n     cin >> q.first >> q.second; n     s.push_back(q); n   } n   for (int i = 1; i <= n; i++) { n     cin >> co[i]; n   } n   int x = 0; n   for (auto i : s) { n     if (co[i.first] != co[i.second]) { n       deg[i.first]++; n       deg[i.second]++; n       x++; n     } n   } n   int flag = 0; n   for (int i = 1; i <= n; i++) { n     if (deg[i] == x) { n       flag = i; n     } n   } n   if (flag) { n     printf( YES n%d n , flag); n   } else { n     printf( NO n ); n   } n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n void solve() { n   long long n, k, kol = 0; n   cin >> n >> k; n   string s; n   cin >> s; n   vector<long long> a(n); n   for (long long i = 0; i < n; i++) { n     a[i] = s[i] -  0 ; n   } n   for (long long i = 0; i < n - 1 && k; i++) { n     if (a[i] == 4 && a[i + 1] == 7) { n       if (i % 2 == 0) { n         a[i + 1] = 4; n         k--; n       } else { n         if (i > 0 && a[i - 1] == 4) { n           if (k % 2 == 1) { n             a[i] = 7; n           } n           break; n         } n         a[i] = a[i + 1] = 7; n         k--; n       } n     } n   } n   for (long long i = 0; i < n; i++) { n     cout << a[i]; n   } n } n signed main() { n   ios_base::sync_with_stdio(0); n   cin.tie(0); n   cout.tie(0); n   long long t = 1; n   while (t--) { n     solve(); n   } n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n #pragma warning(disable : 4996) n using namespace std; n int n, l; n long long a[300000][3]; n long long b[300000][3]; n long long t[300000][2]; n vector<int> c[3000000]; n vector<pair<long long, long long> > g; n long long p[3000000]; n long long dab[3000000][2]; n void sayno() { n   printf( NO ); n   exit(0); n } n void calc() { n   int i, j, k; n   long long d = -1; n   for (i = 0; i < l; i++) { n     if (c[i].size() >= 2) { n       d = (t[c[i][1]][1] - t[c[i][0]][1]) / n           ((t[c[i][1]][0] - t[c[i][0]][0]) / l); n       break; n     } n   } n   if (d == -1) { n     int past = 0; n     g.clear(); n     for (i = 1; i <= l; i++) { n       if (!c[i % l].size()) continue; n       int x = c[past][0], y = c[i % l][0]; n       if (t[x][0] < t[y][0]) { n         long long u = (t[y][0] - t[x][0]) / l; n         long long v = t[y][1] - t[x][1]; n         long long w = (t[y][0] - t[x][0]) % l; n         if (u != 0) n           g.push_back(pair<long long, long long>((v - w + u - 1) / u, v / u)); n       } else { n         long long u = (t[x][0] - t[y][0]) / l + 1; n         long long v = t[x][1] - t[y][1]; n         long long w = t[y][0] + u * l - t[x][0]; n         if (u != 0) n           g.push_back(pair<long long, long long>((v + u - 1) / u, (v + w) / u)); n       } n       past = i; n     } n     sort(g.begin(), g.end()); n     for (auto e : g) { n       if (e.second < g.back().first) sayno(); n     } n     d = g.back().first; n   } n   memset(p, -1, sizeof(p)); n   for (i = 0; i < n; i++) { n     long long u = t[i][1] - d * (t[i][0] / l); n     long long v = t[i][0] % l; n     if (p[v] == -1) n       p[v] = u; n     else if (p[v] != u) n       sayno(); n   } n   p[l] = d; n   int past = 0; n   for (i = 1; i <= l; i++) { n     if (p[i] == -1) continue; n     if (p[i] - p[past] < 0 || p[i] - p[past] > i - past) sayno(); n     for (j = 0; j < p[i] - p[past]; j++) { n       dab[past + j][1] = 1; n     } n     for (j = p[i] - p[past]; j < i - past; j++) { n       dab[past + j][1] = -1; n     } n     past = i; n   } n } n int main() { n   int i, j, k; n   cin >> n >> l; n   for (i = 0; i <= n; i++) { n     if (i != 0) scanf( %I64d%I64d%I64d , &a[i][0], &a[i][1], &a[i][2]); n     b[i][0] = a[i][0], b[i][1] = a[i][1] + a[i][2], b[i][2] = a[i][1] - a[i][2]; n     if ((b[i][1] + b[i][0]) % 2 == 1 || (b[i][2] + b[i][0]) % 2 == 1) sayno(); n     b[i][1] = (b[i][1] + b[i][0]) / 2, b[i][2] = (b[i][2] + b[i][0]) / 2; n     c[b[i][0] % l].push_back(i); n   } n   n++; n   for (i = 0; i < n; i++) t[i][0] = b[i][0], t[i][1] = b[i][1]; n   calc(); n   for (i = 0; i < l; i++) dab[i][0] = dab[i][1]; n   for (i = 0; i < n; i++) t[i][0] = b[i][0], t[i][1] = b[i][2]; n   calc(); n   for (i = 0; i < l; i++) { n     if (dab[i][0] == -1 & dab[i][1] == -1) n       printf( L ); n     else if (dab[i][0] == 1 && dab[i][1] == 1) n       printf( R ); n     else if (dab[i][0] == -1 && dab[i][1] == 1) n       printf( D ); n     else n       printf( U ); n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n vector<vector<long long> > matmul(vector<vector<long long> > &a, n                                   vector<vector<long long> > &b) { n   int i, j, k, n = a.size(); n   vector<vector<long long> > ans(n, vector<long long>(n)); n   for (i = 0; i < n; i++) n     for (j = 0; j < n; j++) { n       long long temp = 0; n       for (k = 0; k < n; k++) n         temp = (temp + a[i][k] * b[k][j]) % (1000000007LL); n       ans[i][j] = temp; n     } n   return ans; n } n vector<vector<long long> > matpwr(vector<vector<long long> > &a, long long p) { n   int n = a.size(); n   vector<vector<long long> > ans(n, vector<long long>(n)); n   for (int i = 0; i < n; i++) ans[i][i] = 1; n   while (p) { n     if (p & 1) ans = matmul(ans, a); n     a = matmul(a, a); n     p >>= 1; n   } n   return ans; n } n long long pwr(long long base, long long p, long long mod = (1000000007LL)) { n   long long ans = 1; n   while (p) { n     if (p & 1) ans = (ans * base) % mod; n     base = (base * base) % mod; n     p /= 2; n   } n   return ans; n } n long long gcd(long long a, long long b) { n   if (b == 0) return a; n   return gcd(b, a % b); n } n long long lcm(long long a, long long b) { return (a * b) / gcd(a, b); } n long long invMod(long long n, long long mod = (1000000007LL)) { n   return pwr(n, mod - 2); n } n int n, arr[2000003]; n int main() { n   ios_base::sync_with_stdio(0); n   cin >> n; n   for (int i = 1; i <= n; i++) arr[i] = i; n   int start = 1; n   for (int iter = 2; iter <= n; iter++) { n     int last = arr[start]; n     for (int j = start + iter; j < start + n; j += iter) { n       int temp = last; n       last = arr[j]; n       arr[j] = temp; n     } n     arr[start + n] = last; n     start++; n   } n   for (int i = start; i < start + n; i++) cout << arr[i] <<    ; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int n, a[110], b[110], sum = 0; n pair<int, int> dp[110][11000], q = {-1, -1}; n pair<int, int> Rec(int i, int W) { n   if (i == n) { n     if (W >= sum) n       return {0, 0}; n     else n       return {1e9, 1e9}; n   } n   if (dp[i][W] != q) return dp[i][W]; n   pair<int, int> Res1 = {1e9, 1e9}, Res2 = {1e9, 1e9}; n   Res1 = {0 + Rec(i + 1, W).first, a[i] + Rec(i + 1, W).second}; n   Res2 = {1 + Rec(i + 1, W + b[i]).first, 0 + Rec(i + 1, W + b[i]).second}; n   return dp[i][W] = min(Res1, Res2); n } n int main() { n   memset(dp, -1, sizeof(dp)); n   cin >> n; n   for (int i = 0; i < n; i++) cin >> a[i], sum += a[i]; n   for (int i = 0; i < n; i++) cin >> b[i]; n   cout << Rec(0, 0).first <<     << Rec(0, 0).second; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n char s[200005]; n int n; n int mem[200005][27]; n int dirr[200005][27]; n bool vis[200005][27]; n char other(char c, char d) { n   if ( a  != c &&  a  != d) return  a ; n   if ( b  != c &&  b  != d) return  b ; n   return  c ; n } n int solve(int ind, int lst) { n   if (ind >= n) return 0; n   if (vis[ind][lst]) return mem[ind][lst]; n   vis[ind][lst] = 1; n   int ans1 = -1, ans2 = -1, ans = -1, dir = -1; n   if (s[ind] -  a  != lst) ans1 = solve(ind + 1, s[ind] -  a ); n   ans2 = 1 + solve(ind + 1, other(s[ind + 1], lst +  a ) -  a ); n   if (ans1 == -1 || ans2 <= ans1) n     dir = 1, ans = ans2; n   else n     dir = 0, ans = ans1; n   dirr[ind][lst] = dir; n   return mem[ind][lst] = ans; n } n int main() { n   ios::sync_with_stdio(false); n   scanf( %s , s); n   n = strlen(s); n   solve(0, 26); n   int lst = 26; n   for (int i = 0; i < n; i++) n     if (dirr[i][lst] == 0) n       lst = s[i] -  a ; n     else n       s[i] = lst = other(s[i + 1], lst +  a ), lst -=  a ; n   puts(s); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int mod = 1000000007; n const int N = 3020; n const int D = 1001; n int c[N][N], x[N], y[N], b[N], v[N][N], f[N][N], w[N]; n int dis(int i, int j) { return max(abs(x[i] - x[j]), abs(y[i] - y[j])); } n int C(int x, int y) { return x >= y ? c[x][y] : 0; } n int main() { n   int n, m, r, i, j, u, d, l, ri, ans = 0, tmp; n   scanf( %d%d%d , &n, &m, &r); n   c[0][0] = 1; n   for (i = 1; i <= 2000; i++) { n     c[i][0] = 1; n     for (j = 1; j <= i; j++) c[i][j] = (c[i - 1][j - 1] + c[i - 1][j]) % mod; n   } n   for (i = 1; i <= n; i++) { n     scanf( %d%d%d , &x[i], &y[i], &b[i]); n     x[i] += D, y[i] += D; n     v[x[i]][y[i]]++; n   } n   for (i = 1; i <= 3000; i++) n     for (j = 1; j <= 3000; j++) n       v[i][j] += v[i - 1][j] + v[i][j - 1] - v[i - 1][j - 1]; n   for (i = 1; i <= n - 1; i++) { n     for (j = i + 1; j <= n; j++) { n       u = max(y[i], y[j]) - r; n       d = min(y[i], y[j]) + r; n       l = max(x[i], x[j]) - r; n       ri = min(x[i], x[j]) + r; n       if (l <= ri && u <= d) n         f[i][j] = v[ri][d] - v[l - 1][d] - v[ri][u - 1] + v[l - 1][u - 1]; n     } n   } n   for (i = 1; i <= n; i++) { n     for (j = 1; j <= n; j++) { n       if (dis(i, j) > r) w[i]++; n     } n     ans = (ans + n            (long long)(C(n, m) - C(w[i], m) + mod) * b[i] % mod * b[i] % mod) % n           mod; n   } n   for (i = 1; i <= n - 1; i++) n     for (j = i + 1; j <= n; j++) { n       tmp = ((C(w[i], m) + C(w[j], m) - n               C(n - (n - w[i] + n - w[j] - f[i][j]), m)) % n                  mod + n              mod) % n             mod; n       ans = (ans + n              (long long)(C(n, m) - tmp + mod) * b[j] % mod * b[i] * 2 % mod) % n             mod; n     } n   printf( %d n , ans); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int n, m, t1, t2; n vector<int> q1, q2; n vector<vector<int> > Visted; n int des(int point1, int point2, int point3, int point4) { n   return abs(point1 - point3) + abs(point2 - point4); n } n int main() { n   cin >> n >> m >> t1; n   Visted.resize(n + 10, vector<int>(m + 10)); n   q1.resize(t1); n   for (int i = 0; i < t1; i++) cin >> q1[i]; n   cin >> t2; n   q2.resize(t2); n   for (int i = 0; i < t2; i++) cin >> q2[i]; n   sort(q1.begin(), q1.end()); n   sort(q2.begin(), q2.end()); n   for (int i = 0; i < t1; i++) { n     bool take = false; n     int desEnd = -1e9, X, Y; n     for (int j = 1; j <= n; j++) { n       for (int z = 1; z <= m; z++) { n         if (!Visted[j][z] && des(0, 0, j, z) <= q1[i] && n             des(0, m + 1, j, z) > desEnd) { n           desEnd = des(0, m + 1, j, z); n           take = true; n           X = j, Y = z; n         } n       } n     } n     if (take) { n       Visted[X][Y] = 1; n     } else { n       cout <<  NO ; n       return 0; n     } n   } n   for (int i = 0; i < t2; i++) { n     bool take = false; n     int desEnd = 1e9, X, Y; n     for (int j = 1; j <= n; j++) { n       for (int z = 1; z <= m; z++) { n         if (!Visted[j][z] && des(0, m + 1, j, z) <= q2[i] && n             des(0, m + 1, j, z) < desEnd) { n           take = true; n           X = j, Y = z; n         } n       } n     } n     if (take) { n       Visted[X][Y] = 1; n     } else { n       cout <<  NO ; n       return 0; n     } n   } n   cout <<  YES ; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n template <class TH> n void _dbg(const char *sdbg, TH h) { n   cerr << sdbg <<  =  << h << endl; n } n template <class TH, class... TA> n void _dbg(const char *sdbg, TH h, TA... a) { n   while (*sdbg !=  , ) cerr << *sdbg++; n   cerr <<  =  << h <<  , ; n   _dbg(sdbg + 1, a...); n } n template <class T> n ostream &operator<<(ostream &os, vector<T> V) { n   os <<  [ ; n   for (auto vv : V) os << vv <<  , ; n   return os <<  ] ; n } n template <class L, class R> n ostream &operator<<(ostream &os, pair<L, R> P) { n   return os <<  (  << P.first <<  ,  << P.second <<  ) ; n } n template <class T> n using min_heap = priority_queue<T, vector<T>, greater<T>>; n template <class T> n using max_heap = priority_queue<T>; n const int mod = 1e9 + 7; n long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; } n struct PairHash { n   template <typename T1, typename T2> n   std::size_t operator()(const pair<T1, T2> &p) const { n     return hash<T1>()(p.first) ^ hash<T2>()(p.second); n   } n }; n void solve(int ncase) { n   int a, b, c, d; n   cin >> a >> b >> c >> d; n   int minx = min({a, b, c}); n   a -= minx; n   b -= minx; n   c -= minx; n   cout << (((a % 2 + b % 2 + c % 2 + (d + 3 * 1LL * minx) % 2) <= 1) || n                    (minx >= 1 && ((a + 1) % 2 + (b + 1) % 2 + (c + 1) % 2 + n                                   (d + 3 * 1LL * minx - 3) % 2) <= 1) n                ?  Yes  n                :  No ) n        << endl; n } n void solve_all_cases() { n   int T = 1; n   cin >> T; n   int ncase = 0; n   while (T--) { n     solve(++ncase); n   } n } n int main() { n   cout << std::fixed; n   cout << setprecision(6); n   solve_all_cases(); n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int main() { n   int n; n   scanf( %d , &n); n   int a[n]; n   for (int i = 0; i < n; i++) cin >> a[i]; n   for (int i = 0; i < n - 1; i++) cout << (a[i] + a[i + 1]) <<    ; n   cout << a[n - 1]; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int j, i, a, b, c, k, d, e, f[1005], n, mi, ma; n int main() { n   cin >> n; n   for (i = 0; i < n; i++) { n     cin >> f[i]; n     ma = max(f[i], ma); n   } n   for (i = 0; i < n - 1; i++) n     for (j = i + 1; j < n; j++) { n       c = 0; n       for (k = i; k <= j; k++) c = f[k] ^ c; n       ma = max(ma, c); n     } n   cout << ma; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n #pragma GCC optimize( Ofast ) n #pragma GCC target(   n      avx,avx2,fma,sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native ) n using namespace std; n long long MOD = 1e9 + 7; n long long k; n vector<long long> v, w, num; n vector<pair<long long, pair<long long, long long> > > zp; n vector<vector<long long> > dp; n long long st(long long t, long long id, long long mod) { n   long long res = 1, a = t, n = id; n   while (n) { n     if (n & 1) res = (res * a) % mod; n     a = (a * a) % mod; n     n >>= 1; n   } n   return res % mod; n } n void add(long long id) { n   vector<long long> mem(k + 1); n   dp.push_back(mem); n   long long lst = dp.size() - 1; n   for (int i = 0; i < k + 1; i++) { n     dp[lst][i] = dp[lst - 1][i]; n     if (i >= w[id]) n       dp[lst][i] = max(dp[lst - 1][i], dp[lst - 1][i - w[id]] + v[id]); n   } n } n void del() { dp.pop_back(); } n long long ans() { n   long long lst = dp.size() - 1; n   long long anss = 0; n   for (int i = 1; i < k + 1; i++) { n     anss = ((10000019 * (long long)anss) + (long long)dp[lst][k - i + 1]) % MOD; n     if (anss > MOD) anss -= MOD; n   } n   return anss; n } n void get(long long l, long long r) { n   if (r == l + 1) { n     if (zp[l].first == 3) { n       zp[l].second.first = ans(); n     } n     return; n   } n   long long mid = (l + r) / 2; n   long long kol = 0; n   for (int i = mid; i < r; i++) { n     if (zp[i].first == 2) { n       if (num[zp[i].second.second] < l) { n         add(zp[i].second.second); n         kol++; n       } n     } n   } n   get(l, mid); n   while (kol--) del(); n   kol = 0; n   for (int i = l; i < mid; i++) { n     if (zp[i].first == 1) { n       if (zp[i].second.second >= r) { n         add(zp[i].second.first); n         kol++; n       } n     } n   } n   get(mid, r); n   while (kol--) del(); n } n int main() { n   ios::sync_with_stdio(0), cin.tie(0), cout.tie(0), n       cout << fixed << setprecision(20); n   long long n; n   cin >> n >> k; n   v.resize(n), w.resize(n), num.resize(n); n   vector<long long> mem(k + 1); n   dp.push_back(mem); n   for (int i = 0; i < n; i++) { n     cin >> v[i] >> w[i]; n     zp.push_back({1, {i, MOD}}); n     num[i] = i; n   } n   long long q; n   cin >> q; n   while (q--) { n     long long sz = zp.size(); n     zp.push_back({0, {num.size(), MOD}}); n     cin >> zp[zp.size() - 1].first; n     if (zp.back().first == 1) { n       long long vv, ww; n       cin >> vv >> ww; n       v.push_back(vv); n       w.push_back(ww); n       num.push_back(sz); n     } n     if (zp.back().first == 2) { n       long long x; n       cin >> x; n       x--; n       zp[num[x]].second.second = sz; n       zp[sz].second.second = x; n     } n   } n   get(0, zp.size()); n   for (auto i : zp) { n     if (i.first == 3) { n       cout << i.second.first << endl; n     } n   } n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n long long read() { n   long long w = 0; n   char c = getchar(); n   while (c <  0  || c >  9 ) c = getchar(); n   while (c >=  0  && c <=  9 ) w = w * 10 + c - 48, c = getchar(); n   return w; n } n long long n, s[100005], e[100005]; n bool f[100005][2]; n bool check(long long x, long long y, long long op) { n   if ((y & 1) && (!op)) return (y - x) & 1; n   long long h = y >> 1; n   if (x > h) return op ? 1 : (y - x) & 1; n   return check(x, h, op ^ 1); n } n signed main() { n   n = read(); n   for (long long i = 1; i <= n; i++) n     s[i] = read(), e[i] = read(), f[i][0] = check(s[i], e[i], 0), n     f[i][1] = check(s[i], e[i], 1); n   bool need = f[n][0]; n   for (long long i = n - 1; i > 0; i--) need = f[i][need]; n   printf(need ?  1   :  0  ); n   need = f[n][1]; n   for (long long i = n - 1; i > 0; i--) need = f[i][need]; n   printf(need ?  1  :  0 ); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int N = 16, Inf = 1e9, lastS = (1 << N) - 1; n static int n, sqrn, R, B, ans, lasts; n struct TCard { n   bool c; n   int r, b; n } card[N]; n static int f[lastS][N * N + 1][2], cardr[lastS], cardb[lastS]; n inline int GetF(int s, int rem, bool c) { n   rem = min(rem, sqrn); n   if (s == lasts) return 0; n   auto &fs = f[s][rem][c]; n   if (fs != -1) return fs; n   fs = Inf; n   for (int i = 0; i < n; ++i) { n     if (s & 1 << i) continue; n     int R = max(0, card[i].r - cardr[s]), B = max(0, card[i].b - cardb[s]), n         turn, _r, _b; n     if (c) { n       turn = max(R - rem, B); n       _r = rem + turn - R; n       _b = turn - B; n     } else { n       turn = max(B - rem, R); n       _b = rem + turn - B; n       _r = turn - R; n     } n     if (_r) n       fs = min(fs, turn + GetF(s ^ 1 << i, _r, 1)); n     else n       fs = min(fs, turn + GetF(s ^ 1 << i, _b, 0)); n   } n   return fs; n } n int main() { n   ios_base::sync_with_stdio(0); n   cin.tie(0); n   cin >> n; n   sqrn = n * n; n   lasts = (1 << n) - 1; n   for_each(card, card + n, [](TCard &C) { n     char tmp; n     cin >> tmp >> C.r >> C.b; n     C.c = tmp ==  R ; n     if (C.r > n) R += C.r - n, C.r = n; n     if (C.b > n) B += C.b - n, C.b = n; n   }); n   for (int s = 1; s <= lasts; ++s) { n     int i = __builtin_ctz(s); n     cardr[s] = cardr[s ^ 1 << i] + card[i].c; n     cardb[s] = cardb[s ^ 1 << i] + !card[i].c; n   } n   memset(f, -1, sizeof f); n   if (R > B) n     ans = R + GetF(0, R - B, 0); n   else n     ans = B + GetF(0, B - R, 1); n   cout << ans + n; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n ifstream file( input.txt ); n using namespace std; n void maker(int x); n int main() { n   int y; n   cin >> y; n   maker(y + 1); n } n void maker(int x) { n   int a, b, c, d; n   a = (x / 1000) % 10; n   b = (x / 100) % 10; n   c = (x / 10) % 10; n   d = (x / 1) % 10; n   while (a == b || a == c || a == d || b == c || b == d || c == d) { n     x++; n     a = (x / 1000) % 10; n     b = (x / 100) % 10; n     c = (x / 10) % 10; n     d = (x / 1) % 10; n   } n   cout << (a * 1000 + b * 100 + c * 10 + d); n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n template <typename... Args> n void logger(string vars, Args&&... values) {} n template <typename T> n inline void maxa(T& a, T b) { n   a = max(a, b); n } n template <typename T> n inline void mina(T& a, T b) { n   a = min(a, b); n } n mt19937 rng(chrono::steady_clock::now().time_since_epoch().count()); n const int mxN = 2e5 + 5; n const int mod = 1e9 + 7; n int main() { n   cin.sync_with_stdio(0); n   cin.tie(0); n   cout.tie(0); n   int n; n   cin >> n; n   vector<int> a(n); n   vector<char> ans(n); n   for (int& i : a) cin >> i; n   string s; n   cin >> s; n   sort(a.begin(), a.end()); n   int cnt = 0; n   for (int i = 1; i < n; i++) cnt += (s[i] != s[i - 1]); n   int l = n - cnt - 1; n   int r = n - cnt - 1; n   cout << a[l] <<     << s[0] <<   n ; n   ans[l] = s[0]; n   for (int i = 1; i < (int)(s.size()); i++) { n     if (s[i] != s[i - 1]) { n       ans[++r] = ans[r] ==  L  ?  R  :  L ; n       cout << a[r] <<     << ans[r] <<   n ; n     } else { n       ans[--l] = ans[l] ==  L  ?  R  :  L ; n       cout << a[l] <<     << ans[l] <<   n ; n     } n   } n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int maxn = 2000 + 100; n map<pair<long long, long long>, int> rat; n int n; n pair<long long, long long> px[maxn], py[maxn]; n long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); } n int main() { n   cin >> n; n   for (int i = 1, a, b, c; i <= n; i++) { n     cin >> a >> b >> c; n     px[i] = make_pair(c * b, a * a + b * b); n     py[i] = make_pair(a * c, a * a + b * b); n   } n   long long ans = 0; n   for (int i = 1; i <= n; i++) { n     rat.clear(); n     long long two0 = 0; n     for (int j = i + 1; j <= n; j++) { n       long long a = px[j].first * px[i].second - px[j].second * px[i].first; n       long long b = py[j].first * py[i].second - py[j].second * py[i].first; n       long long g = gcd(abs(a), abs(b)); n       if (g != 0) a /= g, b /= g; n       if (a == 0 && b == 0) { n         two0++; n         ans += j - i - 1; n       } else { n         if (a == 0) b = 1; n         if (b == 0) a = 1; n         if (a < 0 && b < 0) a *= -1, b *= -1; n         if (a > 0 && b < 0) a *= -1, b *= -1; n         ans += two0; n         if (rat.count(make_pair(a, b))) { n           ans += rat[make_pair(a, b)]; n           rat[make_pair(a, b)]++; n         } else n           rat[make_pair(a, b)] = 1; n       } n     } n   } n   cout << ans << endl; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int MAXN = 25; n int dp[MAXN][MAXN][MAXN]; n int n, t; n int main() { n   scanf( %d%d , &n, &t); n   t = 2 * t; n   dp[1][0][1] = dp[1][0][2] = dp[1][0][3] = 1; n   for (int i = 1; i < n; ++i) n     for (int j = 0; j <= t; ++j) n       for (int k = 1; k <= 4; ++k) n         for (int l = 1; l <= 4; ++l) { n           if ((i == 1 && l > k) || (i != 1 && l != k)) { n             int nj = j; n             if (j % 2 && l < k) n               ++nj; n             else if (j % 2 == 0 && l > k) n               ++nj; n             dp[i + 1][nj][l] += dp[i][j][k]; n           } n         } n   int ans = 0; n   for (int i = 1; i <= 4; ++i) ans += dp[n][t][i]; n   printf( %d n , ans); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int main() { n   ios_base::sync_with_stdio(false); n   cin.tie(NULL); n   int t; n   cin >> t; n   multiset<long long int> s; n   map<string, int> mp; n   while (t--) { n     char ch; n     long long int x; n     cin >> ch >> x; n     string str(18,  0 ); n     string temp = to_string(x); n     int j = 17; n     for (int i = ((int)(temp).size()) - 1; i >= 0; i--) { n       if ((temp[i] -  0 ) % 2 != 0) { n         str[j] =  1 ; n       } n       j--; n     } n     if (ch ==  + ) { n       mp[str]++; n     } else if (ch ==  - ) { n       mp[str]--; n     } else { n       cout << mp[str] <<   n ; n     } n   } n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n #pragma warning(disable : 4996) n #pragma comment(linker,  /STACK:666000000 ) n using namespace std; n const int INF = (1 << 30) - 1; n const long double EPS = 1e-9; n const long double PI = fabs(atan2(0.0, -1.0)); n int n; n void load() { cin >> n; } n const int SZ = 1010; n int sv[SZ]; n int rec(const int v) { n   if (v < SZ && -1 != sv[v]) return sv[v]; n   bool can[10]; n   int p9; n   memset(can, false, sizeof(can)); n   { n     int p = 0; n     int tmp = v; n     while (tmp != 0) { n       can[tmp % 10] = true; n       if (9 == tmp % 10) p9 = p; n       tmp /= 10; n       p *= 10; n     } n   } n   if (v >= SZ) { n     if (can[9] && p9 > 10) { n       int cnt = 9 * (p9 / 10) - 8; n       return cnt + rec(v - cnt * 9); n     } n     for (int i = 9; i >= 1; i--) n       if (can[i]) return 1 + rec(v - i); n   } n   int res = INT_MAX; n   for (int i = 1; i <= 9; i++) n     if (can[i]) res = min(res, 1 + rec(v - i)); n   if (v < SZ) sv[v] = res; n   return res; n } n void solve() { n   memset(sv, -1, sizeof(sv)); n   sv[0] = 0; n   int res = rec(n); n   cout << res; n } n int main() { n   load(); n   solve(); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int N = 1e5; n map<int, int> dic; n int n, a[N + 10], ma[N + 10], ma2[N + 10]; n int main() { n   ios::sync_with_stdio(0), cin.tie(0); n   cin >> n; n   for (int i = 1; i <= n; i++) cin >> a[i]; n   ma[1] = a[1]; n   ma2[1] = -1; n   for (int i = 2; i <= n; i++) { n     if (a[i] > ma[i - 1]) { n       ma2[i] = ma[i - 1]; n       ma[i] = a[i]; n     } else { n       ma[i] = ma[i - 1]; n       if (ma2[i - 1] < a[i]) { n         ma2[i] = a[i]; n       } else n         ma2[i] = ma2[i - 1]; n     } n     if (a[i] != ma[i] && a[i] == ma2[i]) { n       dic[ma[i]]++; n     } n   } n   int tot = -1e6, idx = -1; n   for (int i = 1; i <= n; i++) { n     int temp = dic[a[i]]; n     if (a[i] == ma[i]) temp--; n     if (temp > tot) { n       tot = temp; n       idx = a[i]; n     } else if (temp == tot) { n       idx = min(idx, a[i]); n     } n   } n   cout << idx << endl; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n long long a[1000005] = {0}; n long long b[1000005] = {0}; n long long c[1000005] = {0}; n long long d[1000005] = {0}; n long long s; n long long i, j = 0, l; n long long count1 = 0; n long long count2 = 0; n long long count3 = 0; n long long count4 = 0; n long long ans = 0; n bool cmp(long long aa, long long bb) { return aa > bb; } n int main() { n   long long n; n   scanf( %lld n , &n); n   for (i = 0; i < n; i++) { n     cin >> s >> j; n     if (s == 11) { n       a[count1++] = j; n       ans += j; n     } else if (s == 10) { n       b[count2++] = j; n     } else if (s == 1) { n       c[count3++] = j; n     } else { n       d[count4++] = j; n     } n   } n   sort(b, b + count2, cmp); n   sort(c, c + count3, cmp); n   for (i = 0; i < min(count2, count3); i++) ans += (b[i] + c[i]); n   for (i = 0; i < abs(count2 - count3); i++) { n     if (count3 > count2) n       d[count4 + i] = c[min(count2, count3) + i]; n     else if (count3 < count2) n       d[count4 + i] = b[min(count2, count3) + i]; n   } n   count4 += abs(count2 - count3); n   sort(d, d + count4, cmp); n   for (i = 0; i < count1 && i < count4; i++) ans += d[i]; n   cout << ans << endl; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int a[35], b[35], diff[35]; n int main() { n   std::ios::sync_with_stdio(false); n   int t; n   t = 1; n   while (t--) { n     long long x, x1, val, val1, i, j, res = 0; n     cout <<  ? 0 0  << endl; n     cin >> x; n     x1 = x; n     if (x == 0) { n       for (i = 0; i < 30; i++) { n         val = (1 << i); n         cout <<  ?   << val <<     << 0 << endl; n         cin >> x; n         if (x == -1) { n           res += (1 << i); n         } n       } n       cout <<  !   << res <<     << res << endl; n     } else { n       { n         x1 = x; n         i = 29; n         val = 0; n         val1 = 0; n         for (i = 29; i >= 0; i--) { n           val += (1 << i); n           val1 += (1 << i); n           cout <<  ?   << val <<     << val1 << endl; n           cin >> x; n           if (x != x1) { n             diff[i] = 1; n             val -= (1 << i); n             if (x == -1) { n               a[i] = 1; n               b[i] = 0; n             } else { n               a[i] = 0; n               b[i] = 1; n             } n             cout <<  ?   << val <<     << val1 << endl; n             cin >> x; n             x1 = x; n           } else { n             diff[i] = 0; n           } n         } n         for (i = 29; i >= 0; i--) { n           val = 0; n           val1 = 0; n           if (diff[i]) { n             continue; n           } n           for (j = 0; j < 30; j++) { n             if (j == i) { n               continue; n             } n             if (diff[j]) { n               val += (1 << j); n             } n           } n           { n             val += (1 << i); n             cout <<  ?   << val <<     << val1 << endl; n             cin >> x; n             if (x == -1) { n               a[i] = 1; n               b[i] = 1; n             } else { n               a[i] = 0; n               b[i] = 0; n             } n           } n         } n         val = 0; n         val1 = 0; n         for (i = 0; i < 30; i++) { n           if (a[i]) { n             val += (1 << i); n           } n           if (b[i]) { n             val1 += (1 << i); n           } n         } n         cout <<  !   << val <<     << val1 << endl; n       } n     } n   } n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const long long int mod = 1e9 + 7; n int32_t main() { n   ios_base::sync_with_stdio(false); n   cin.tie(0); n   cout.tie(0); n   long long int n, k; n   cin >> n >> k; n   long long int ans = 1; n   while (k % 2 == 0) { n     k = k / 2; n     ans++; n   } n   cout << ans << endl; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int N = 2e4 + 10, mod = 1e9 + 7, M = 510; n const double PI = 3.1415926535; n long long res[40], p[40], ei[40], sum[N], cnt; n double pre[N]; n int path[100]; n void dfs(int u, int s, long long va) { n   if (u == -1) { n     sum[s] = ((long long)sum[s] + va) % mod; n     return; n   } n   for (int i = 0; i <= cnt; i++) { n     path[i]++; n     if (res[i] - path[i] + 1) n       dfs(u - 1, s + i, (long long)va * (res[i] - path[i] + 1) % mod); n     path[i]--; n   } n } n int main() { n   int n; n   scanf( %d , &n); n   vector<int> temp; n   int t = n; n   while (t) t /= 10, cnt++; n   p[1] = 1; n   for (int i = 2; i <= 11; i++) p[i] = p[i - 1] * 10; n   ei[0] = 1; n   for (int i = 1; i < 11; i++) ei[i] = ei[i - 1] * 8; n   for (int i = 0; i < (1 << cnt); i++) { n     vector<int> temp; n     for (int j = 0; j < cnt; j++) n       if (i >> j & 1) temp.push_back(j); n     int len = temp.size(); n     for (int j = 0; j < 1 << len; j++) { n       int a[15] = {0}; n       for (int k = 0; k < len; k++) n         if (j >> k & 1) n           a[temp[k]] = 7; n         else n           a[temp[k]] = 4; n       long long f = p[cnt], va = 0; n       for (long long k = cnt - 1, r = 1; k >= 0; k--, r *= 10) n         va += (long long)a[k] * r; n       if (va > n) continue; n       for (int k = 0; k < cnt; k++) { n         if (a[k]) { n           f /= 10; n           continue; n         } n         for (int r = 9; r >= 0; r--) n           if ((long long)r * f + va <= n) { n             a[k] = r, va = r * f + va; n             break; n           } n         f /= 10; n       } n       long long num = 0, ans = 0; n       for (int k = 0; k < cnt; k++) { n         if (num < temp.size() && temp[num] == k) { n           num++; n           if (k == cnt - 1) ans++; n           continue; n         } n         if (a[k] == 7 || a[k] == 4) { n           int sum = cnt - 1 - k; n           int ts = temp.size() - num; n           int tnum = a[k] + 1; n           if (a[k] == 4) n             tnum--; n           else n             tnum -= 2; n           ans = ans + ei[sum - ts] * (long long)tnum; n           break; n         } else { n           int sum = cnt - 1 - k; n           int ts = temp.size() - num; n           int tnum = a[k] + 1; n           if (a[k] > 7) n             tnum -= 3; n           else if (a[k] > 4) n             tnum -= 2; n           else n             tnum--; n           if (k == cnt - 1) tnum++; n           ans = ans + ei[sum - ts] * (long long)tnum; n         } n       } n       res[len] = (res[len] + (long long)ans); n     } n   } n   res[0]--; n   dfs(5, 0, 1); n   long long ans = 0, pre = 0; n   for (int i = 1; i <= cnt; i++) { n     pre = pre + sum[i - 1]; n     ans = (ans + pre * res[i]) % mod; n   } n   cout << ans << endl; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int N, good; n bool prime[100010]; n vector<int> fact, num, lis; n int main() { n   memset(prime, true, sizeof(prime)); n   for (int i = 2; i * i <= 100000; i++) n     if (prime[i]) n       for (int j = 2; i * j <= 100000; j++) prime[i * j] = false; n   for (int i = 2; i <= 100000; i++) n     if (prime[i]) { n       num.push_back(i); n       lis.push_back(0); n     } n   scanf( %d , &N); n   while (N--) { n     scanf( %d , &good); n     int temp = good; n     fact.clear(); n     int longest = 0; n     for (int i = 0; i < num.size() && num[i] * num[i] <= good; i++) n       if (good % num[i] == 0) { n         fact.push_back(i); n         longest = max(longest, lis[i] + 1); n         while (temp % num[i] == 0) temp /= num[i]; n       } n     if (temp > 1) { n       int i = lower_bound(num.begin(), num.end(), temp) - num.begin(); n       fact.push_back(i); n       longest = max(longest, lis[i] + 1); n     } n     for (int i = 0; i < fact.size(); i++) n       lis[fact[i]] = max(lis[fact[i]], longest); n   } n   int ans = 1; n   for (int i = 0; i < num.size(); i++) ans = max(ans, lis[i]); n   printf( %d n , ans); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int N = 2300; n int dp[N], a[N], res = 0, n; n void dfs(int u, int d) { n   if (d == n) { n     dp[u] = 0; n     return; n   } n   int l = u * 2, r = l + 1; n   dfs(l, d + 1); n   dfs(r, d + 1); n   int x = dp[l] + a[l], y = dp[r] + a[r]; n   if (x < y) swap(x, y); n   dp[u] = x; n   res += x - y; n } n int main() { n   cin >> n; n   for (int i = 2; i < (1 << n + 1); i++) { n     scanf( %d , &a[i]); n   } n   dfs(1, 0); n   cout << res << endl; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n long long n, root, val, rem; n int main() { n   cin >> n; n   root = floor((sqrt(1.0 + 8.0 * n) - 1.0) / 2.0); n   val = root * (root + 1) / 2; n   if (n == val) --root; n   val = root * (root + 1) / 2; n   rem = n - val; n   cout << rem << endl; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const long long N = 1e5 + 2; n const long long M = 1e6 + 2; n const long long mod = 998244353; n long long ar[N], fact[M], inv[M], cnt[N]; n long long binpow(long long x, long long y) { n   long long tich = 1; n   while (y) { n     if (y & 1) { n       tich *= x; n       tich %= mod; n     } n     x *= x; n     x %= mod; n     y >>= 1; n   } n   return tich; n } n long long C(long long x, long long y) { n   return ((fact[y] * inv[y - x]) % mod * inv[x]) % mod; n } n signed main() { n   ios::sync_with_stdio(0); n   cin.tie(0); n   long long n, i, j, k, l, ans = 0, sum = 0; n   cin >> n; n   for (i = 1; i <= n; i++) { n     cin >> ar[i]; n     cnt[ar[i] % n]++; n     sum += ar[i]; n   } n   fact[0] = 1; n   for (i = 1; i < M - 1; i++) { n     fact[i] = (fact[i - 1] * i) % mod; n   } n   inv[M - 2] = binpow(fact[M - 2], mod - 2); n   for (i = M - 2; i > 0; i--) { n     inv[i - 1] = (inv[i] * i) % mod; n   } n   sort(ar + 1, ar + 1 + n); n   long long pos = 0; n   for (i = 1; i < n; i++) { n     if (ar[i + 1] < i) { n       pos = i; n       break; n     } n   } n   if (pos) { n     j = 1; n     for (i = 0; i < pos; i++) { n       while (ar[j] < i) { n         j++; n       } n       ans += C(n - 1, i - (j - 1) + n - 1); n       if (ans >= mod) { n         ans -= mod; n       } n     } n     cout << ans; n   } else { n     for (i = 1; i <= n; i++) { n       sum -= ar[i] % n; n     } n     sum /= n; n     for (i = 1; i <= n; i++) { n       sum = sum + cnt[n - i] - 1; n       if (sum >= 0) { n         ans += C(n - 1, sum + n - 1); n         if (ans >= mod) { n           ans -= mod; n         } n       } n     } n     cout << ans; n   } n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int main() { n   int n, m; n   cin >> n >> m; n   vector<pair<int, int>> v; n   for (int i = 0; i < m; i++) { n     int a, b; n     cin >> a >> b; n     v.push_back(make_pair(a, b)); n   } n   int x1 = v[0].first; n   int y1 = v[0].second; n   vector<int> p1, p2; n   for (int i = 1; i < m; i++) { n     int a = v[i].first; n     int b = v[i].second; n     if (x1 != a && x1 != b) { n       p1.push_back(i); n     } n     if (y1 != a && y1 != b) { n       p2.push_back(i); n     } n   } n   if (p1.size() == 0 || p2.size() == 0) { n     cout <<  YES  << endl; n     return 0; n   } n   x1 = v[p1[0]].first; n   y1 = v[p1[0]].second; n   int c1 = 0, c2 = 0, c3 = 0, c4 = 0; n   for (int i = 1; i < p1.size(); i++) { n     int a = v[p1[i]].first; n     int b = v[p1[i]].second; n     if (x1 != a && x1 != b) { n       c1++; n     } n     if (y1 != a && y1 != b) { n       c2++; n     } n   } n   x1 = v[p2[0]].first; n   y1 = v[p2[0]].second; n   for (int i = 1; i < p2.size(); i++) { n     int a = v[p2[i]].first; n     int b = v[p2[i]].second; n     if (x1 != a && x1 != b) { n       c3++; n     } n     if (y1 != a && y1 != b) { n       c4++; n     } n   } n   if (c1 == 0 || c2 == 0) { n     cout <<  YES  << endl; n   } else if (c3 == 0 || c4 == 0) { n     cout <<  YES  << endl; n   } else { n     cout <<  NO  << endl; n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n template <class T> n inline bool chmax(T &a, T b) { n   return a < b ? (a = b, 1) : 0; n } n template <class T> n inline bool chmin(T &a, T b) { n   return a > b ? (a = b, 1) : 0; n } n int main() { n   int n, m; n   cin >> n >> m; n   map<int, vector<int>> obs; n   int left = n; n   while (m--) { n     int x, y; n     cin >> x >> y; n     if (x == 1) n       chmin(left, y - 1); n     else n       obs[x].emplace_back(y); n   } n   vector<pair<int, int>> segs = {{1, left}}; n   int prv = 1; n   for (auto &p : obs) { n     auto &v = p.second; n     sort(begin(v), end(v)); n     if (p.first != prv + 1) { n       segs.assign(1, {segs.begin()->first, n}); n     } n     vector<pair<int, int>> segs2; n     auto it = segs.begin(); n     int p_v = 0, sz_v = v.size(); n     int lst = -1; n     while (it != segs.end() && p_v < sz_v) { n       chmax(it->first, lst); n       if (it->first > it->second) { n         it++; n         continue; n       } n       if (v[p_v] <= it->first) { n         it->first += v[p_v++] == it->first; n         continue; n       } n       segs2.emplace_back(it->first, v[p_v] - 1); n       lst = v[p_v++] + 1; n     } n     if (p_v == sz_v) { n       while (it != segs.end()) { n         chmax(it->first, lst); n         if (it->first <= it->second) break; n         it++; n       } n       if (it != segs.end()) { n         segs2.emplace_back(it->first, n); n       } n     } n     if ((segs = segs2).empty()) return !(cout << -1 << endl); n     prv = p.first; n   } n   if (prv < n) { n     segs.assign(1, {segs.begin()->first, n}); n   } n   cout << (segs.rbegin()->second == n ? (n - 1) * 2 : -1) << endl; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int main() { n   ios_base::sync_with_stdio(false); n   cin.tie(0); n   int t; n   cin >> t; n   while (t--) { n     long long n, k; n     cin >> n >> k; n     if (n > k) n       cout << k << endl; n     else { n       int ne = (k - 1) / (n - 1); n       cout << k + ne << endl; n     } n   } n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n int mat[110][110]; n int main() { n   int n, k, i, j; n   scanf( %d %d , &n, &k); n   if (n * n < k) { n     printf( -1 n ); n     return 0; n   } n   for (i = 0; i < n; i++) { n     for (j = i; j < n; j++) { n       if (i == j) { n         if (k > 0) { n           k--; n           mat[i][j] = 1; n         } else n           break; n       } else { n         if (k >= 2) { n           mat[i][j] = 1; n           mat[j][i] = 1; n           k = k - 2; n         } else if (k == 0) n           break; n       } n     } n   } n   for (i = 0; i < n; i++) { n     for (j = 0; j < n; j++) { n       printf( %d  , mat[i][j]); n     } n     printf(  n ); n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n int n, k; n bool visited[101][101][1010]; n double ar[101], dp[101][101][1010]; n double F(int i, int j, int k) { n   if (i > j) return 1.0 - F(j, i, k); n   if (k == 0) return 1.0; n   if (visited[i][j][k]) return dp[i][j][k]; n   int a, b, c, d, l; n   double x, y, p = 1.0 / ((n * (n + 1)) >> 1), res = 0.0; n   for (a = 0; a < n; a++) { n     for (b = a; b < n; b++) { n       c = i, d = j; n       if (c >= a && c <= b) c = b - (c - a); n       if (d >= a && d <= b) d = b - (d - a); n       res += (p * F(c, d, k - 1)); n     } n   } n   visited[i][j][k] = true; n   return (dp[i][j][k] = res); n } n int main() { n   int i, j, l; n   while (scanf( %d %d , &n, &k) != EOF) { n     if (k > 1000) k = 1000; n     for (i = 0; i < n; i++) scanf( %d , &ar[i]); n     memset(visited, 0, sizeof(visited)); n     double res = 0.0; n     for (i = 0; i < n; i++) { n       for (j = i + 1; j < n; j++) { n         if (ar[i] < ar[j]) n           res += (1.0 - F(i, j, k)); n         else n           res += F(i, j, k); n       } n     } n     printf( %0.12f n , res + 1e-15); n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n template <class T> n T gcd(T a, T b) { n   return b ? gcd(b, a % b) : a; n } n mt19937 rng(chrono::steady_clock::now().time_since_epoch().count()); n const double EPS = 1e-9; n const double PI = acos(-1.); n const long long LL_INF = 1e17 + 16; n const int INF = 1e9 + 10; n const long long MOD = 1e9 + 7; n const int MAXN = 20; n set<long long> goods; n long long f[MAXN]; n void gen() { n   for (int i = (1); i <= (int)(10); i++) { n     for (int j = (0); j < (int)(1 << i); j++) { n       long long v = 0; n       long long st10 = 1; n       for (int k = (0); k < (int)(i); k++) { n         if (j & (1 << k)) { n           v += 7 * st10; n         } else { n           v += 4 * st10; n         } n         st10 *= 10; n       } n       goods.insert(v); n     } n   } n } n int per[MAXN]; n int used[MAXN]; n void solve() { n   gen(); n   long long n, k; n   cin >> n >> k; n   f[0] = 1; n   int m; n   for (m = 1;; m++) { n     f[m] = f[m - 1] * m; n     if (f[m] >= k) { n       break; n     } n   } n   if (m > n) { n     printf( -1 n ); n     return; n   } n   int ans = 0; n   int offset = n - m; n   for (__typeof((goods).begin()) it = (goods).begin(); it != (goods).end(); n        it++) { n     if ((*it) <= offset) { n       ans++; n     } n   } n   k--; n   int top = 1; n   for (int i = m; i >= 1; i--) { n     int v = k / f[i - 1] + 1; n     int cnt = 0; n     for (int j = (1); j <= (int)(m); j++) { n       if (!used[j]) { n         cnt++; n         if (cnt == v) { n           per[top++] = j; n           used[j] = 1; n           break; n         } n       } n     } n     k %= f[i - 1]; n   } n   for (int i = (1); i <= (int)(m); i++) { n     if (goods.count(i + offset) && goods.count(per[i] + offset)) { n       ans++; n     } n   } n   cout << ans << endl; n } n int main() { n   int t = 1; n   while (t--) { n     solve(); n   } n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n void dfs(set<int> &temp, list<int> adj[], vector<bool> &v, int s, int &t1, n          int &t2, vector<int> b, vector<int> w) { n   v[s] = true; n   list<int>::iterator it; n   for (it = adj[s].begin(); it != adj[s].end(); it++) { n     if (!v[*it]) { n       temp.insert(*it); n       t1 += b[*it]; n       t2 += w[*it]; n       dfs(temp, adj, v, *it, t1, t2, b, w); n     } n   } n } n list<int> adj[1001]; n int main() { n   int n, m, weight; n   cin >> n >> m >> weight; n   vector<int> b(n + 1); n   vector<int> w(n + 1); n   for (int i = 1; i <= n; i++) cin >> w[i]; n   for (int i = 1; i <= n; i++) cin >> b[i]; n   for (int i = 0; i < m; i++) { n     int a, b; n     cin >> a >> b; n     adj[a].push_back(b); n     adj[b].push_back(a); n   } n   vector<bool> v(n + 1, false); n   vector<set<int> > arr; n   vector<int> tw; n   vector<int> tb; n   for (int i = 1; i <= n; i++) { n     if (!v[i]) { n       set<int> temp; n       temp.insert(i); n       int t1 = b[i], t2 = w[i]; n       dfs(temp, adj, v, i, t1, t2, b, w); n       arr.push_back(temp); n       tb.push_back(t1); n       tw.push_back(t2); n     } n   } n   vector<vector<int> > dp(arr.size() + 1, vector<int>(weight + 1, 0)); n   for (int i = 1; i <= arr.size(); i++) { n     for (int j = 1; j <= weight; j++) { n       int max = 0; n       if (dp[i - 1][j] > max) max = dp[i - 1][j]; n       if (j - tw[i - 1] >= 0) n         if (dp[i - 1][j - tw[i - 1]] + tb[i - 1] > max) n           max = dp[i - 1][j - tw[i - 1]] + tb[i - 1]; n       set<int>::iterator it; n       for (it = arr[i - 1].begin(); it != arr[i - 1].end(); it++) { n         if (j - w[*it] >= 0) n           if (dp[i - 1][j - w[*it]] + b[*it] > max) n             max = dp[i - 1][j - w[*it]] + b[*it]; n       } n       dp[i][j] = max; n     } n   } n   int max = 0; n   for (int i = 0; i <= weight; i++) n     if (dp[arr.size()][i] > max) max = dp[arr.size()][i]; n   cout << max; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n long long n, m, ans, x, i, j, s; n double a[100], b[100]; n map<double, pair<long long, long long> > mp; n map<double, pair<long long, long long> >::iterator it, it2; n long long num(long long x) { n   s = 0; n   while (x) { n     s++; n     x -= x & -x; n   } n   return s; n } n int main() { n   cin >> n >> m; n   for (i = 0; i < n; i++) cin >> a[i]; n   for (i = 0; i < m; i++) cin >> b[i]; n   for (i = 0; i < n; i++) n     for (j = 0; j < m; j++) { n       mp[(a[i] + b[j]) / 2.0].first |= (1LL << i); n       mp[(a[i] + b[j]) / 2.0].second |= (1LL << j); n     } n   for (it = mp.begin(); it != mp.end(); it++) n     for (it2 = it; it2 != mp.end(); it2++) { n       x = num((*it).second.first | (*it2).second.first) + n           num((*it).second.second | (*it2).second.second); n       if (x > ans) ans = x; n     } n   cout << ans; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n int main() { n   long long n, k; n   scanf( %I64d , &n); n   while (n % 3 == 0) n /= 3; n   printf( %I64d , 1 + n / 3); n   getchar(); n   getchar(); n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n constexpr long long INF = numeric_limits<long long>::max() / 4; n constexpr long long n_max = 2e5 + 10; n template <typename A, typename B> n string to_string(pair<A, B> p); n string to_string(const string &s) { return     + s +    ; } n string to_string(const char c) { return to_string((string)&c); } n string to_string(bool b) { return (b ?  true  :  false ); } n template <size_t N> n string to_string(bitset<N> v) { n   string res =   ; n   for (size_t i = 0; i < N; i++) res += static_cast<char>( 0  + v[i]); n   return res; n } n template <typename A> n string to_string(A v) { n   bool first = true; n   string res =  { ; n   for (const auto &x : v) { n     if (!first) res +=  ,  ; n     first = false; n     res += to_string(x); n   } n   res +=  } ; n   return res; n } n template <typename A, typename B> n string to_string(pair<A, B> p) { n   return  (  + to_string(p.first) +  ,   + to_string(p.second) +  ) ; n } n void debug_out() { cerr << endl; } n template <typename Head, typename... Tail> n void debug_out(Head H, Tail... T) { n   cerr <<     << to_string(H); n   debug_out(T...); n } n template <class T> n bool chmax(T &a, T b) { n   if (a < b) { n     a = b; n     return true; n   } n   return false; n } n template <class T> n bool chmin(T &a, T b) { n   if (a > b) { n     a = b; n     return true; n   } n   return false; n } n signed main() { n   cin.tie(nullptr); n   ios::sync_with_stdio(false); n   long long t; n   cin >> t; n   for (long long _ = 0; _ < (long long)(t); _++) { n     long long n; n     cin >> n; n     vector<long long> a(n); n     for (long long i = 0; i < (long long)(n); i++) cin >> a[i]; n     vector<long long> dp(n + 1); n     for (long long i = 1; i < (long long)(n) + 1; i++) { n       dp[i]++; n       for (long long j = i * 2; j <= n; j += i) { n         if (a[j - 1] > a[i - 1]) chmax(dp[j], dp[i]); n       } n     } n     long long ans = 0; n     for (long long i = 0; i < (long long)(n + 1); i++) chmax(ans, dp[i]); n     cout << ans <<   n ; n   } n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int main() { n   ios_base::sync_with_stdio(false); n   cin.tie(0); n   cout.tie(0); n   int test = 1; n   cin >> test; n   while (test--) { n     long long int n, m; n     cin >> n >> m; n     long long int sum1 = 0, sum2 = 0; n     long long int a[n], b[n], mina[n], mi = 0; n     for (int i = 0; i < n; i++) { n       cin >> a[i] >> b[i]; n       sum1 += a[i]; n       sum2 += b[i]; n       mina[i] = max(0LL, m - b[i]); n       mi += mina[i]; n       a[i] = min(a[i], m); n     } n     long long int ans = sum1 - sum2 + (n * m); n     long long int x = ans - 2LL * mi; n     for (int i = 0; i < n; i++) { n       if (x <= 0) break; n       long long int temp = min(2LL * (a[i] - mina[i]), x); n       temp /= 2; n       mina[i] += temp; n       x -= 2LL * temp; n     } n     cout << abs(x) <<   n ; n     for (int i = 0; i < n; i++) cout << mina[i] <<     << m - mina[i] <<   n ; n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n #pragma warning(disable : 4996) n using namespace std; n bool compare(int a, int b) { return a > b; } n int main() { n   int t, p, f, cnts, cntw, s, w; n   scanf( %d , &t); n   while (t--) { n     scanf( %d%d , &p, &f); n     scanf( %d%d , &cnts, &cntw); n     scanf( %d%d , &s, &w); n     if (s > w) { n       int temp = s; n       s = w; n       w = temp; n       temp = cnts; n       cnts = cntw; n       cntw = temp; n     } n     int mx = min(cnts, p / s); n     int ans = 0; n     for (int s1 = 0; s1 <= mx; s1++) { n       int w1 = min(cntw, (p - s1 * s) / w); n       int s2 = min(cnts - s1, f / s); n       int w2 = min(cntw - w1, (f - s2 * s) / w); n       ans = max(ans, s1 + s2 + w1 + w2); n     } n     printf( %d n , ans); n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int maxn = 1e3 + 10; n long long n, k; n int main() { n   scanf( %I64d%I64d , &n, &k); n   long long x; n   x = sqrt(9 + 8 * (n + k)) - 3; n   x /= 2; n   printf( %I64d n , n - x); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const long long MOD = 998244353; n const int N = 3e3; n long long dmod(long long x) { return x % MOD; } n int n, k; n int h[N + 5]; n long long memo[N + 5][2 * N + 5]; n long long dp(int idx, int gap) { n   if (idx > n) { n     if (gap > 0) return 1; n     return 0; n   } n   long long &ret = memo[idx][gap + N]; n   if (ret != -1) return ret; n   ret = 0ll; n   if (h[idx] == h[idx % n + 1]) { n     ret = dmod((long long)k * dp(idx + 1, gap)); n   } else { n     ret = dp(idx + 1, gap + 1); n     ret = dmod(ret + dp(idx + 1, gap - 1)); n     ret = dmod(ret + dmod((long long)(k - 2) * dp(idx + 1, gap))); n   } n   return ret; n } n int main() { n   memset(memo, -1, sizeof(memo)); n   scanf( %d%d , &n, &k); n   for (int i = 1; i <= n; i++) { n     scanf( %d , &h[i]); n   } n   printf( %lld n , dp(1, 0)); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int main() { n   int n, x, m = 0, sum = 0; n   cin >> n >> x; n   int *arr = new int[n]; n   for (long long i = 0; i < n; i++) cin >> arr[i], sum += arr[i]; n   if (sum > 0) n     while (sum > 0) { n       sum -= x; n       m++; n     } n   else n     while (sum < 0) { n       sum += x; n       m++; n     } n   cout << m; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int brute(int s, int x) { n   int ans = 0; n   for (int i = 1; i <= s; ++i) n     for (int j = 1; j <= s; ++j) n       if (i + j == s && (i ^ j) == x) ++ans; n   return ans; n } n long long ways0(long long s, long long x) { n   if (s == x) return 2; n   return 0; n } n long long solve(long long s, long long x) { n   long long dp[60][2] = {}; n   if (s % 2 != x % 2) { n     return 0; n   } n   if (x & (1LL << 0)) { n     dp[0][0] = 2; n   } else { n     dp[0][0] = 1; n     dp[0][1] = 1; n   } n   for (int i = 1; i < 60; ++i) { n     if (x & (1LL << i)) { n       if (s & (1LL << i)) { n         dp[i][0] += 2 * dp[i - 1][0]; n       } else { n         dp[i][1] += 2 * dp[i - 1][1]; n       } n     } else { n       if (s & (1LL << i)) { n         dp[i][0] += dp[i - 1][1]; n         dp[i][1] += dp[i - 1][1]; n       } else { n         dp[i][0] += dp[i - 1][0]; n         dp[i][1] += dp[i - 1][0]; n       } n     } n   } n   return dp[59][0] - ways0(s, x); n } n int main() { n   long long s, x; n   cin >> s >> x; n   cout << solve(s, x) <<   n ; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n template <class T> n inline void dmin(T& x, T y) { n   y < x ? x = y : 0; n } n template <class T> n inline void dmax(T& x, T y) { n   y > x ? x = y : 0; n } n template <class T> n inline void dmin(T& x, vector<T> y) { n   for (auto t : y) t < x ? x = t : 0; n } n template <class T> n inline void dmax(T& x, vector<T> y) { n   for (auto t : y) t > x ? x = t : 0; n } n const int N = 5 + 1e6; n const long long INF = -2e18; n int n, k; n long long gk(int x, long long a[], int i, long long f) { n   return a[x] + (i - x) / 3 * f; n } n bool cmp(int x, int y, long long a[], int i, long long f) { n   return gk(x, a, i, f) > gk(y, a, i, f); n } n void opera(long long a[], int n, long long f, int k) { n   static long long b[N]; n   static long long q[3][N], left[3], right[3]; n   for (int i = 0; i < 3; ++i) left[i] = 1, right[i] = 0; n   for (int i = 0; i < n; ++i) b[i] = INF; n   for (int i = 0; i < n; ++i) { n     int t = i % 3; n     while (left[t] <= right[t] && q[t][left[t]] < i - 3 * k) ++left[t]; n     while (left[t] <= right[t] && cmp(i, q[t][right[t]], a, i, f)) --right[t]; n     q[t][++right[t]] = i; n     b[i] = gk(q[t][left[t]], a, i, f); n   } n   for (int i = 0; i < n; ++i) a[i] = b[i]; n } n void opera2(long long a[], int n, long long f, int k) { n   static long long f1[N], f2[N]; n   for (int i = 0; i < n; ++i) { n     f1[i] = f2[i] = a[i]; n     for (int j = 1; j < 10 && i - j >= 0; ++j) f2[i] = max(f2[i], a[i - j]); n   } n   opera(f1, n, f, 3 * k); n   opera(f2, n, f, 3 * (k - 1)); n   for (int i = 0; i < n; ++i) a[i] = max(f1[i], f2[i]); n } n long long a[N], b[N]; n int main() { n   int k; n   scanf( %d , &k); n   long long f[6]; n   for (int i = 0; i < 6; ++i) scanf( %lld , &f[i]); n   a[0] = 0; n   n = 1; n   for (int i = 5; i >= 0; --i) { n     for (int j = 0; j < 10 * n; ++j) b[j] = INF; n     for (int j = 0; j < n; ++j) b[j * 10] = a[j]; n     n *= 10; n     opera2(b, n, f[i], k); n     for (int j = 0; j < n; ++j) a[j] = b[j]; n   } n   int q; n   scanf( %d , &q); n   while (q--) { n     int x; n     scanf( %d , &x); n     printf( %lld n , a[x]); n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int main() { n   int t; n   cin >> t; n   while (t--) { n     int n; n     cin >> n; n     int arr[n]; n     for (int i = 0; i < n; i++) { n       cin >> arr[i]; n     } n     sort(arr, arr + n); n     bool f = true; n     for (int j = 1; j < n; j++) { n       int diff = abs(arr[j] - arr[j - 1]); n       if (diff > 1) { n         f = false; n       } n     } n     if (f) { n       cout <<  YES n ; n     } else { n       cout <<  NO n ; n     } n   } n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int a, b, k, t, suan, d[1100002], f[1110000]; n int main() { n   cin >> a >> b >> k >> t; n   int shu = k * 2 * t; n   d[shu] = 1; n   int y = d[0]; n   for (int i = 1; i <= t * 2; i++) { n     f[0] = y; n     for (int j = 1; j <= shu * 2 + k; j++) { n       f[j] = (f[j - 1] + d[j]) % 1000000007; n     } n     for (int j = 0; j <= k; j++) { n       d[j] = f[j + k]; n     } n     for (int j = k + 1; j <= shu * 2; j++) { n       d[j] = (f[j + k] - f[j - 1 - k] + 1000000007) % 1000000007; n     } n   } n   for (int i = shu - a + b + 1; i <= shu * 2; i++) { n     suan = (suan + d[i]) % 1000000007; n   } n   cout << suan; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n long long int modulo = 1000000007; n const int limite = 1000001; n long long int elev[limite]; n int ocupado[limite]; n int main() { n   ios_base::sync_with_stdio(false); n   int n, m, k; n   cin >> n >> m >> k; n   elev[0] = 1; n   for (int i = 1; i < limite; i++) elev[i] = (elev[i - 1] * 2) % modulo; n   int ini = 0; n   int fin = n + 1; n   int inf = k + 2; n   int sup = n; n   for (int i = 0; i < m; i++) { n     int u, v; n     cin >> u >> v; n     if (v == u + 1) n       ; n     else if (v == u + k + 1) { n       ocupado[v] = 1; n       ini = max(ini, u); n       fin = min(fin, v); n       inf = max(inf, u + 1); n       sup = min(sup, v + k); n     } else { n       cout << 0 << endl; n       exit(0); n     } n   } n   if (fin <= ini) { n     cout << 0 << endl; n     exit(0); n   } n   int libres = 0; n   long long int maneras = 1; n   for (int i = inf; i <= sup; i++) { n     if (not ocupado[i]) { n       maneras = (maneras + elev[libres]) % modulo; n       libres++; n     } n     if (i - k >= inf and not ocupado[i - k]) libres--; n   } n   cout << maneras << endl; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n bool v[6]; n int a[100009][6], maxx = -1, t; n long long m = 1e9 + 7; n struct pi { n   long long ah[60][60]; n }; n pi multi(pi x, pi y) { n   pi z; n   for (int i = 1; i <= t; i++) { n     for (int j = 1; j <= t; j++) { n       z.ah[i][j] = 0; n       for (int k = 1; k <= t; k++) n         z.ah[i][j] = (z.ah[i][j] % m + x.ah[i][k] % m * y.ah[k][j] % m) % m; n       z.ah[i][j] %= m; n     } n   } n   return z; n } n pi quimul(pi x, long long int n) { n   pi an; n   for (int i = 1; i <= t; i++) an.ah[i][i] = 1; n   for (; n; n >>= 1) { n     if (n & 1) an = multi(an, x); n     x = multi(x, x); n   } n   return an; n } n int main() { n   long long n; n   int x, v, p[600], zh[90][90]; n   char c =  a , u; n   for (int i = 1; i <= 52; i++) n     for (int j = 1; j <= 52; j++) zh[i][j] = 1; n   for (int i = 1; i <= 26; i++) p[(int)c + i - 1] = i; n   c =  A ; n   for (int i = 27; i <= 52; i++) p[(int)c + i - 27] = i; n   cin >> n >> t >> v; n   for (int i = 0; i < v; i++) { n     scanf(  %c %c , &c, &u); n     zh[p[(int)c]][p[(int)u]] = 0; n   } n   pi ans; n   for (int i = 1; i <= t; i++) n     for (int j = 1; j <= t; j++) ans.ah[i][j] = zh[i][j]; n   ans = quimul(ans, n - 1); n   long long int pp = 0; n   for (int i = 1; i <= t; i++) n     for (int j = 1; j <= t; j++) pp = (pp + ans.ah[i][j]) % m; n   cout << (pp + m) % m << endl; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int main() { n   int a, b, c, n, i, j, money; n   cin >> a >> b >> c; n   cin >> n; n   int m[n]; n   money = 0; n   for (i = 0; i < n; i++) { n     cin >> m[i]; n     if (m[i] > b && m[i] < c) money = money + 1; n   } n   if (a > b && a < c) n     cout << money; n   else n     cout << 0; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n template <typename T> n void display(T a[], int size) { n   for (int i = 0; i < size; i++) { n     cout << a[i] <<    ; n   } n   cout << endl; n } n void display(vector<pair<int, int> > a) { n   for (int i = 0; i < a.size(); i++) { n     cout <<  (  << a[i].first <<  ,  << a[i].second <<  )  n          <<    ; n   } n   cout << endl; n } n void display(const vector<int>& a) { n   for (int i = 0; i < a.size(); i++) { n     cout << a[i]; n     if (i == a.size() - 1) n       cout << endl; n     else n       cout <<    ; n   } n } n template <typename T> n void initialise(T a[], T value, int length) { n   for (int i = 0; i < length; i++) a[i] = value; n } n template <typename T> n void initialise(vector<T>& a, T value) { n   for (int i = 0; i < a.size(); i++) a[i] = value; n } n bool compare(pair<int, int> a, pair<int, int> b) { n   if (a.first != b.first) n     return a.first < b.first; n   else n     return a.second < b.second; n } n int max(int a[], int n) { n   int max = -1000000000; n   for (int i = 0; i < n; i++) { n     if (a[i] > max) max = a[i]; n   } n   return max; n } n bool find(string a[], string s, int n) { n   int left = 0; n   int right = n - 1; n   while (left < right) { n     int mid = (left + right) / 2; n     if (s.compare(a[mid]) == 0) n       return true; n     else if (s.compare(a[mid]) < 0) { n       right = mid; n     } else { n       left = mid + 1; n     } n   } n   return false; n } n void factor(int a[], int base, int num, int n) { n   for (int i = n - 1; i >= 0; i--) { n     a[i] = num % base; n     num = num / base; n   } n } n int findLength(int n, int base) { n   int i = 0; n   while (n > 0) { n     i++; n     n = n / base; n   } n   return i; n } n int gcd(int a, int b) { n   while (a % b != 0 && b % a != 0) { n     if (b > a) { n       b = b % a; n     } else if (a > b) { n       a = a % b; n     } n   } n   if (a <= b) n     return a; n   else n     return b; n } n int main() { n   int n; n   cin >> n; n   int dir[n]; n   int step[n]; n   for (int i = 0; i < n; i++) { n     char now; n     cin >> now; n     if (now ==  > ) n       dir[i] = 1; n     else n       dir[i] = -1; n   } n   for (int i = 0; i < n; i++) { n     cin >> step[i]; n   } n   int trace[n]; n   initialise(trace, 0, n); n   int curr = 0; n   while (true) { n     if (trace[curr] == 1) { n       cout <<  INFINITE  << endl; n       break; n     } else { n       trace[curr] = 1; n       curr = curr + dir[curr] * step[curr]; n       if (curr >= n || curr < 0) { n         cout <<  FINITE  << endl; n         break; n       } n     } n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int N, dp[100005][3], MOD = 1000000007; n char s[2][100005]; n long long ans = 1; n int main() { n   scanf( %d%s%s , &N, s[0], s[1]); n   for (int i = 0; i < N; ++i) { n     if (s[0][i] ==  ? ) ans = (((ans * 10) % (MOD) + (MOD)) % (MOD)); n     if (s[1][i] ==  ? ) ans = (((ans * 10) % (MOD) + (MOD)) % (MOD)); n     for (int x = 0; x < 10; ++x) { n       for (int y = 0; y < 10; ++y) { n         if ((s[0][i] ==  ?  || s[0][i] == x +  0 ) && n             (s[1][i] ==  ?  || s[1][i] == y +  0 )) { n           if (x >= y) { n             dp[i][0] = n                 (((dp[i][0] + (i ? dp[i - 1][0] : 1)) % (MOD) + (MOD)) % (MOD)); n           } n           if (x <= y) { n             dp[i][1] = n                 (((dp[i][1] + (i ? dp[i - 1][1] : 1)) % (MOD) + (MOD)) % (MOD)); n           } n           if (x == y) { n             dp[i][2] = n                 (((dp[i][2] + (i ? dp[i - 1][2] : 1)) % (MOD) + (MOD)) % (MOD)); n           } n         } n       } n     } n   } n   if (N == 1) n     puts( 0 ); n   else n     printf( n          %d n , n         (((ans - dp[N - 1][0] - dp[N - 1][1] + dp[N - 1][2]) % (MOD) + (MOD)) % n          (MOD))); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int main() { n   long long n, c = 0, d = 0, k; n   string str; n   cin >> n >> str; n   for (int i = 0; i < n; i++) { n     if (str[i] ==  - ) c++; n   } n   if (c == n) { n     cout << 0 << endl; n     return 0; n   } else if (str[0] ==  - ) { n     for (int i = 0; i < n; i++) { n       if (str[i] ==  - ) { n         continue; n       } else { n         k = i; n         break; n       } n     } n     for (int i = k; i < n; i++) { n       if (str[i] ==  + ) n         d += 1; n       else { n         d -= 1; n         if (d < 0) d = 0; n       } n     } n   } else { n     for (int i = 0; i < n; i++) { n       if (str[i] ==  + ) n         d += 1; n       else { n         d -= 1; n         if (d < 0) d = 0; n       } n     } n   } n   cout << d << endl; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int M; n const int MAX = 100001; n vector<int> _size, marked, _pow, _ipow; n vector<pair<int, int> > adjList[MAX + 1]; n int getSize(int u, int p = -1) { n   _size[u] = 1; n   for (auto [v, w] : adjList[u]) n     if (v != p && !marked[v]) _size[u] += getSize(v, u); n   return _size[u]; n } n int getCentroid(int u, int p, int n) { n   for (auto [v, w] : adjList[u]) n     if (v != p && !marked[v] && _size[v] * 2 > n) return getCentroid(v, u, n); n   return u; n } n void add(unordered_map<int, int> &aux, int u, int p, int lvl, int rem) { n   aux[rem]++; n   for (auto [v, w] : adjList[u]) n     if (v != p && !marked[v]) n       add(aux, v, u, lvl + 1, (int(1LL * w * _pow[lvl] % M) + rem) % M); n } n void remove(unordered_map<int, int> &aux, int u, int p, int lvl, int rem) { n   aux[rem]--; n   for (auto [v, w] : adjList[u]) n     if (v != p && !marked[v]) n       remove(aux, v, u, lvl + 1, (int(1LL * w * _pow[lvl] % M) + rem) % M); n } n long long count(unordered_map<int, int> &aux, int u, int p, int lvl, int rem) { n   int nxt = int(1LL * _ipow[lvl] * (M - rem) % M); n   long long ans = aux[nxt]; n   for (auto [v, w] : adjList[u]) n     if (v != p && !marked[v]) n       ans += count(aux, v, u, lvl + 1, (rem * 10LL + w) % M); n   return ans; n } n long long solve(int u) { n   int N = getSize(u); n   u = getCentroid(u, -1, N); n   marked[u] = 1; n   unordered_map<int, int> aux; n   aux[0] = 1; n   for (auto [v, w] : adjList[u]) n     if (!marked[v]) add(aux, v, u, 1, w % M); n   long long ans = aux[0] - 1; n   for (auto [v, w] : adjList[u]) n     if (!marked[v]) { n       remove(aux, v, u, 1, w % M); n       ans += count(aux, v, u, 1, w % M); n       add(aux, v, u, 1, w % M); n     } n   aux.clear(); n   for (auto [v, w] : adjList[u]) n     if (!marked[v]) ans += solve(v); n   return ans; n } n int gcd(int a, int b, int &x, int &y) { n   if (b == 0) { n     x = 1; n     y = 0; n     return a; n   } n   int x1, y1; n   int d = gcd(b, a % b, x1, y1); n   x = y1; n   y = x1 - y1 * (a / b); n   return d; n } n int getInv() { n   int x, y; n   int g = gcd(10, M, x, y); n   assert(g == 1); n   return (x % M + M) % M; n } n int main() { n   ios_base ::sync_with_stdio(false); n   cin.tie(nullptr); n   int n; n   cin >> n >> M; n   _size = vector<int>(n), _pow = vector<int>(n + 1, 1), n   _ipow = vector<int>(n + 1, 1), marked = vector<int>(n + 1); n   _ipow[1] = getInv(); n   _pow[1] = 10; n   for (int i = 2; i <= n; i++) { n     _pow[i] = int(1LL * _pow[i - 1] * 10 % M); n     _ipow[i] = int(1LL * _ipow[i - 1] * _ipow[1] % M); n   } n   for (int i = 0; i < n - 1; i++) { n     int u, v, w; n     cin >> u >> v >> w; n     adjList[u].push_back({v, w}); n     adjList[v].push_back({u, w}); n   } n   cout << solve(0) <<   n ; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int N = 2e6 + 100, M = 1e6 + 100; n int n, up[N], down[M], nei[M][2]; n int lim; n bool mark[M], bad[M]; n vector<int> vec; n int f(int a) { return lower_bound(vec.begin(), vec.end(), a) - vec.begin(); } n bool dfs(int v) { n   mark[v] = true; n   for (int i = 0; i < 2 && nei[v][i] <= lim; i++) { n     int u = nei[v][i]; n     if (up[u] == -1 || (mark[up[u]] == false && dfs(up[u]))) { n       up[u] = v; n       down[v] = u; n       return true; n     } n   } n   return false; n } n bool ok(int X) { n   lim = X; n   fill(up, up + N, -1); n   fill(down, down + M, -1); n   memset(bad, false, sizeof bad); n   int matching = 0; n   bool done = false; n   for (int v = 0; v < n; v++) n     if (nei[v][0] > lim) n       return false; n     else if (nei[v][1] > lim) { n       if (up[nei[v][0]] != -1) return false; n       down[v] = nei[v][0]; n       up[nei[v][0]] = v; n       bad[v] = true; n       matching++; n     } n   while (done == false) { n     done = true; n     copy(bad, bad + n, mark); n     for (int v = 0; v < n; v++) n       if (mark[v] == false && down[v] == -1 && dfs(v)) { n         matching++; n         done = false; n       } n   } n   return matching == n; n } n int main() { n   ios::sync_with_stdio(false), cin.tie(0); n   cin >> n; n   for (int i = 0; i < n; i++) { n     cin >> nei[i][0] >> nei[i][1]; n     vec.push_back(nei[i][0]); n     vec.push_back(nei[i][1]); n   } n   sort(vec.begin(), vec.end()); n   vec.resize(unique(vec.begin(), vec.end()) - vec.begin()); n   for (int i = 0; i < n; i++) n     nei[i][0] = f(nei[i][0]), nei[i][1] = f(nei[i][1]); n   if (ok(vec.size() - 1) == false) { n     cout << -1; n     return 0; n   } n   if (ok(vec.size() - 2) == false) { n     cout << vec.back(); n     return 0; n   } n   int l = -1, r = vec.size() - 1; n   while (r - l > 1) { n     if (ok((l + r) >> 1)) n       r = lim; n     else n       l = lim; n   } n   cout << vec[r]; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int val[200007], add[200007]; n int main() { n   int n, t, a, x, k, l = 1; n   long long sum = 0; n   scanf( %d , &n); n   for (int i = 0; i < n; ++i) { n     scanf( %d , &t); n     if (t == 1) { n       scanf( %d%d , &a, &x); n       add[a] += x; n       sum += a * x; n     } else if (t == 2) { n       scanf( %d , &k); n       val[++l] = k; n       sum += val[l]; n     } else if (l > 1) { n       sum -= val[l]; n       sum -= add[l]; n       add[l - 1] += add[l]; n       add[l] = 0; n       --l; n     } n     printf( %.6lf n , (double)sum / l); n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n constexpr int N = 2e5 + 10; n long long n, w, k, happy[N], nice, t[N], mytime, ans; n bool in[N]; n pair<int, int> lowest; n set<pair<int, int>> st; n queue<int> q; n int main() { n   ios_base::sync_with_stdio(false); n   cin.tie(0); n   cout.tie(0); n   cin >> n >> w >> k; n   for (int i = 0; i < n; i++) cin >> happy[i]; n   for (int i = 0; i < n; i++) cin >> t[i]; n   for (int i = n - 1; ~i; i--) { n     st.insert({t[i], -i}); n     if ((int)st.size() == w) { n       lowest = *st.begin(); n       mytime += (t[i] + 1) / 2; n       in[i] = true; n     } else if ((int)st.size() > w) { n       if (t[i] >= lowest.first) { n         in[-lowest.second] = false; n         mytime += (t[i] + 1) / 2; n         mytime -= (lowest.first + 1) / 2; n         mytime += lowest.first; n         lowest = *st.upper_bound(lowest); n         in[i] = true; n       } else n         mytime += t[i]; n     } else { n       in[i] = true; n       mytime += (t[i] + 1) / 2; n     } n     nice += happy[i]; n     q.push(i); n     while (mytime > k) { n       nice -= happy[q.front()]; n       if (in[q.front()]) { n         mytime -= (t[q.front()] + 1) / 2; n         in[q.front()] = false; n         st.erase({t[q.front()], -q.front()}); n         if ((int)st.size() >= w) { n           lowest = *(--st.lower_bound(lowest)); n           in[-lowest.second] = true; n           mytime -= lowest.first; n           mytime += (lowest.first + 1) / 2; n         } n       } else { n         mytime -= t[q.front()]; n         st.erase({t[q.front()], -q.front()}); n       } n       q.pop(); n     } n     ans = max(ans, nice); n   } n   cout << ans <<   n ; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n inline void speedUp() { n   ios_base::sync_with_stdio(false); n   cin.tie(NULL); n   cout.tie(NULL); n } n long long int t, n, m, p[100005], q[100005], Podd, Peven, Qodd, Qeven, tot; n int main() { n   speedUp(); n   int t, n; n   cin >> t; n   while (t--) { n     tot = Podd = Peven = Qodd = Qeven = 0; n     cin >> n; n     for (int i = 1; i <= n; i++) { n       cin >> p[i]; n       if (p[i] % 2 == 0) n         Peven++; n       else n         Podd++; n     } n     cin >> m; n     for (int i = 1; i <= m; i++) { n       cin >> q[i]; n       if (q[i] % 2 == 0) n         Qeven++; n       else n         Qodd++; n     } n     for (int i = 1; i <= n; i++) { n       if (p[i] % 2 == 0) n         tot += Qeven; n       else n         tot += Qodd; n     } n     cout << tot << endl; n   } n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int main(void) { n   int n; n   scanf( %d , &n); n   int v[n]; n   for (int i = 0; i < n; i++) scanf( %d , v + i); n   if (n > 2) { n     for (int i = 0; i + 3 <= n; i++) { n       int a = v[i], b = v[i + 1], c = v[i + 2]; n       int ans1 = -1, ans2 = -1; n       set<int> ms; n       ms.insert(a); n       ms.insert(b); n       ms.insert(c); n       if (ms.size() == 1) n         continue; n       else if (ms.size() == 3) { n         if (a == *ms.begin()) n           ans1 = i, ans2 = i + 1; n         else if (a == *(++ms.begin())) n           ans1 = i, ans2 = i + 2; n         else if (a == *ms.rbegin()) n           ans1 = i, ans2 = i + 1; n       } else if (ms.size() == 2) { n         if (a == c) { n           int d = -1; n           if (i > 0) { n             d = v[i - 1]; n             if (d != a) n               ans1 = i - 1, ans2 = i; n             else n               ans1 = i, ans2 = i + 1; n           } else if (i + 3 < n) { n             d = v[i + 3]; n             if (d != a) n               ans1 = i + 2, ans2 = i + 3; n             else n               ans1 = i + 1, ans2 = i + 2; n           } else n             continue; n         } else if (a == b) n           ans1 = i + 1, ans2 = i + 2; n         else if (b == c) n           ans1 = i, ans2 = i + 1; n       } n       printf( %d %d n , ans1 + 1, ans2 + 1); n       return 0; n     } n   } n   printf( -1 n ); n   return (0); n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const double eps = 1e-2; n struct cplx { n   double x, y; n   cplx(double x1 = 0, double x2 = 0) { x = x1, y = x2; } n } g[2000001], f[2000001]; n cplx operator+(cplx a, cplx b) { return cplx(a.x + b.x, a.y + b.y); } n cplx operator-(cplx a, cplx b) { return cplx(a.x - b.x, a.y - b.y); } n cplx operator*(cplx a, cplx b) { n   return cplx(a.x * b.x - a.y * b.y, a.x * b.y + a.y * b.x); n } n void swap(cplx &a, cplx &b) { swap(a.x, b.x), swap(a.y, b.y); } n int a[2000001], b[2000001]; n int r[2000001]; n const double Pi = acos(-1); n void fft(cplx f[], int op, int n) { n   for (int i = 0; i < n; i++) n     if (i < r[i]) swap(f[i], f[r[i]]); n   for (int w = 2; w <= n; w <<= 1) { n     int len = w / 2; n     cplx tmp(cos(Pi / len), op * sin(Pi / len)); n     for (int k = 0; k < n; k += w) { n       cplx buf(1, 0); n       for (int l = k; l < k + len; l++) { n         cplx tt = f[len + l] * buf; n         f[len + l] = f[l] - tt; n         f[l] = f[l] + tt; n         buf = buf * tmp; n       } n     } n   } n   if (op == -1) { n     for (int i = 0; i < n; i++) f[i].x /= n, f[i].y /= n; n   } n } n char p[2000001]; n char q[2000001]; n int res[2000001]; n int l1, l2, k, n, m; n void solve(char c) { n   for (int i = 0; i <= n; i++) f[i].x = f[i].y = g[i].x = g[i].y = 0; n   int far = -1; n   for (int i = 0; i < l1; i++) { n     if (p[i] == c) far = i + k; n     if (i <= far) f[i].x = 1; n   } n   far = l1; n   for (int i = l1 - 1; i >= 0; i--) { n     if (p[i] == c) far = i - k; n     if (i >= far) f[i].x = 1; n   } n   for (int i = 0; i < l2; i++) n     if (q[i] == c) g[i].x = 1; n   fft(f, 1, n); n   fft(g, 1, n); n   for (int i = 0; i < n; i++) f[i] = f[i] * g[i]; n   fft(f, -1, n); n   for (int i = 0; i < n; i++) res[i] += (int)(f[i].x + eps); n } n signed main() { n   int ans = 0; n   scanf( %d%d%d , &l1, &l2, &k); n   cin >> p; n   cin >> q; n   reverse(p, p + l1); n   n = l1, m = l2; n   for (m += n, n = 1; n <= m; n <<= 1) n     ; n   for (int i = 0; i < n; i++) r[i] = (r[i >> 1] >> 1) | ((i & 1) ? n >> 1 : 0); n   solve( A ); n   solve( T ); n   solve( G ); n   solve( C ); n   for (int i = 0; i <= l1 - l2; i++) n     if (res[l1 - i - 1] >= l2) ans++; n   printf( %d , ans); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n struct edge { n   int to, nxt; n } e[100005], e2[100005]; n int h[100005], n, cnt, hei[100005], gson[100005], node[100005], N, fa[100005]; n void ins(int x, int y) { n   e[++cnt].nxt = h[x]; n   e[cnt].to = y; n   h[x] = cnt; n } n void dfs1(int x) { n   hei[x] = 1; n   for (int i = h[x]; i; i = e[i].nxt) { n     dfs1(e[i].to); n     hei[x] = std::max(hei[x], hei[e[i].to] + 1); n     if (hei[gson[x]] < hei[e[i].to]) gson[x] = e[i].to; n   } n } n void dfs2(int x) { n   node[++N] = x; n   for (int i = h[x]; i; i = e[i].nxt) n     if (e[i].to != gson[x]) dfs2(e[i].to); n   if (gson[x]) dfs2(gson[x]); n } n int main() { n   scanf( %d , &n); n   for (int i = 2; i <= n; i++) scanf( %d , &fa[i]), ins((++fa[i]), i); n   dfs1(1); n   dfs2(1); n   for (int i = 1; i <= n; i++) printf( %d  , node[i] - 1); n   printf(  n%d n , n - hei[1]); n   for (int i = 1, j = 1, k = 0; i <= n - hei[1]; i++) { n     while (j <= n && fa[node[j]] == k) k = node[j++]; n     if (j > n) break; n     printf( %d  , node[j] - 1); n     k = fa[k]; n   } n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n char a[1005], b[1005]; n int main() { n   int s1 = 0, s2 = 0; n   scanf( %s %s , &a, &b); n   int len1 = strlen(a); n   int len2 = strlen(b); n   for (int i = 0; i < len1; i++) n     if (a[i] ==  1 ) s1++; n   for (int i = 0; i < len2; i++) n     if (b[i] ==  1 ) s2++; n   if (s1 & 1) s1++; n   if (s1 >= s2) n     puts( YES ); n   else n     puts( NO ); n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int n, Q, x, y, z, kk; n int dis[500005], head[500005], father[500005], top[500005], q[500005]; n bool vis[500005]; n int far[500005], heavyson[500005], rak[500005], sum[500005], leaf[500005], ans, n     d[500005]; n struct Tree { n   int nxt, to, step; n } e[500005]; n inline bool cmp(int u, int v) { n   return dis[u] - dis[father[top[u]]] > dis[v] - dis[father[top[v]]]; n } n inline void link(int x, int y, int z) { n   e[++kk].nxt = head[x]; n   e[kk].to = y; n   e[kk].step = z; n   head[x] = kk; n } n inline int bfs(int S) { n   int left1 = 1; n   int right1 = 1; n   q[left1] = S; n   memset(d, 0, sizeof(d)); n   memset(vis, false, sizeof(vis)); n   vis[S] = true; n   while (left1 <= right1) { n     int u = q[left1++]; n     for (int i = head[u]; i; i = e[i].nxt) { n       int v = e[i].to; n       if (vis[v]) continue; n       vis[v] = true; n       q[++right1] = v; n       d[v] = d[u] + e[i].step; n     } n   } n   int kkk = 0; n   for (int i = 1; i <= n; i++) { n     if (d[i] > d[kkk]) kkk = i; n   } n   return kkk; n } n void dfs1(int u, int fa) { n   far[u] = dis[u]; n   for (int i = head[u]; i; i = e[i].nxt) { n     int v = e[i].to; n     if (v == fa) continue; n     father[v] = u; n     dis[v] = dis[u] + e[i].step; n     dfs1(v, u); n     if (!heavyson[u] || far[u] < far[v]) heavyson[u] = v, far[u] = far[v]; n   } n } n void dfs2(int u, int first) { n   top[u] = first; n   if (!heavyson[u]) { n     leaf[++leaf[0]] = u; n     return; n   } n   dfs2(heavyson[u], first); n   for (int i = head[u]; i; i = e[i].nxt) { n     int v = e[i].to; n     if (v == father[u] || v == heavyson[u]) continue; n     dfs2(v, v); n   } n } n inline int solve(int x, int y) { n   if (rak[top[x]] <= 2 * y - 1) return sum[min(y * 2 - 1, leaf[0])]; n   int u = x; n   while (rak[top[u]] > y * 2 - 1) u = father[top[u]]; n   return sum[y * 2 - 1] - n          min(min(sum[y * 2 - 1] - sum[y * 2 - 2], far[u] - dis[u]), dis[u]) + n          far[x] - dis[u]; n } n int main() { n   scanf( %d%d , &n, &Q); n   for (int i = 1; i < n; i++) { n     scanf( %d%d%d , &x, &y, &z); n     link(x, y, z); n     link(y, x, z); n   } n   int first = bfs(1); n   int root = bfs(first); n   dfs1(root, -1); n   dfs2(root, root); n   sort(leaf + 1, leaf + leaf[0] + 1, cmp); n   for (int i = 1; i <= leaf[0]; i++) { n     rak[top[leaf[i]]] = i; n     sum[i] = sum[i - 1] + dis[leaf[i]] - dis[father[top[leaf[i]]]]; n   } n   while (Q--) { n     scanf( %d%d , &x, &y); n     x = ((x + ans - 1) % n) + 1; n     y = ((y + ans - 1) % n) + 1; n     printf( %d n , ans = solve(x, y)); n   } n   return 0; n } n "}
+{"func_code_string": "#include<bits/stdc++.h> n  n #define For(i, x, n) for(int i = x; i < n; i++) n #define ROF(i,x,n) for(int i = n - 1; i >= x; i--) n  n #define IOS ios::sync_with_stdio(false); cin.tie(0); cout.tie(0) n #define F first n #define S second n #define pb push_back n #define po pop_back n #define mp make_pair n #define En endl n ///#define endl   n  n  n #define ALL(x) x.begin(), x.end() n  n using namespace std; n  n typedef double db; n typedef long long LL; n typedef string str; n typedef pair<int, int> PII; n typedef pair<LL, LL> PLL; n  n typedef vector<int> VI; n typedef vector<LL> VLL; n typedef vector<bool> VB; n typedef vector<char> VC; n typedef vector<PII> VPII; n typedef vector<string> VSTR; n typedef set<int> SI; n typedef set<LL> SLL; n typedef set<PII> SPII; n  n typedef const int CI; n typedef const long long CLL; n  n /// CI MAX_N = ; n CI MOD = 1e9 + 7; n  n int t, n, a; n  n int main () { n     IOS; n     cin >> t; n     while (t--) { n         cin >> n; n         int sumz = 0; n         int sumf = 0; n         For (i, 0, 2 * n) { n             cin >> a; n             if (a % 2 == 0) sumz++; n             else sumf++; n         } n         if (sumz == sumf) cout <<  YES  << En; n         else cout <<  NO  << En; n     } n } n  n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int maxn = 200010; n int n, m, X, a[maxn], b[maxn], c[maxn], d[maxn], tr[maxn]; n long long ans; n vector<int> M[maxn]; n vector<pair<int, int>> Q[maxn]; n void add(int p) { n   for (; p <= X; p += p & -p) tr[p]++; n } n int sum(int p) { n   int s = 0; n   for (; p; p -= p & -p) s += tr[p]; n   return s; n } n int main() { n   scanf( %d %d %d , &n, &m, &X); n   for (int i = 1; i <= n; i++) { n     scanf( %d , &a[i]), a[i] = min(a[i], X); n   } n   for (int i = 1; i <= m; i++) { n     scanf( %d , &b[i]), b[i] = min(b[i], X); n   } n   auto init = [&](int n, int *a, int *c) { n     static int mx[20][maxn], lb[maxn], rb[maxn]; n     for (int i = 1; i <= n; i++) { n       mx[0][i] = a[i], lb[i] = rb[i] = 0; n     } n     for (int i = 1; i < 20; i++) { n       for (int j = 1; j + (1 << i) - 1 <= n; j++) { n         mx[i][j] = max(mx[i - 1][j], mx[i - 1][j + (1 << (i - 1))]); n       } n     } n     auto query = [&](int l, int r) { n       int k = log2(r - l + 1); n       return max(mx[k][l], mx[k][r - (1 << k) + 1]); n     }; n     stack<int> st; n     for (int i = 1; i <= n; i++) { n       while (!st.empty() && a[st.top()] > a[i]) rb[st.top()] = i, st.pop(); n       if (!st.empty()) lb[i] = st.top(); n       st.push(i); n     } n     for (int i = 1; i <= n; i++) { n       c[i] = min(!lb[i] ? X : query(lb[i], i), !rb[i] ? X : query(i, rb[i])); n     } n   }; n   init(n, a, c), init(m, b, d); n   for (int i = 1; i <= n; i++) { n     Q[X - c[i]].emplace_back(a[i], -1); n     Q[X - a[i]].emplace_back(a[i], 1); n   } n   for (int i = 1; i <= m; i++) { n     M[b[i]].push_back(X - d[i] + 1); n   } n   for (int i = 0; i < X; i++) { n     for (int d : M[i]) add(d); n     for (auto p : Q[i]) ans += p.second * sum(p.first); n   } n   printf( %lld n , ans); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n int main() { n   int n; n   scanf( %d , &n); n   int a[n], b[n]; n   long int s = 0; n   for (int i = 0; i < n; i++) scanf( %d%d , &a[i], &b[i]); n   for (int i = 1; i < n; i++) { n     if (b[i] >= b[i - 1]) b[i] = b[i - 1]; n     s += (a[i] * b[i]); n   } n   printf( %ld n , s + (a[0] * b[0])); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int main() { n   int a = 1023, b = 0, n, e; n   char op; n   cin >> n; n   while (n--) { n     cin >> op >> e; n     if (op ==  | ) { n       a |= e; n       b |= e; n     } else if (op ==  & ) { n       a &= e; n       b &= e; n     } else if (op ==  ^ ) { n       a ^= e; n       b ^= e; n     } n   } n   int ouxor = 0; n   int ou = 0; n   int exor = 0; n   e = 0; n   for (int i = 0; i < 10; i++) { n     int num = 1 << i; n     if ((a & num) && (b & num)) n       ou |= num; n     else if ((b & num)) n       exor |= num; n     else if (!(a & num) && !(b & num)) n       ouxor |= num; n   } n   int count = 0; n   count += ouxor ? 2 : 0; n   count += ou ? 1 : 0; n   count += exor ? 1 : 0; n   cout << count << endl; n   if (ou) cout <<  |   << ou << endl; n   if (ouxor) { n     cout <<  |   << ouxor << endl; n     cout <<  ^   << ouxor << endl; n   } n   if (exor) cout <<  ^   << exor << endl; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n int main() { n   int t; n   scanf( %d , &t); n   int a, b, c, d, k, x, y; n   while (t--) { n     scanf( %d %d %d %d %d , &a, &b, &c, &d, &k); n     if (a % c == 0) { n       x = a / c; n     } else { n       x = a / c + 1; n     } n     if (b % d == 0) { n       y = b / d; n     } else { n       y = b / d + 1; n     } n     if (x + y > k) { n       printf( -1 n ); n     } else n       printf( %d %d n , k - y, y); n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const long long INF = (long long)1e15 + 696969; n long long n, k; n long long a[1LL << 20], b[1LL << 20]; n long long opt[20][1LL << 20]; n signed main() { n   ios::sync_with_stdio(false); n   cin.tie(NULL); n   cout.tie(NULL); n   memset(opt, -1, sizeof opt); n   cin >> n; n   for (long long i = 1; i < n; i <<= 1) k++; n   long long ok = false; n   for (long long i = 0; i < n; i++) { n     long long x; n     cin >> x; n     if (x == -1) n       ok = true; n     else if (!ok) n       a[i] = 0; n     else n       a[i - 1] = x; n   } n   n--; n   reverse(a, a + n); n   for (long long i = k - 1, j = 0; i > 0; i--) { n     j += 1 << i; n     b[i] = j; n   } n   for (long long i = 0; i < n; i++) { n     opt[0][i] = a[i]; n   } n   for (long long i = 1; i < k; i++) { n     long long mn = INF; n     for (long long j = n - 1; j >= 0; j--) { n       if (j > b[i]) n         opt[i][j] = INF; n       else { n         opt[i][j] = mn + a[j]; n         mn = min(mn, opt[i - 1][j]); n       } n     } n   } n   cout << opt[k - 1][0] << endl; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int main() { n   int t; n   cin >> t; n   while (t--) { n     long long x1, y1, z1; n     long long x2, y2, z2; n     cin >> x1 >> y1 >> z1; n     cin >> x2 >> y2 >> z2; n     long long sum = 0; n     if (z2 > x1) { n       z2 -= x1; n       if (z2 > z1) { n         z2 -= z1; n         sum -= (2 * z2); n       } else { n         z1 -= z2; n         sum += 2 * min(z1, y2); n       } n     } else { n       sum += 2 * min(z1, y2); n     } n     cout << sum << endl; n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n template <typename Arg1> n void __f(const char* name, Arg1&& arg1) { n   cerr << name <<   :   << arg1 << std::endl; n } n template <typename Arg1, typename... Args> n void __f(const char* names, Arg1&& arg1, Args&&... args) { n   const char* comma = strchr(names + 1,  , ); n   cerr.write(names, comma - names) <<   :   << arg1 <<   |  ; n   __f(comma + 1, args...); n } n const int N = 1510; n int DP[27][N][N]; n int ans[27][N]; n int main() { n   ios_base::sync_with_stdio(false); n   cin.tie(NULL); n   int n; n   cin >> n; n   string s; n   cin >> s; n   memset(DP, 0, sizeof(DP)); n   memset(ans, 0, sizeof(ans)); n   DP[s[0] -  a ][0][0] = 1; n   for (int i = (int)1; i < (int)N; i++) DP[s[0] -  a ][0][i] = 1; n   for (char ch =  a ; ch <=  z ; ch++) { n     if (s[0] == ch) continue; n     for (int i = (int)1; i < (int)N; i++) DP[ch -  a ][0][i] = 1; n   } n   for (int i = (int)1; i < (int)(int)(s.size()); i++) { n     for (char ch =  a ; ch <=  z ; ch++) { n       if (s[i] == ch) { n         int len = 0; n         for (int k = i; k >= 0; k--) { n           if (s[k] != ch) break; n           len++; n         } n         DP[ch -  a ][i][0] = len; n       } n       for (int j = (int)1; j < (int)N; j++) { n         if (ch == s[i]) n           DP[ch -  a ][i][j] = 1 + DP[ch -  a ][i - 1][j]; n         else n           DP[ch -  a ][i][j] = 1 + DP[ch -  a ][i - 1][j - 1]; n       } n     } n   } n   for (char ch =  a ; ch <=  z ; ch++) { n     for (int j = 0; j < N; j++) { n       for (int i = (int)0; i < (int)(int)(s.size()); i++) n         ans[ch -  a ][j] = max(ans[ch -  a ][j], DP[ch -  a ][i][j]); n     } n   } n   int q; n   cin >> q; n   for (int i = (int)0; i < (int)q; i++) { n     int m; n     char ch; n     cin >> m >> ch; n     cout << ans[ch -  a ][m] << endl; n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int INF = INT_MAX; n const long long INFL = LLONG_MAX; n int N, ans, P[100100], ord[100100]; n int comp(int a, int b) { return P[a] > P[b]; } n int main() { n   ios_base::sync_with_stdio(0); n   cout.precision(15); n   cin >> N; n   for (int(i) = 1; (i) <= (N); (i)++) { n     cin >> P[i]; n     ord[i] = i; n   } n   sort(ord + 1, ord + 1 + N, comp); n   cout << ord[1] <<     << P[ord[2]] <<   n ; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int main() { n   int n; n   cin >> n; n   vector<int> a(n); n   for (int i = 0; i < n; i++) { n     cin >> a[i]; n   } n   int inv = 0; n   for (int i = 1; i < n; i++) { n     for (int j = 0; j < i; j++) { n       if (a[i] < a[j]) { n         inv++; n       } n     } n   } n   inv %= 2; n   int m; n   cin >> m; n   for (int i = 0; i < m; i++) { n     int l, r; n     cin >> l >> r; n     int len = r - l + 1; n     int di = (len * (len - 1)) / 2; n     inv += di; n     inv %= 2; n     if (inv == 1) { n       cout <<  odd  << endl; n     } else { n       cout <<  even  << endl; n     } n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n using ll = long long; n const int MAXN = 23; n int parseInt() { n   int d; n   scanf( %d , &d); n   ; n   return d; n } n int n; n int a[MAXN], b[MAXN]; n vector<pair<int, int> > v; n map<int, int> rang; n int main() { n   cin >> n; n   for (int i = 0; i < n; ++i) { n     a[i] = parseInt(); n     v.push_back(make_pair(a[i], i)); n   } n   sort(v.begin(), v.end()); n   for (int i = 0; i < n; ++i) { n     rang[v[i].first] = i; n     b[i] = v[i].first; n   } n   int rng; n   for (int i = 0; i < n; ++i) { n     rng = rang[a[i]]; n     rng = (rng + 1) % n; n     cout << b[rng] <<    ; n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int P = 1e9 + 7, INF = 0x3f3f3f3f; n long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; } n long long qpow(long long a, long long n) { n   long long r = 1 % P; n   for (a %= P; n; a = a * a % P, n >>= 1) n     if (n & 1) r = r * a % P; n   return r; n } n long long inv(long long first) { n   return first <= 1 ? 1 : inv(P % first) * (P - P / first) % P; n } n inline int rd() { n   int first = 0; n   char p = getchar(); n   while (p <  0  || p >  9 ) p = getchar(); n   while (p >=  0  && p <=  9 ) first = first * 10 + p -  0 , p = getchar(); n   return first; n } n const int N = 1e6 + 10; n int n, a, b; n struct _ { n   long long a, b, c; n   void pr() { printf( a=%lld,b=%lld n , a, b); } n   bool operator<(const _& rhs) const { return c > rhs.c; } n } e[N]; n long long ans; n int vis[N]; n int main() { n   scanf( %d%d%d , &n, &a, &b); n   for (int i = 1; i <= n; ++i) { n     scanf( %lld%lld , &e[i].a, &e[i].b); n     e[i].c = e[i].a - e[i].b; n   } n   for (int i = 1; i <= n; ++i) ans += e[i].b; n   if (!b) return printf( %lld n , ans), 0; n   if (b == 1) { n     long long t = 0; n     for (int i = 1; i <= n; ++i) t = max(t, (e[i].a << a) - e[i].b); n     return printf( %lld n , ans + t), 0; n   } n   sort(e + 1, e + 1 + n); n   for (int i = 1; i <= n; ++i) n     if (e[i].a > e[i].b) vis[i] = 1; n   int cnt = 0; n   for (int i = 1; i <= b; ++i) n     if (vis[i]) ans += e[i].a - e[i].b, ++cnt; n   long long t = 0; n   for (int i = 1; i <= b; ++i) { n     if (vis[i]) n       t = max(t, (e[i].a << a) - e[i].a); n     else n       t = max(t, (e[i].a << a) - e[i].b); n   } n   long long ret = ans + t; n   t = 0; n   for (int i = b + 1; i <= n; ++i) t = max(t, (e[i].a << a) - e[i].b); n   if (cnt < b) n     ret = max(ret, ans + t); n   else n     ret = max(ret, ans + t - e[b].a + e[b].b); n   printf( %lld n , ret); n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int Length[1001], n, x, a[1001], Concern, Pos, Ppl; n vector<int> Queues, adj[1001], Ans; n int32_t main() { n   ios::sync_with_stdio(0); n   cin.tie(0); n   cout.tie(0); n   ; n   cin >> n >> x; n   for (int i = 1; i <= n; ++i) { n     cin >> a[i]; n     if (a[i]) adj[a[i]].push_back(i); n   } n   for (int i = 1; i <= n; ++i) { n     if (a[i] == 0) { n       Ppl = i; n       int len = 0; n       while (Ppl) { n         ++len; n         if (Ppl == x) Concern = i, Pos = len; n         if (adj[Ppl].size()) n           Ppl = adj[Ppl][0]; n         else n           Ppl = 0; n       } n       if (Concern != i) Queues.push_back(len); n     } n   } n   for (int i = Queues.size() - 1; i >= 0; --i) { n     vector<int> Add; n     for (int j = 0; j < Ans.size(); ++j) { n       if (!Length[Ans[j] + Queues[i]]) n         Add.push_back(Ans[j] + Queues[i]), Length[Ans[j] + Queues[i]] = 1; n     } n     for (int j = 0; j < Add.size(); ++j) Ans.push_back(Add[j]); n     if (!Length[Queues[i]]) Ans.push_back(Queues[i]), Length[Queues[i]] = 1; n   } n   cout << Pos <<   n ; n   sort(Ans.begin(), Ans.end()); n   for (int i = 0; i < Ans.size(); ++i) cout << Pos + Ans[i] <<   n ; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int Min = -10000000; n int Max = -Min; n int A[8] = {1, 1, 0, 0, 1, 1, 1, 1}; n int B[8] = {0, 0, 1, 1, 1, 1, -1, -1}; n int C[8]; n struct Nodes { n   int x, y; n } p[100010]; n bool operator<(Nodes &p1, Nodes p2) { n   if (p1.x == p2.x) return p1.y < p2.y; n   return p1.x < p2.x; n } n long long cross(long long x1, long long y1, long long x2, long long y2) { n   return x1 * y2 - y1 * x2; n } n int main() { n   int i, j, k; n   int n; n   long long a, b, c, res; n   while (scanf( %d , &n) != EOF) { n     for (i = 0; i < 8; i++) { n       if (i & 1) { n         C[i] = Max; n       } else n         C[i] = Min; n     } n     for (i = 1; i <= n; i++) { n       scanf( %d%d , &p[i].x, &p[i].y); n       C[0] = max(C[0], p[i].x); n       C[1] = min(C[1], p[i].x); n       C[2] = max(C[2], p[i].y); n       C[3] = min(C[3], p[i].y); n       C[4] = max(C[4], p[i].x + p[i].y); n       C[5] = min(C[5], p[i].x + p[i].y); n       C[6] = max(C[6], p[i].x - p[i].y); n       C[7] = min(C[7], p[i].x - p[i].y); n     } n     res = 0; n     for (i = 0; i < 8; i++) { n       Nodes p1, p2; n       p1.x = p1.y = Min; n       p2.x = p2.y = Max; n       for (j = 0; j < 8; j += 2) { n         Nodes tmp[2]; n         for (k = j; k < j + 2; k++) { n           c = cross(A[i], B[i], A[k], B[k]); n           a = cross(A[i], C[i], A[k], C[k]); n           b = cross(C[i], B[i], C[k], B[k]); n           if (c == 0) break; n           if (b % c || a % c) break; n           tmp[k - j].x = b / c; n           tmp[k - j].y = a / c; n         } n         if (k < j + 2) continue; n         if (tmp[1] < tmp[0]) swap(tmp[0], tmp[1]); n         if (p1 < tmp[0]) p1 = tmp[0]; n         if (tmp[1] < p2) p2 = tmp[1]; n       } n       res += max(abs(p2.x - p1.x), abs(p2.y - p1.y)); n     } n     cout << res + 4 << endl; n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int N = 1e5 + 5e4 + 2; n int head[N], grp_edge[N][30], max1[N][30], grp[N], level[N], okfine = 0, sum[N], n                                                              dem = 0; n char edge[N]; n bool cac = true; n vector<pair<int, char> > adj[N]; n vector<int> adj_grp[N]; n stack<pair<int, char> > lis; n void dfs(int x) { n   int i = 0, j; n   if (adj[x].size() == 0) { n     if (!okfine) { n       okfine = level[x]; n     } n     if (okfine != level[x]) { n       cac = false; n     } n     while (lis.size()) { n       i = lis.top().first; n       if (lis.top().second !=  ? ) { n         grp_edge[x][(int)(lis.top().second -  a  + 1)]++; n       } n       grp[i] = x; n       lis.pop(); n     } n     if (i) { n       adj_grp[head[i]].push_back(x); n       head[x] = head[i]; n     } n   } n   if (adj[x].size() == 1) { n     level[adj[x][0].first] = level[x] + 1; n     lis.push({adj[x][0].first, edge[adj[x][0].first]}); n     dfs(adj[x][0].first); n   } n   if (adj[x].size() == 2) { n     while (lis.size()) { n       i = lis.top().first; n       if (lis.top().second !=  ? ) { n         grp_edge[x][(int)(lis.top().second -  a  + 1)]++; n       } n       grp[i] = x; n       lis.pop(); n     } n     if (i) { n       adj_grp[head[i]].push_back(x); n       head[x] = head[i]; n     } n     level[adj[x][0].first] = level[x] + 1; n     lis.push({adj[x][0].first, edge[adj[x][0].first]}); n     dfs(adj[x][0].first); n     level[adj[x][1].first] = level[x] + 1; n     lis.push({adj[x][1].first, edge[adj[x][1].first]}); n     dfs(adj[x][1].first); n   } n } n void dfs1(int x) { n   int i, j; n   for (i = 0; i < adj_grp[x].size(); i++) { n     dfs1(adj_grp[x][i]); n     for (j = 1; j <= 26; j++) { n       max1[x][j] = n           max(max1[x][j], max1[adj_grp[x][i]][j] + grp_edge[adj_grp[x][i]][j]); n     } n   } n   for (j = 1; j <= 26; j++) { n     sum[x] += max1[x][j]; n   } n   if (sum[x] > okfine - level[x]) { n     dem++; n   } n } n int main() { n   ios::sync_with_stdio(0); n   cin.tie(0); n   int n, i, j, k, l, q, ans, ans1; n   char x, x1; n   cin >> n >> q; n   for (i = 2; i <= n; i++) { n     cin >> head[i] >> edge[i]; n     adj[head[i]].push_back({i, edge[i]}); n   } n   dfs(1); n   dfs1(1); n   head[1] = 0; n   for (i = 1; i <= q; i++) { n     if (!cac) { n       cout <<  Fou n ; n       continue; n     } n     cin >> j >> x; n     x1 = edge[j]; n     if (edge[j] !=  ? ) { n       grp_edge[grp[j]][(int)(edge[j] -  a  + 1)]--; n     } n     edge[j] = x; n     if (edge[j] !=  ? ) { n       grp_edge[grp[j]][(int)(edge[j] -  a  + 1)]++; n     } n     k = grp[j]; n     while (k != 1) { n       if (adj_grp[head[k]].size() == 2) { n         if (sum[head[k]] > okfine - level[head[k]]) { n           if (x1 !=  ? ) { n             sum[head[k]] -= max1[head[k]][(int)(x1 -  a  + 1)]; n             max1[head[k]][(int)(x1 -  a  + 1)] = n                 max(max1[adj_grp[head[k]][0]][(int)(x1 -  a  + 1)] + n                         grp_edge[adj_grp[head[k]][0]][(int)(x1 -  a  + 1)], n                     max1[adj_grp[head[k]][1]][(int)(x1 -  a  + 1)] + n                         grp_edge[adj_grp[head[k]][1]][(int)(x1 -  a  + 1)]); n             sum[head[k]] += max1[head[k]][(int)(x1 -  a  + 1)]; n           } n           if (x !=  ? ) { n             sum[head[k]] -= max1[head[k]][(int)(x -  a  + 1)]; n             max1[head[k]][(int)(x -  a  + 1)] = n                 max(max1[adj_grp[head[k]][0]][(int)(x -  a  + 1)] + n                         grp_edge[adj_grp[head[k]][0]][(int)(x -  a  + 1)], n                     max1[adj_grp[head[k]][1]][(int)(x -  a  + 1)] + n                         grp_edge[adj_grp[head[k]][1]][(int)(x -  a  + 1)]); n             sum[head[k]] += max1[head[k]][(int)(x -  a  + 1)]; n           } n           if (sum[head[k]] <= okfine - level[head[k]]) { n             dem--; n           } n         } else { n           if (x1 !=  ? ) { n             sum[head[k]] -= max1[head[k]][(int)(x1 -  a  + 1)]; n             max1[head[k]][(int)(x1 -  a  + 1)] = n                 max(max1[adj_grp[head[k]][0]][(int)(x1 -  a  + 1)] + n                         grp_edge[adj_grp[head[k]][0]][(int)(x1 -  a  + 1)], n                     max1[adj_grp[head[k]][1]][(int)(x1 -  a  + 1)] + n                         grp_edge[adj_grp[head[k]][1]][(int)(x1 -  a  + 1)]); n             sum[head[k]] += max1[head[k]][(int)(x1 -  a  + 1)]; n           } n           if (x !=  ? ) { n             sum[head[k]] -= max1[head[k]][(int)(x -  a  + 1)]; n             max1[head[k]][(int)(x -  a  + 1)] = n                 max(max1[adj_grp[head[k]][0]][(int)(x -  a  + 1)] + n                         grp_edge[adj_grp[head[k]][0]][(int)(x -  a  + 1)], n                     max1[adj_grp[head[k]][1]][(int)(x -  a  + 1)] + n                         grp_edge[adj_grp[head[k]][1]][(int)(x -  a  + 1)]); n             sum[head[k]] += max1[head[k]][(int)(x -  a  + 1)]; n           } n           if (sum[head[k]] > okfine - level[head[k]]) { n             dem++; n           } n         } n       } else { n         if (sum[head[k]] > okfine - level[head[k]]) { n           if (x1 !=  ? ) { n             sum[head[k]] -= max1[head[k]][(int)(x1 -  a  + 1)]; n             max1[head[k]][(int)(x1 -  a  + 1)] = n                 max1[adj_grp[head[k]][0]][(int)(x1 -  a  + 1)] + n                 grp_edge[adj_grp[head[k]][0]][(int)(x1 -  a  + 1)]; n             sum[head[k]] += max1[head[k]][(int)(x1 -  a  + 1)]; n           } n           if (x !=  ? ) { n             sum[head[k]] -= max1[head[k]][(int)(x -  a  + 1)]; n             max1[head[k]][(int)(x -  a  + 1)] = n                 max1[adj_grp[head[k]][0]][(int)(x -  a  + 1)] + n                 grp_edge[adj_grp[head[k]][0]][(int)(x -  a  + 1)]; n             sum[head[k]] += max1[head[k]][(int)(x -  a  + 1)]; n           } n           if (sum[head[k]] <= okfine - level[head[k]]) { n             dem--; n           } n         } else { n           if (x1 !=  ? ) { n             sum[head[k]] -= max1[head[k]][(int)(x1 -  a  + 1)]; n             max1[head[k]][(int)(x1 -  a  + 1)] = n                 max1[adj_grp[head[k]][0]][(int)(x1 -  a  + 1)] + n                 grp_edge[adj_grp[head[k]][0]][(int)(x1 -  a  + 1)]; n             sum[head[k]] += max1[head[k]][(int)(x1 -  a  + 1)]; n           } n           if (x !=  ? ) { n             sum[head[k]] -= max1[head[k]][(int)(x -  a  + 1)]; n             max1[head[k]][(int)(x -  a  + 1)] = n                 max1[adj_grp[head[k]][0]][(int)(x -  a  + 1)] + n                 grp_edge[adj_grp[head[k]][0]][(int)(x -  a  + 1)]; n             sum[head[k]] += max1[head[k]][(int)(x -  a  + 1)]; n           } n           if (sum[head[k]] > okfine - level[head[k]]) { n             dem++; n           } n         } n       } n       k = head[k]; n     } n     if (dem) { n       cout <<  Fou n ; n     } else { n       ans = 0; n       ans1 = 0; n       for (j = 1; j <= 26; j++) { n         ans += max1[1][j] * j; n         ans1 += max1[1][j]; n       } n       cout <<  Shi   << ans + (okfine - ans1) * 27 * 13 << endl; n     } n   } n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int main() { n   int n; n   while (scanf( %d , &n) == 1) { n     string s; n     cin >> s; n     s =  #  + s; n     bool used[n + 1]; n     memset(used, 0, sizeof used); n     int d[n + 1]; n     for (int i = 1; i <= n; i++) { n       scanf( %d , d + i); n     } n     int pos = 1; n     bool ok = false; n     while (!used[pos]) { n       used[pos] = true; n       if (s[pos] ==  < ) { n         pos -= d[pos]; n       } else { n         pos += d[pos]; n       } n       if (pos <= 0 || pos > n) { n         ok = true; n         break; n       } n     } n     if (ok) { n       puts( FINITE ); n     } else { n       puts( INFINITE ); n     } n   } n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n #pragma GCC optimize( Ofast ) n #pragma GCC target( sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,tune=native ) n #pragma GCC optimize( unroll-loops ) n using namespace std; n template <typename T, typename U> n inline ostream &operator<<(ostream &_out, const pair<T, U> &_p) { n   _out << _p.first <<     << _p.second; n   return _out; n } n template <typename T, typename U> n inline istream &operator>>(istream &_in, pair<T, U> &_p) { n   _in >> _p.first >> _p.second; n   return _in; n } n template <typename T> n inline ostream &operator<<(ostream &_out, const vector<T> &_v) { n   if (_v.empty()) { n     return _out; n   } n   _out << _v.front(); n   for (auto _it = ++_v.begin(); _it != _v.end(); ++_it) { n     _out <<     << *_it; n   } n   return _out; n } n template <typename T> n inline istream &operator>>(istream &_in, vector<T> &_v) { n   for (auto &_i : _v) { n     _in >> _i; n   } n   return _in; n } n const long long MAXN = 3604; n const long long MAXM = MAXN / 2; n const long long INF = 1e9; n const long long MOD = 998244353; n long long sum(long long a, long long b) { n   if (a + b >= MOD) { n     return a + b - MOD; n   } n   return a + b; n } n long long mul(long long a, long long b) { n   if (a * b >= MOD) { n     return (a * b) % MOD; n   } n   return a * b; n } n long long sqr(long long a) { return (a * a) % MOD; } n long long bin_pow(long long a, long long b) { n   if (b == 0) { n     return 1; n   } n   if (b % 2) { n     return mul(a, bin_pow(a, b - 1)); n   } n   return sqr(bin_pow(a, b / 2)); n } n long long fact[MAXN]; n long long rfact[MAXN]; n long long dp[2][MAXM][MAXN]; n bool connected[MAXN]; n long long dp1[MAXM]; n long long dp2[MAXN][MAXM]; n inline long long c(long long n, long long k) { n   return mul(fact[n], mul(rfact[k], rfact[n - k])); n } n class FSbalansirovannieRaspolozheniyaDomino { n  public: n   void solve(std::istream &in, std::ostream &out) { n     fact[0] = 1; n     for (long long i = 1; i < MAXN; i++) { n       fact[i] = mul(i, fact[i - 1]); n     } n     rfact[MAXN - 1] = bin_pow(fact[MAXN - 1], MOD - 2); n     for (long long j = MAXN - 1; j >= 1; j--) { n       rfact[j - 1] = mul(rfact[j], j); n     } n     long long h, w; n     in >> h >> w; n     long long n; n     in >> n; n     vector<pair<pair<long long, long long>, pair<long long, long long>>> a(n); n     in >> a; n     { n       for (long long i = 0; i <= h; i++) { n         for (long long j = 0; j < MAXM; j++) { n           dp2[i][j] = 0; n           dp[0][j][i] = 0; n         } n         connected[i] = 0; n       } n       for (long long j = 0; j < MAXM; j++) { n         dp1[j] = 0; n       } n       for (auto v : a) { n         connected[v.first.first - 1] = 1; n         connected[v.second.first - 1] = 1; n       } n       long long counts = 0; n       for (long long j = 0; j < h; j++) { n         counts += !connected[j]; n       } n       dp1[0] = 1; n       for (long long i = 0; i <= h; i++) { n         for (long long j = 0; j < MAXM; j++) { n           dp1[j] = sum(dp1[j], dp2[i][j]); n         } n         if (i + 1 < h && connected[i] == 0 && connected[i + 1] == 0) { n           for (long long j = 0; j + 1 < MAXM; j++) { n             dp2[i + 2][j + 1] = dp1[j]; n           } n         } n       } n       for (long long i = 0; i < MAXM; i++) { n         for (long long j = 0; j <= counts - 2 * i; j++) { n           dp[0][i][j] = n               mul(dp1[i], mul(fact[counts - 2 * i], n                               mul(fact[i], rfact[counts - 2 * i - j]))); n         } n       } n     } n     { n       for (long long i = 0; i <= w; i++) { n         for (long long j = 0; j < MAXM; j++) { n           dp2[i][j] = 0; n           dp[1][j][i] = 0; n         } n         connected[i] = 0; n       } n       for (long long j = 0; j < MAXM; j++) { n         dp1[j] = 0; n       } n       for (auto v : a) { n         connected[v.first.second - 1] = 1; n         connected[v.second.second - 1] = 1; n       } n       long long counts = 0; n       for (long long j = 0; j < w; j++) { n         counts += !connected[j]; n       } n       dp1[0] = 1; n       for (long long i = 0; i <= w; i++) { n         for (long long j = 0; j < MAXM; j++) { n           dp1[j] = sum(dp1[j], dp2[i][j]); n         } n         if (i + 1 < w && connected[i] == 0 && connected[i + 1] == 0) { n           for (long long j = 0; j + 1 < MAXM; j++) { n             dp2[i + 2][j + 1] = dp1[j]; n           } n         } n       } n       for (long long i = 0; i < MAXM; i++) { n         for (long long j = 0; j <= counts - 2 * i; j++) { n           dp[1][i][j] = mul(dp1[i], c(counts - 2 * i, j)); n         } n       } n     } n     long long ans = 0; n     for (long long i = 0; 2 * i <= h; i++) { n       for (long long j = 0; 2 * j <= w; j++) { n         ans += dp[0][i][j] * dp[1][j][i]; n         if (ans >= MOD * MOD) { n           ans -= MOD * MOD; n         } n       } n     } n     ans %= MOD; n     out << ans; n   } n }; n signed main() { n   ios_base::sync_with_stdio(0); n   cin.tie(0); n   FSbalansirovannieRaspolozheniyaDomino solver; n   std::istream &in(std::cin); n   std::ostream &out(std::cout); n   solver.solve(in, out); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n char _; n int num_rectangles; n pair<pair<int, int>, pair<int, int> > rectangles[135000], pre[135000], n     suff[135000]; n pair<pair<int, int>, pair<int, int> > intersection( n     pair<pair<int, int>, pair<int, int> > first, n     pair<pair<int, int>, pair<int, int> > second) { n   if (first.first.first == INT_MIN || second.first.first == INT_MIN) n     return {{INT_MIN, INT_MIN}, {INT_MIN, INT_MIN}}; n   int tx = max(first.first.first, second.first.first), n       bx = min(first.second.first, second.second.first); n   int ty = max(first.first.second, second.first.second), n       by = min(first.second.second, second.second.second); n   if (bx < tx || by < ty) return {{INT_MIN, INT_MIN}, {INT_MIN, INT_MIN}}; n   return {{tx, ty}, {bx, by}}; n } n int main() { n   scanf( %d , &num_rectangles); n   for (int i = 0; i < num_rectangles; i++) n     scanf(  %d %d %d %d , &rectangles[i].first.first, n           &rectangles[i].first.second, &rectangles[i].second.first, n           &rectangles[i].second.second); n   sort(rectangles, rectangles + num_rectangles); n   pre[0] = rectangles[0]; n   suff[num_rectangles - 1] = rectangles[num_rectangles - 1]; n   for (int i = 1; i < num_rectangles; i++) { n     pre[i] = intersection(pre[i - 1], rectangles[i]); n     suff[num_rectangles - i - 1] = intersection( n         suff[num_rectangles - i], rectangles[num_rectangles - i - 1]); n   } n   for (int i = 0; i < num_rectangles; i++) { n     if (i == 0) { n       if (suff[1].first.first != INT_MIN) { n         printf( %d %d n , suff[1].first.first, suff[1].first.second); n         return 0; n       } n     } else if (i == num_rectangles - 1) { n       if (pre[num_rectangles - 2].first.first != INT_MIN) { n         printf( %d %d n , pre[num_rectangles - 2].first.first, n                pre[num_rectangles - 2].first.second); n         return 0; n       } n     } else { n       pair<pair<int, int>, pair<int, int> > first = pre[i - 1], n                                             second = suff[i + 1], n                                             intersect = n                                                 intersection(first, second); n       if (intersect.first.first != INT_MIN) { n         printf( %d %d n , intersect.first.first, intersect.first.second); n         return 0; n       } n     } n   } n   if (pre[num_rectangles - 1].first.first != INT_MIN) { n     printf( %d %d n , pre[num_rectangles - 1].first.first, n            pre[num_rectangles - 1].first.second); n     return 0; n   } n   printf( -1 n ); n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int maxn = 1e6, maxm = 1e6; n unsigned int degree[maxn + 10], blk[maxn + 10]; n namespace find { n unsigned int fa[maxn + 10], siz[maxn + 10]; n inline void Init(const unsigned int n) { n   iota(fa, fa + n + 1, 0); n   fill(siz, siz + n + 1, 1); n } n unsigned int GetFather(const unsigned int x) { n   return fa[x] == x ? x : fa[x] = GetFather(fa[x]); n } n inline void Merge(const unsigned int x, const unsigned int y) { n   unsigned int fx = GetFather(x), fy = GetFather(y); n   if (fx == fy) return; n   if (siz[fx] < siz[fy]) swap(fx, fy); n   fa[fy] = fx; n   siz[fx] += siz[fy]; n } n }  // namespace find n int main() { n   ios_base::sync_with_stdio(false); n   unsigned int n, m; n   cin >> n >> m; n   find::Init(n); n   for (unsigned int i = 0; i < m; ++i) { n     unsigned int a, b; n     cin >> a >> b; n     find::Merge(a, b); n     ++degree[a]; n     ++degree[b]; n   } n   unsigned long long ans = 0; n   const unsigned int r = find::GetFather(1); n   bool fl = true; n   for (unsigned int i = 1; i <= n; ++i) { n     if (degree[i] & 0x01) ++blk[find::GetFather(i)]; n     if (degree[i] && find::GetFather(i) != r) fl = false; n   } n   if (fl && !blk[r]) { n     cout <<  0  << endl; n     return 0; n   } n   for (unsigned int i = 1; i <= n; ++i) n     if (find::GetFather(i) == i) { n       ans += blk[i] / 2; n       if (degree[i] && !blk[i]) ++ans; n     } n   if (!degree[1] && find::siz[1] == 1 && find::GetFather(1) == 1) ++ans; n   cout << ans << endl; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int main() { n   string s; n   int count = 0, count1 = 0; n   cin >> s; n   for (int i = 0; i < s.size(); i++) { n     if (s[i] >= 97 && s[i] <= 122) n       count++; n     else n       count1++; n   } n   if (count >= count1) { n     for (int i = 0; i < s.size(); i++) { n       if (isupper(s[i])) s[i] = s[i] + 32; n     } n   } else { n     for (int i = 0; i < s.size(); i++) { n       if (islower(s[i])) s[i] = s[i] - 32; n     } n   } n   cout << s; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int dirx[] = {-1, -1, -1, 0, 0, 1, 1, 1}; n int diry[] = {-1, 0, 1, -1, 1, -1, 0, 1}; n vector<string> vec_splitter(string s) { n   s +=  , ; n   vector<string> res; n   while (!s.empty()) { n     res.push_back(s.substr(0, s.find( , ))); n     s = s.substr(s.find( , ) + 1); n   } n   return res; n } n void debug_out(vector<string> __attribute__((unused)) args, n                __attribute__((unused)) int idx, n                __attribute__((unused)) int LINE_NUM) { n   cerr << endl; n } n template <typename Head, typename... Tail> n void debug_out(vector<string> args, int idx, int LINE_NUM, Head H, Tail... T) { n   if (idx > 0) n     cerr <<  ,  ; n   else n     cerr <<  Line(  << LINE_NUM <<  )  ; n   stringstream ss; n   ss << H; n   cerr << args[idx] <<   =   << ss.str(); n   debug_out(args, idx + 1, LINE_NUM, T...); n } n int const lmt = 2e5 + 5; n int a[lmt]; n int main() { n   ios_base::sync_with_stdio(0); n   cin.tie(0); n   cout.tie(0); n   int t; n   cin >> t; n   while (t--) { n     long long n; n     cin >> n; n     for (long long i = 0; i < n; i++) cin >> a[i]; n     if (a[0] + a[1] <= a[n - 1]) { n       cout << 1 <<    ; n       cout << 2 <<    ; n       cout << n <<   n ; n     } else { n       cout << -1 <<   n ; n     } n   } n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int a[300005], p[300005], out[300005]; n long long f[300005]; n bool v[300005]; n int n, m, cnt; n void work(int p) { n   int t = min(a[p], a[p + 1]); n   if (t) out[++m] = p; n   a[p] -= t; n   a[p + 1] -= t; n } n int main() { n   scanf( %d , &n); n   for (int i = 1; i <= n; i++) { n     scanf( %d , &a[i]); n     long long O = f[max(i - 2, 0)] + a[i]; n     long long E = f[max(i - 3, 0)] + max(a[i], a[i - 1]); n     f[i] = min(O, E); n     v[i] = (f[i] != O); n   } n   long long ans = min(f[n - 1], f[n]); n   for (int i = n - (ans == f[n - 1]); i > 0; i -= 2 + v[i]) p[++cnt] = i; n   reverse(p + 1, p + cnt + 1); n   for (int i = 1; i <= cnt; i++) { n     int pre = p[i - 1], now = p[i]; n     if (v) work(now - 1); n     work(pre + 1); n     work(now); n   } n   printf( %d n , m); n   for (int i = 1; i <= m; i++) printf( %d n , out[i]); n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int a[4] = {1, 2, 3, 5}; n int main(void) { n   int n, k; n   scanf( %d%d , &n, &k); n   printf( %d n , (5 + 6 * (n - 1)) * k); n   for (int i = 0; i < n; i++) { n     printf( %d %d %d %d n , (a[0] + 6 * i) * k, (a[1] + 6 * i) * k, n            (a[2] + 6 * i) * k, (a[3] + 6 * i) * k); n   } n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n int main() { n   int n, mxpos = 0, mx = 0, temp, i; n   scanf( %d , &n); n   int p[n]; n   for (i = 0; i < n; i++) { n     scanf( %d , &p[i]); n     if (mx < p[i]) { n       mx = p[i]; n       mxpos = i; n     } n   } n   int loopno = 0, j; n   int notsorted = 1; n   while (notsorted) { n     notsorted = 0; n     for (j = 0; j < n - loopno - 1; j++) { n       if (p[j] > p[j + 1]) { n         temp = p[j]; n         p[j] = p[j + 1]; n         p[j + 1] = temp; n         notsorted = 1; n       } n     } n     loopno++; n   } n   printf( %d %d , mxpos + 1, p[n - 2]); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int N = 32000; n const int mod = 1000000007; n const int inf = 2 * mod; n int dp[5001][5001]; n pair<long long, long long> hashVal[5001]; n pair<long long, long long> powVal[5001]; n const long long base1 = 37; n const long long base2 = 2017; n const long long mod1 = 1e9 + 7; n const long long mod2 = 1e9 + 297; n int ans[50001]; n string s; n inline int ceil(int p, int q) { return (p + q - 1) / q; } n int call(int l, int r) { n   if (l > r) return 0; n   if (l == r) return 1; n   if (l == r - 1) return (s[l] == s[r] ? 2 : 0); n   if (dp[l][r] != -1) return dp[l][r]; n   int ret; n   if (s[l] != s[r] || call(l + 1, r - 1) == 0) n     ret = 0; n   else n     ret = 1 + call(l, ceil(l + r, 2) - 1); n   return dp[l][r] = ret; n } n int main() { n   cin >> s; n   int len = s.length(); n   memset(dp, -1, sizeof(dp)); n   for (int i = 0; i < len; i++) { n     for (int j = 0; j < len; j++) { n       ans[call(i, j)]++; n     } n   } n   for (int i = len - 1; i >= 1; i--) ans[i] += ans[i + 1]; n   for (int i = 1; i <= len; i++) { n     cout << ans[i] <<    ; n   } n   cout << endl; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const long long INF = LLONG_MAX; n const long long mod = 1e9 + 7; n inline long long power(long long n, long long k, long long mod = INF) { n   long long ans = 1; n   while (k > 0) { n     if (k & 1) ans = (ans * n) % mod; n     n = (n * n) % mod; n     k >>= 1; n   } n   return ans; n } n void sum() { n   string s; n   cin >> s; n   long long n = (long long)s.size(); n   long long pre[n + 1]; n   long long suf[n + 2]; n   pre[1] = s[0] -  0 ; n   suf[n] = s[n - 1] -  0 ; n   suf[n + 1] = 0; n   suf[0] = 0; n   pre[0] = 0; n   long long st = pre[1]; n   long long en = suf[n]; n   long long t = 1; n   long long ans = 0; n   for (long long i = 1; i < n; ++i) { n     t = (t * 10) % mod; n     st = (st * 10 + s[i] -  0 ) % mod; n     pre[i + 1] = (pre[i] % mod + st) % mod; n     en = (en + t * (s[n - i - 1] -  0 )) % mod; n     suf[n - i] = en; n   } n   for (long long i = 2; i <= n + 1; ++i) { n     long long temp = i - 1; n     temp %= mod; n     ans += (((pre[i - 2] * t) % mod) + (((temp)*suf[i]) % mod)) % mod; n     ans %= mod; n     t = ((t % mod) * power(10, mod - 2, mod)) % mod; n   } n   cout << (ans) % mod <<   n ; n } n int32_t main() { n   ios::sync_with_stdio(false); n   cin.tie(NULL); n   sum(); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n int a[100005], s[100005]; n int main() { n   int l, r, q1, q2, i, N, S; n   scanf( %d%d%d%d%d , &N, &l, &r, &q1, &q2); n   s[0] = 0; n   for (i = 1; i <= N; i++) { n     scanf( %d , &a[i]); n     s[i] = s[i - 1] + a[i]; n   } n   int mx = s[N] * l + q1 * (N - 1); n   for (i = 0; i <= N; i++) { n     int t = s[i] * l + (s[N] - s[i]) * r; n     int p = N - 2 * i; n     if (p < 0) p = -p; n     if (p) p--; n     if (l > r) n       t += p * q2; n     else n       t += p * q1; n     if (t < mx) mx = t; n   } n   printf( %d n , mx); n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int arr[1000] = {0}; n int main() { n   int n, m, i, j, k; n   cin >> n; n   for (i = 0; i < n; i++) cin >> arr[i]; n   if (n % 2 == 0) { n     cout <<  No  << endl; n     return 0; n   } else { n     if (arr[0] % 2 == 1 && arr[n - 1] % 2 == 1) { n       cout <<  Yes  << endl; n     } else n       cout <<  No  << endl; n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n int main() { n   int pages, readPages[7]; n   scanf( %d , &pages); n   for (int i = 0; i < 7; i++) scanf( %d , &readPages[i]); n   int day = 1, i = 0; n   while (pages > 0) { n     if (day == 8) day = 1; n     if (i == 7) i = 0; n     pages -= readPages[i]; n     day++, i++; n   } n   printf( %d n , day - 1); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int MAX_N = 3000 + 50; n const int MAX_D = 15; n struct DP { n   int d1; n   int d2; n   int d3; n   int v1; n   int v2; n   int v3; n }; n bool operator<(const DP& l, const DP& r) { n   return l.v1 < r.v1 || (l.v1 == r.v1 && l.v2 < r.v2) || n          (l.v1 == r.v1 && l.v2 == r.v2 && l.v3 < r.v3); n } n class SparseTable { n  public: n   SparseTable(vector<pair<int, int> >& vals) { n     N = vals.size(); n     depths.assign(MAX_N, -1); n     table.assign(N, vector<pair<int, int> >(MAX_D)); n     init(); n     build(vals); n   } n   void init() { n     for (int i = 1; i < MAX_N; ++i) { n       depths[i] = depths[i - 1]; n       if ((i & (i - 1)) == 0) { n         ++depths[i]; n       } n     } n   } n   void build(vector<pair<int, int> >& vals) { n     for (int i = 0; i < N; ++i) { n       table[i][0] = vals[i]; n     } n     for (int d = 1; d <= depths[N] + 1; ++d) { n       for (int i = 0; i < N; ++i) { n         int left = i; n         int right = min(N - 1, left + (1 << (d - 1))); n         table[i][d] = max(table[left][d - 1], table[right][d - 1]); n       } n     } n   } n   pair<int, int> getMax(int left, int right) { n     int len = right - left + 1; n     int d = depths[len]; n     return max(table[left][d], table[left + len - (1 << d)][d]); n   } n  n  private: n   vector<vector<pair<int, int> > > table; n   vector<int> depths; n   int N = 0; n }; n int main() { n   ios_base::sync_with_stdio(false); n   int n; n   cin >> n; n   vector<int> vec(n); n   vector<pair<int, int> > vec_with_index(n); n   for (int i = 0; i < n; ++i) { n     cin >> vec[i]; n     vec_with_index[i].first = vec[i]; n     vec_with_index[i].second = i; n   } n   sort(vec_with_index.begin(), vec_with_index.end()); n   vector<pair<int, int> > vals; n   vals.push_back({vec_with_index[0].first, 0}); n   for (int i = 1; i < vec_with_index.size(); ++i) { n     vals.push_back({vec_with_index[i].first - vec_with_index[i - 1].first, i}); n   } n   SparseTable st(vals); n   DP ret; n   ret.v1 = -1; n   ret.v2 = -1; n   ret.v3 = -1; n   for (int d1 = n - 1; d1 >= 0; --d1) { n     for (int d2 = d1 - 1; d2 >= 0; --d2) { n       int len1 = n - 1 - d1 + 1; n       int len2 = d1 - 1 - d2 + 1; n       if (len1 > 2 * len2 || len2 > 2 * len1) { n         continue; n       } n       int min_len3 = max({1, (len1 + 1) / 2, (len2 + 1) / 2}); n       int max_len3 = min({d2, 2 * len1, 2 * len2}); n       if (min_len3 > max_len3) { n         continue; n       } n       int min_d3 = d2 - max_len3; n       int max_d3 = d2 - min_len3; n       pair<int, int> max_val = st.getMax(min_d3, max_d3); n       DP temp; n       temp.d1 = d1; n       temp.d2 = d2; n       temp.d3 = max_val.second; n       temp.v1 = vec_with_index[d1].first - vec_with_index[d1 - 1].first; n       temp.v2 = vec_with_index[d2].first - vec_with_index[d2 - 1].first; n       temp.v3 = max_val.first; n       if (ret < temp) { n         ret = temp; n       } n     } n   } n   vector<int> ret_vec(n); n   for (int i = 0; i < ret.d3; ++i) { n     ret_vec[vec_with_index[i].second] = -1; n   } n   for (int i = ret.d3; i < ret.d2; ++i) { n     ret_vec[vec_with_index[i].second] = 3; n   } n   for (int i = ret.d2; i < ret.d1; ++i) { n     ret_vec[vec_with_index[i].second] = 2; n   } n   for (int i = ret.d1; i < n; ++i) { n     ret_vec[vec_with_index[i].second] = 1; n   } n   for (auto item : ret_vec) { n     cout << item <<    ; n   } n   cout << endl; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n struct Node { n   long long l, r; n   mutable long long val; n   Node(long long l = 0, long long r = 0, long long v = 0) n       : l(l), r(r), val(v) {} n   bool operator<(const Node& rv) const { return l < rv.l; } n }; n long long n, m; n set<Node> t; n long long a[100005]; n long long seed; n long long vmax; n long long qpow(long long x, long long p, long long m) { n   long long ans = 1; n   long long base = x; n   while (p) { n     if (p & 1) ans = (ans * base) % m; n     base = (base * base) % m; n     p >>= 1; n   } n   return ans; n } n long long rnd() { n   long long ans = seed; n   seed = (seed * 7 + 13) % 1000000007; n   return ans; n } n set<Node>::iterator split(long long p) { n   set<Node>::iterator it = t.lower_bound(Node(p)); n   if (it != t.end() && it->l == p) { n     return it; n   } n   --it; n   long long l = it->l, r = it->r, val = it->val; n   t.erase(it); n   t.insert(Node(l, p - 1, val)); n   return t.insert(Node(p, r, val)).first; n } n void assign(long long l, long long r, long long v) { n   set<Node>::iterator end = split(r + 1); n   set<Node>::iterator begin = split(l); n   t.erase(begin, end); n   t.insert(Node(l, r, v)); n } n void add(long long l, long long r, long long k) { n   set<Node>::iterator end = split(r + 1); n   set<Node>::iterator begin = split(l); n   for (set<Node>::iterator it = begin; it != end; ++it) { n     it->val += k; n   } n } n long long kth(long long l, long long r, long long k) { n   vector<pair<long long, long long> > v; n   set<Node>::iterator end = split(r + 1); n   set<Node>::iterator begin = split(l); n   for (set<Node>::iterator it = begin; it != end; ++it) { n     v.push_back(make_pair(it->val, it->r - it->l + 1)); n   } n   sort(v.begin(), v.end()); n   for (long long i = 0; i < v.size(); ++i) { n     k -= v[i].second; n     if (k <= 0) return v[i].first; n   } n   return -1; n } n long long power(long long l, long long r, long long k, long long mod) { n   set<Node>::iterator end = split(r + 1); n   set<Node>::iterator begin = split(l); n   long long ans = 0; n   for (set<Node>::iterator it = begin; it != end; ++it) { n     ans = (ans + n            (((qpow(it->val % mod, k, mod) % mod) * (it->r - it->l + 1 % mod)) % n             mod)) % n           mod; n   } n   return ans % mod; n } n signed main() { n   ios::sync_with_stdio(false); n   cin >> n >> m >> seed >> vmax; n   for (long long i = 1; i <= n; ++i) { n     a[i] = (rnd() % vmax) + 1; n     t.insert(Node(i, i, a[i])); n   } n   for (long long i = 1; i <= m; ++i) { n     long long opt = (rnd() % 4) + 1, l = (rnd() % n) + 1, r = (rnd() % n) + 1, n               x, y; n     if (l > r) swap(l, r); n     if (opt == 3) n       x = (rnd() % (r - l + 1)) + 1; n     else n       x = (rnd() % vmax) + 1; n     if (opt == 4) y = (rnd() % vmax) + 1; n     if (opt == 1) { n       add(l, r, x); n     } else if (opt == 2) { n       assign(l, r, x); n     } else if (opt == 3) { n       cout << kth(l, r, x) << endl; n     } else { n       cout << power(l, r, x, y) << endl; n     } n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int maxp = 22; n const long double EPS = 1e-18; n const long long INF = 1e18; n const int MOD = 1e9 + 7; n const int N = 2e5 + 1; n void yesno(bool a) { n   if (a) { n     cout <<  YES  <<   n ; n   } else { n     cout <<  NO  <<   n ; n   } n } n long long power(long long x, long long n, long long m) { n   if (n == 0) return 1; n   long long u = power(x, n / 2, m); n   u = (u * u) % m; n   if (n % 2) u = (u * x) % m; n   return u; n } n int main() { n   ios_base::sync_with_stdio(0); n   cin.tie(0); n   cout.tie(0); n   ; n   int n; n   cin >> n; n   long long i, arr[n]; n   for (i = 0; i < n; i++) cin >> arr[i]; n   if (n == 1) { n     cout << 1 <<     << 1 <<   n ; n     cout << -arr[0] <<   n ; n     cout << 1 <<     << 1 <<   n ; n     cout << 0 <<   n ; n     cout << 1 <<     << 1 <<   n ; n     cout << 0 <<   n ; n     return 0; n   } n   cout << 1 <<     << n - 1 <<   n ; n   for (i = 0; i < n - 1; i++) { n     long long num = arr[i] % n; n     cout << num * (n - 1) <<    ; n     arr[i] += num * (n - 1); n   } n   cout <<   n ; n   cout << n <<     << n <<   n ; n   long long num = arr[n - 1] % n; n   cout << (n - num) <<   n ; n   arr[n - 1] += n - num; n   cout << 1 <<     << n <<   n ; n   for (i = 0; i < n; i++) cout << -arr[i] <<    ; n   cout <<   n ; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int32_t main() { n   ios_base::sync_with_stdio(false); n   cin.tie(0); n   cout.tie(0); n   long long n; n   cin >> n; n   char c[n][n]; n   for (long long i = 0; i < n; i++) { n     for (long long j = 0; j < n; j++) { n       cin >> c[i][j]; n     } n   } n   bool re = 1, ce = 1; n   for (long long i = 0; i < n; i++) { n     re = 1; n     for (long long j = 0; j < n; j++) { n       if (c[i][j] !=  E ) { n         re = 0; n       } n     } n     if (re == 1) { n       break; n     } n   } n   for (long long j = 0; j < n; j++) { n     ce = 1; n     for (long long i = 0; i < n; i++) { n       if (c[i][j] !=  E ) { n         ce = 0; n       } n     } n     if (ce == 1) { n       break; n     } n   } n   if (re == 1 && ce == 1) { n     cout <<  -1 ; n     return 0; n   } n   if (re == 1) { n     for (long long j = 0; j < n; j++) { n       for (long long i = 0; i < n; i++) { n         if (c[i][j] !=  E ) { n           cout << i + 1 <<     << j + 1 <<   n ; n           break; n         } n       } n     } n   } else { n     for (long long i = 0; i < n; i++) { n       for (long long j = 0; j < n; j++) { n         if (c[i][j] !=  E ) { n           cout << i + 1 <<     << j + 1 <<   n ; n           break; n         } n       } n     } n   } n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n int main() { n   int n; n   std::string s; n   std::cin >> n >> s; n   int cnt = 0; n   for (int i = 0; i < s.length(); i++) { n     if (s[i] ==  1 ) n       cnt++; n     else { n       std::cout << cnt; n       cnt = 0; n     } n   } n   std::cout << cnt; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n long long f[105][105][2]; n struct seg { n   int a; n   long long len; n   bool operator<(const seg &p) const { return a < p.a; } n } a[105]; n int main() { n   int n; n   scanf( %d , &n); n   for (int i = 1; i <= n; ++i) { n     scanf( %d%lld , &a[i].a, &a[i].len); n   } n   sort(a + 1, a + n + 1); n   long long ans = 0; n   a[0].a = -2e9; n   for (int i = 0; i <= n; ++i) n     for (int j = 0; j <= i; ++j) { n       for (int k = 0; k <= 1; ++k) { n         ans = max(ans, f[i][j][k]); n         int pr = a[j].a + k * a[j].len; n         int R, x; n         for (int p = i + 1, mx = -2e9; p <= n; ++p) { n           for (int q = 0; q <= 1; ++q) { n             int r = a[p].a + q * a[p].len; n             if (r > mx) mx = r, R = p, x = q; n             f[p][R][x] = n                 max(f[p][R][x], n                     f[i][j][k] + min(a[p].len, (long long)r - pr) + (mx - r)); n           } n         } n       } n     } n   printf( %lld n , ans); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n #pragma GCC optimize( O2 ) n using namespace std; n const int maxn = 1e5 + 10, lg = 18; n int n, m, q, cid[maxn], csize = 0, H[maxn], low[maxn], ok[maxn], par[maxn][lg], n                         comp[maxn], c1; n bool dp[maxn][lg]; n vector<int> G[maxn]; n bool mark[maxn]; n void dfs1(int a, int p) { n   par[a][0] = p; n   for (int i = 1; i < lg; i++) { n     par[a][i] = par[par[a][i - 1]][i - 1]; n   } n   low[a] = H[a]; n   mark[a] = 1; n   for (int b : G[a]) { n     if (!mark[b]) { n       H[b] = H[a] + 1; n       comp[b] = comp[a]; n       dfs1(b, a); n       low[a] = min(low[a], low[b]); n     } else if (b != p) { n       low[a] = min(low[a], H[b]); n     } n   } n } n void dfs2(int a) { n   mark[a] = 1; n   for (int b : G[a]) { n     if (!mark[b]) { n       if (low[b] >= H[a]) { n         cid[b] = csize++; n       } else { n         cid[b] = cid[a]; n       } n       dfs2(b); n     } else if (H[a] > H[b]) { n       int dis = H[a] - H[b]; n       if ((dis & 1) == 0) { n         ok[cid[a]] = 1; n       } n     } n   } n } n void dfs3(int a) { n   mark[a] = 1; n   dp[a][0] = (ok[cid[a]]); n   for (int b : G[a]) { n     if (!mark[b]) { n       dfs3(b); n     } n   } n } n bool lca(int a, int b) { n   bool ans = 0; n   if (H[a] > H[b]) swap(a, b); n   for (int i = lg - 1; i >= 0; i--) { n     if (H[par[b][i]] >= H[a]) { n       ans |= dp[b][i]; n       b = par[b][i]; n     } n   } n   if (a == b) { n     return ans; n   } n   for (int i = lg - 1; i >= 0; i--) { n     if (par[b][i] != par[a][i]) { n       ans |= dp[a][i]; n       ans |= dp[b][i]; n       a = par[a][i]; n       b = par[b][i]; n     } n   } n   ans |= dp[a][0]; n   ans |= dp[b][0]; n   return ans; n } n int32_t main() { n   scanf( %d%d , &n, &m); n   for (int i = 0; i < m; i++) { n     int a, b; n     scanf( %d%d , &a, &b); n     a--, b--; n     G[a].push_back(b); n     G[b].push_back(a); n   } n   for (int i = 0; i < n; i++) { n     if (!mark[i]) { n       comp[i] = c1++; n       dfs1(i, i); n     } n   } n   fill(mark, mark + n, 0); n   for (int i = 0; i < n; i++) { n     if (!mark[i]) { n       cid[i] = csize++; n       dfs2(i); n     } n   } n   fill(mark, mark + n, 0); n   for (int i = 0; i < n; i++) { n     if (!mark[i]) { n       dfs3(i); n     } n   } n   for (int j = 0; j < lg - 1; j++) { n     for (int i = 0; i < n; i++) { n       dp[i][j + 1] = dp[i][j] | dp[par[i][j]][j]; n     } n   } n   scanf( %d , &q); n   while (q--) { n     int a, b; n     scanf( %d%d , &a, &b); n     a--, b--; n     if (H[a] > H[b]) swap(a, b); n     if (a == b || comp[a] != comp[b]) { n       printf( No n ); n       continue; n     } n     if ((H[b] - H[a]) & 1) { n       printf( Yes n ); n       continue; n     } n     bool ans = lca(a, b); n     printf(ans ?  Yes n  :  No n ); n   } n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int main() { n   int n, k; n   cin >> n >> k; n   int a[n]; n   int count[5005] = {0}; n   for (int i = 0; i < n; i++) { n     cin >> a[i]; n     count[a[i]]++; n   } n   int c[n]; n   int d = 1; n   for (int i = 1; i <= 5000; i++) { n     if (count[i] > k) { n       cout <<  NO  n            <<   n ; n       return 0; n     } n   } n   cout <<  YES  n        <<   n ; n   if (k == 1) { n     for (int i = 0; i < n; i++) { n       cout <<  1  n            <<    ; n     } n   } else { n     for (int i = 1; i <= 5000; i++) { n       for (int j = 0; j < n; j++) { n         if (a[j] == i) { n           c[j] = d; n           d++; n         } n         if (d > k) d = d % k; n       } n     } n     for (int i = 0; i < n; i++) { n       cout << c[i] <<    ; n     } n   } n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int INF = 1e9 + 10; n const long long int LINF = 1LL * INF * INF; n const int MAXN = 2e5 + 10; n const int MAXM = 5e3 + 10; n priority_queue<int> pq; n vector<vector<int> > graph; n queue<int> que; n pair<int, int> A[20]; n long long int dp[20][(1 << 20)]; n long long int sum[(1 << 20)]; n long long int solve(int here, int cur, int n) { n   if (dp[here][cur] != -1) return dp[here][cur]; n   long long int res = 0; n   for (int i = 0; i < n; i++) { n     if (i == here) continue; n     if ((1 << i) & cur) { n       if (A[i].second == A[here].second) continue; n       res += solve(i, cur ^ (1 << here), n); n       res %= 1000000007; n     } n   } n   return dp[here][cur] = res; n } n int main() { n   int n, m, k, a, b, x, y; n   int cnt = 0; n   int mx = 0; n   int mn = INF; n   int cur = 0, idx = -1; n   int T; n   cin >> n >> T; n   for (int i = 0; i < n; i++) cin >> A[i].first >> A[i].second; n   for (int i = 0; i < n; i++) n     for (int j = 0; j < (1 << n); j++) dp[i][j] = -1; n   for (int i = 0; i < n; i++) dp[i][(1 << i)] = 1; n   for (int i = 0; i < n; i++) n     for (int j = 0; j < (1 << n); j++) solve(i, j, n); n   for (int i = 0; i < (1 << n); i++) n     for (int j = 0; j < n; j++) n       if ((1 << j) & i) sum[i] += (long long int)A[j].first; n   long long int res = 0; n   for (int i = 0; i < (1 << n); i++) { n     if (sum[i] != T) continue; n     for (int j = 0; j < n; j++) n       if ((1 << j) & i) { n         res += (long long int)dp[j][i]; n         res %= 1000000007; n       } n   } n   cout << res; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int q[1000005]; n long long i, j, t, tot, C, cnt; n long long loc[10005], op[10005]; n long long n, m, k, H, x, y, ans, tmp; n long long a[100005], w[100005], e[25], dis[10005], heap[10005]; n bool used[100005], f[10005]; n map<long long, long long> A; n map<long long, long long>::iterator it; n void Spfa(long long s) { n   long long i, head, tail, x, v; n   for (i = 1; i <= k; i++) { n     dis[i] = 1999999999999999999LL; n     f[i] = false; n   } n   dis[s + 1] = 1; n   f[s + 1] = true; n   q[1] = s + 1; n   head = 1; n   tail = 2; n   while (head != tail) { n     x = q[head]; n     f[x] = false; n     for (i = 1; i <= tot; i++) n       if (dis[x] + e[i] < dis[(dis[x] + e[i]) % k + 1]) { n         v = (dis[x] + e[i]) % k + 1; n         dis[v] = dis[x] + e[i]; n         if (!f[v]) { n           q[tail] = v; n           f[v] = true; n           tail++; n         } n       } n     head++; n   } n } n int main() { n   scanf( %I64d%I64d%I64d%I64d , &H, &n, &m, &k); n   for (i = 1; i <= n; i++) scanf( %I64d%I64d , &a[i], &w[i]); n   tot = 0; n   memset(used, false, sizeof used); n   x = 1 % k; n   for (i = 1; i <= n; i++) { n     if (a[i] % k == x) { n       used[i] = true; n       it = A.find(w[i]); n       if (it == A.end()) n         A.insert(make_pair(w[i], 1)); n       else n         A[w[i]]++; n     } n   } n   for (t = 1; t <= m; t++) { n     scanf( %I64d , &C); n     if (C == 1) { n       scanf( %I64d , &x); n       e[++tot] = x; n       Spfa(1 % k); n       for (i = 1; i <= n; i++) n         if (dis[a[i] % k + 1] <= a[i]) { n           if (!used[i]) { n             used[i] = true; n             it = A.find(w[i]); n             if (it == A.end()) n               A.insert(make_pair(w[i], 1)); n             else n               A[w[i]]++; n           } n         } n     } else if (C == 2) { n       scanf( %I64d%I64d , &x, &y); n       if (used[x]) { n         it = A.find(w[x]); n         tmp = it->second; n         if (tmp == 1) n           A.erase(w[x]); n         else n           A[w[x]]--; n         w[x] -= y; n         it = A.find(w[x]); n         if (it != A.end()) n           A[w[x]]++; n         else n           A.insert(make_pair(w[x], 1)); n       } else n         w[x] -= y; n     } else { n       if (A.size() == 0) { n         printf( 0 n ); n         continue; n       } n       it = A.end(); n       it--; n       ans = it->first; n       printf( %I64d n , ans); n       tmp = it->second; n       if (tmp == 1) n         A.erase(ans); n       else n         A[ans]--; n     } n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int main() { n   int a, b, c; n   cin >> a >> b >> c; n   int r = min(a / 3, min(b / 2, c / 2)); n   a -= 3 * r; n   b -= 2 * r; n   c -= 2 * r; n   int ans = 7 * r; n   int cnt1 = 0; n   for (int i = 0; i < 14; i++) { n     int a1 = a, b1 = b, c1 = c, cnt = 0; n     for (int j = i; j < 14; j++) { n       if (j == 0 || j == 3 || j == 6 || j == 7 || j == 10 || j == 13) a1--; n       if (j == 1 || j == 5 || j == 8 || j == 12) b1--; n       if (j == 2 || j == 4 || j == 9 || j == 11) c1--; n       if (a1 < 0 || b1 < 0 || c1 < 0) { n         cnt1 = max(cnt1, cnt); n         break; n       } n       cnt++; n     } n   } n   cout << ans + cnt1; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int main() { n   long long arr[100000], arr1[100000], n, x, z, co = 0, co1 = 0, k, m, n                                                 fin = 1000000; n   map<long long, long long> left; n   map<long long, long long> right; n   cin >> n; n   if (n % 2 == 0) n     k = n / 2; n   else n     k = (n / 2) + 1; n   for (int i = 0; i < n; i++) { n     cin >> x >> z; n     if (x == z) { n       if (left[x] == 0) { n         arr[co++] = x; n         left[x]++; n       } else n         left[x]++; n     } else { n       if (left[x] == 0) { n         arr[co++] = x; n         left[x]++; n       } else n         left[x]++; n       if (right[z] == 0) { n         arr1[co1++] = z; n         right[z]++; n       } else n         right[z]++; n     } n   } n   for (int i = 0; i < co; i++) { n     m = 1000001; n     if ((left[arr[i]] + right[arr[i]]) >= k) { n       m = k - left[arr[i]]; n       if (m < 0) { n         cout <<  0 ; n         exit(0); n       } n     } n     if (m < fin) { n       fin = m; n     } n   } n   if (fin == 1000000) { n     for (int i = 0; i < co1; i++) { n       if (right[arr1[i]] >= k) { n         cout << k; n         exit(0); n       } n     } n   } n   if (fin == 1000000) n     cout <<  -1 ; n   else n     cout << fin; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int N6 = 1e6 + 6; n using namespace std; n long long n, m, x, y, sum1, sum2, ans1, ans2; n int main() { n   cin >> n >> x >> y; n   if (n > y) { n     cout << -1; n     return 0; n   } n   sum1 = y - n + 1; n   sum1 *= sum1; n   sum1 += (n - 1); n   if (sum1 >= x) { n     for (int i = 1; i < n; ++i) { n       cout << 1 <<    ; n     } n     cout << y - n + 1; n   } else n     cout << -1; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int maxn = 1050; n int dp[maxn][9], nxt[maxn][9][maxn], a[maxn], n, cnt[9]; n inline int ask(int k) { return (1 << (k - 1)); } n int main() { n   scanf( %d , &n); n   for (int i = 1; i <= n; ++i) scanf( %d , &a[i]); n   for (int i = 1; i <= n; ++i) { n     for (int j = 1; j <= 8; ++j) cnt[j] = 0; n     for (int j = 1; j <= 8; ++j) n       for (int k = 1; k <= n; ++k) nxt[i][j][k] = 1e9; n     for (int j = i; j <= n; ++j) nxt[i][a[j]][++cnt[a[j]]] = j; n   } n   int ans = 0; n   for (int num = 0; num * 8 <= n; ++num) { n     for (int i = 0; i < 256; ++i) n       for (int k = 0; k <= 8; ++k) dp[i][k] = 1e9; n     dp[0][0] = 1; n     for (int i = 0; i < 256; ++i) n       for (int j = 0; j <= 8; ++j) n         for (int k = 1; k <= 8; ++k) { n           if (dp[i][j] > n || ask(k) & i) continue; n           dp[i ^ ask(k)][j] = min(dp[i ^ ask(k)][j], nxt[dp[i][j]][k][num] + 1); n           dp[i ^ ask(k)][j + 1] = n               min(dp[i ^ ask(k)][j + 1], nxt[dp[i][j]][k][num + 1] + 1); n         } n     for (int i = 0; i <= 8; ++i) n       if (dp[255][i] <= n + 1) ans = max(ans, 8 * num + i); n   } n   cout << ans << endl; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using lint = long long; n using ldouble = long double; n void solve() { n   int n, d; n   std::cin >> n >> d; n   std::vector<int> vs(n, 1); n   int diff = n * (n - 1) / 2 - d; n   if (diff < 0) { n     std::cout <<  NO  << std::endl; n     return; n   } n   int head = 1; n   for (int v = n - 1; v > head; --v) { n     int to = std::max(v - diff, head); n     --vs[v]; n     ++vs[to]; n     diff -= v - to; n     if (diff == 0) break; n     while (vs[head] == (1 << head)) ++head; n   } n   if (diff > 0) { n     std::cout <<  NO  << std::endl; n     return; n   } n   std::cout <<  YES  << std::endl; n   int p = 1; n   for (int i = 1; i < n; ++i) { n     int v = p, ch = 0; n     for (int j = 0; j < vs[i]; ++j) { n       std::cout << v <<    ; n       if (++ch == 2) { n         ++v; n         ch = 0; n       } n     } n     p += vs[i - 1]; n   } n   std::cout << std::endl; n } n int main() { n   std::cin.tie(nullptr); n   std::cout.tie(nullptr); n   std::ios::sync_with_stdio(false); n   int q; n   std::cin >> q; n   while (q--) solve(); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const long long mod = 1e9 + 7; n const long long inf = 1e18; n int main(void) { n   ios_base::sync_with_stdio(false); n   cin.tie(0); n   cout.tie(0); n   int t; n   cin >> t; n   while (t--) { n     long long n, k; n     cin >> n >> k; n     k++; n     long long A[n]; n     for (long long i = 0; i < n; i++) { n       cin >> A[i]; n       long long t = 1; n       while (A[i]--) { n         t *= 10; n       } n       A[i] = t; n     } n     long long ans = 0; n     for (long long i = 0; i < n; i++) { n       long long cnt = k; n       if (i != n - 1) { n         cnt = min(cnt, A[i + 1] / A[i] - 1); n       } n       ans += A[i] * 1LL * cnt; n       k -= cnt; n       if (k == 0) break; n     } n     cout << ans <<   n ; n   } n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n void r(int b, int p, int f, int h, int c); n int main() { n   int b, p, f, h, c, t; n   cin >> t; n   while (t--) { n     cin >> b >> p >> f >> h >> c; n     r(b, p, f, h, c); n   } n } n void r(int b, int p, int f, int h, int c) { n   int i, j, k, t = 0; n   i = b / 2; n   if (i == 0) { n     cout << 0 << endl; n   } else { n     if (i >= (p + f)) { n       t = (p * h) + (c * f); n       cout << t << endl; n     } else { n       if (h >= c) { n         if (p >= i) { n           t = (i * h); n           cout << t << endl; n         } else { n           t = (h * p); n           i = i - p; n           t = t + (i * c); n           cout << t << endl; n         } n       } else { n         if (f >= i) { n           t = (i * c); n           cout << t << endl; n         } else { n           t = (c * f); n           i = i - f; n           t = t + (i * h); n           cout << t << endl; n         } n       } n     } n   } n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n ; n clock_t start; n mt19937_64 rng(chrono::system_clock::now().time_since_epoch().count()); n const long long N = 501, lmx = 11; n long long mx[N][N][lmx][lmx], n, m, q, col[4][N][N], logg[N]; n long long sum(long long k, long long r1, long long c1, long long r2, n               long long c2) { n   return col[k][r2][c2] - col[k][r2][c1] - col[k][r1][c2] + col[k][r1][c1]; n } n void sparse() { n   for (long long i = 2; i < N; i++) logg[i] = logg[i / 2] + 1; n   for (long long lgi = 1; lgi < lmx; lgi++) { n     for (long long i = 1; i <= n; i++) { n       for (long long j = 1; j <= m; j++) { n         if (i + (1 << (lgi - 1)) <= n) n           mx[i][j][lgi][0] = max(mx[i][j][lgi - 1][0], n                                  mx[i + (1 << (lgi - 1))][j][lgi - 1][0]); n       } n     } n   } n   for (long long lgi = 0; lgi < lmx; lgi++) { n     for (long long lgj = 1; lgj < lmx; lgj++) { n       for (long long i = 1; i <= n; i++) { n         for (long long j = 1; j <= m; j++) { n           long long k = lgj - 1; n           if (j + (1 << k) <= m) n             mx[i][j][lgi][lgj] = n                 max(mx[i][j][lgi][k], mx[i][j + (1 << k)][lgi][k]); n         } n       } n     } n   } n } n long long query(long long r1, long long c1, long long r2, long long c2) { n   if (r1 > r2 || c1 > c2) return 0; n   long long k1 = logg[r2 - r1 + 1], k2 = logg[c2 - c1 + 1]; n   long long m1 = max(mx[r1][c1][k1][k2], mx[r2 - (1 << k1) + 1][c1][k1][k2]); n   long long m2 = max(mx[r1][c2 - (1 << k2) + 1][k1][k2], n                      mx[r2 - (1 << k1) + 1][c2 - (1 << k2) + 1][k1][k2]); n   return max(m1, m2); n } n void solve() { n   string s, ss =  RGYB ; n   cin >> n >> m >> q; n   for (long long i = 0; i < n; i++) { n     cin >> s; n     for (long long j = 0; j < m; j++) { n       for (long long k = 0; k < 4; k++) n         if (ss[k] == s[j]) col[k][i + 1][j + 1] = 1; n     } n   } n   for (long long k = 0; k < 4; k++) { n     for (long long i = 1; i <= n; i++) n       for (long long j = 1; j <= m; j++) n         col[k][i][j] += n             col[k][i - 1][j] + col[k][i][j - 1] - col[k][i - 1][j - 1]; n   } n   for (long long i = 1; i <= n; i++) { n     for (long long j = 1; j <= m; j++) { n       long long lim = min(min(i, j), min(n - i, m - j)); n       for (long long len = 1; len <= lim; len++) { n         if (sum(0, i - len, j - len, i, j) != len * len) break; n         if (sum(1, i - len, j, i, j + len) != len * len) break; n         if (sum(2, i, j - len, i + len, j) != len * len) break; n         if (sum(3, i, j, i + len, j + len) != len * len) break; n         mx[i][j][0][0] = len * len; n       } n     } n   } n   sparse(); n   while (q--) { n     long long r1, c1, r2, c2, ans = 0; n     cin >> r1 >> c1 >> r2 >> c2; n     long long s = 1, e = min(r2 - r1 + 1, c2 - c1 + 1); n     while (s <= e) { n       long long mid = (s + e) / 2; n       if (query(r1 + mid - 1, c1 + mid - 1, r2 - mid, c2 - mid) >= mid * mid) { n         s = mid + 1, ans = mid; n       } else n         e = mid - 1; n     } n     cout << 4 * ans * ans <<   n ; n   } n } n signed main() { n   ios_base::sync_with_stdio(0); n   cin.tie(0); n   cout.tie(0); n   long long t = 1; n   start = clock(); n   cout << fixed << setprecision(15); n   while (t--) { n     solve(); n   } n   double time_taken = double(clock() - start) / double(CLOCKS_PER_SEC); n   cerr << time_taken; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int gcd(int a, int b) { return b == 0 ? a : gcd(b, a % b); } n bool is_simple(int a) { n   for (int i = 2; i < a; ++i) { n     if (a % i == 0) return false; n   } n   return true; n } n int elems[200009] = {0}; n int addings[200009] = {0}; n int removes[200009] = {0}; n vector<string> orders; n int main() { n   int n; n   double current_mean = 0.; n   long long cur_num = 1; n   scanf( %d , &n); n   char buf[100]; n   gets(buf); n   orders.reserve(n); n   for (int i = 1; i < n + 1; ++i) { n     gets(buf); n     orders.push_back(string(buf)); n     int t = orders[i - 1][0] -  0 ; n     addings[i] = addings[i - 1]; n     removes[i] = removes[i - 1]; n     if (t == 2) addings[i]++; n     if (t == 3) removes[i]++; n   } n   for (int i = 0; i < n; ++i) { n     stringstream ss(orders[i]); n     int t; n     ss >> t; n     if (t == 1) { n       int x, a; n       ss >> a >> x; n       double ttt = current_mean * cur_num; n       ttt += a * x; n       current_mean = ttt / cur_num; n       int start_change = cur_num - (removes[n] - removes[i]); n       if (start_change < 0) start_change = 0; n       for (int i = start_change; i < a && i < cur_num; ++i) elems[i] += x; n     } n     if (t == 2) { n       int k; n       ss >> k; n       elems[cur_num] = k; n       cur_num++; n       double ttt = current_mean * (cur_num - 1); n       ttt += k; n       current_mean = ttt / cur_num; n     } n     if (t == 3) { n       double ttt = current_mean * (cur_num); n       ttt -= elems[cur_num - 1]; n       cur_num--; n       current_mean = ttt / cur_num; n     } n     printf( %.6f n , current_mean); n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n template <class T> n inline void chkmin(T &a, T b) { n   if (a > b) a = b; n } n template <class T> n inline void chkmax(T &a, T b) { n   if (a < b) a = b; n } n long long sum[30]; n char fir[210000], sec[210000]; n int main() { n   int len, i; n   double ans, cnt; n   scanf( %d , &len); n   scanf( %s%s , fir, sec); n   cnt = 1LL * len * (len + 1) * (2 * len + 1) / 6; n   ans = 0; n   memset(sum, 0, sizeof(sum)); n   for (i = len - 1; i >= 0; i--) { n     sum[fir[i] -  A ] += len - i; n     ans += sum[sec[i] -  A ] * (i + 1) / cnt; n   } n   memset(sum, 0, sizeof(sum)); n   for (i = len - 1; i >= 0; i--) { n     ans += sum[fir[i] -  A ] * (i + 1) / cnt; n     sum[sec[i] -  A ] += len - i; n   } n   printf( %.15lf n , 1.0 * ans); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int N = 1e5 + 5; n int n, m, k, ans[5]; n char s[N]; n void solve(int l, int r) { n   while (l != r) { n     int mid = l + r >> 1; n     printf( 1 %d %d n , mid, mid + 1); n     fflush(stdout); n     scanf( %s , s); n     if (!strcmp(s,  NIE )) n       l = mid + 1; n     else n       r = mid; n   } n   ans[++m] = l; n } n int main() { n   scanf( %d%d , &n, &k); n   solve(1, n); n   if (ans[1] > 1) solve(1, ans[1] - 1); n   if (ans[1] < n) solve(ans[1] + 1, n); n   if (m == 2) { n     printf( 2 %d %d n , ans[1], ans[2]); n     exit(0); n   } n   printf( 1 %d %d n , ans[2], ans[3]); n   fflush(stdout); n   scanf( %s , s); n   if (!strcmp(s,  NIE )) ans[2] = ans[3]; n   printf( 2 %d %d n , ans[1], ans[2]); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n const int N = 2e5 + 5; n const int highestboolN = 1e9; n const long long unsigned inf = 1234568901234567890; n const long double pi = 3.141592653589793; n const int md = 1e9 + 7; n using namespace std; n int here = 1; n void force_break() { n   here++; n   if (here >= (N * 100)) { n     cout <<   n n t Infinite loop  n n ; n     exit(1); n   } n   return; n } n int board[105][105]; n int main() { n   ios::sync_with_stdio(false); n   cin.tie(0); n   int n; n   scanf( %d , &n); n   memset(board, 0, sizeof(board)); n   for (int i = 0; i < n; i++) { n     for (int j = 0; j < n; j++) { n       if (board[i][j]) continue; n       char temp; n       if ((i + j) % 2) { n         board[i][j] = 1; n         temp = 2; n       } else { n         board[i][j] = 2; n         temp = 1; n       } n       if (i + 2 < n and j + 1 < n) board[i + 2][j + 1] = temp; n       if (i + 1 < n and j + 2 < n) board[i + 1][j + 2] = temp; n       if (i + 2 < n and j - 1 >= 0) board[i + 2][j - 1] = temp; n       if (i + 1 < n and j - 2 >= 0) board[i + 1][j - 2] = temp; n     } n   } n   for (int i = 0; i < n; i++) { n     for (int j = 0; j < n; j++) { n       if (board[i][j] == 1) n         cout <<  B ; n       else if (board[i][j] == 2) n         cout <<  W ; n     } n     cout << endl; n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n long long arr[1010], brr[1010]; n int main() { n   long long n, i, j, x, y, ans; n   cin >> n; n   for (i = 1; i <= n; i++) cin >> arr[i]; n   for (i = 1; i <= n; i++) cin >> brr[i]; n   ans = 0; n   for (i = 1; i <= n; i++) { n     x = arr[i]; n     y = brr[i]; n     ans = max(ans, x + y); n     for (j = i + 1; j <= n; j++) { n       x = (x | arr[j]); n       y = (y | brr[j]); n       ans = max(ans, x + y); n     } n   } n   cout << ans; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int n; n long long dp[26][2][2]; n long long need; n bool hasone = 0; n int ans[55]; n inline void upd(long long &a, long long b) { a += b; } n inline long long getval(int p, int v) { n   memset(dp, 0, sizeof(dp)); n   dp[0][0][0] = 1; n   for (int i = 0; i < (n + 1) / 2; i++) { n     for (int x = 0; x < 2; x++) { n       for (int y = 0; y < 2; y++) { n         if (!dp[i][x][y]) continue; n         for (int a = 0; a < 2; a++) { n           if (!i && a) continue; n           if (i <= p && a != ans[i]) continue; n           for (int b = 0; b < 2; b++) { n             if ((n - 1 - i) <= p && b != ans[n - 1 - i]) continue; n             if (i == n - 1 - i && a != b) continue; n             if (a > b && !x) continue; n             if (a > !b && !y) continue; n             upd(dp[i + 1][x | (a < b)][y | (a < !b)], dp[i][x][y]); n           } n         } n       } n     } n   } n   return dp[(n + 1) / 2][0][0] + dp[(n + 1) / 2][0][1] + dp[(n + 1) / 2][1][0] + n          dp[(n + 1) / 2][1][1] - !hasone; n } n int main() { n   cin >> n >> need; n   dp[0][0][0] = 1; n   for (int i = 0; i < (n + 1) / 2; i++) { n     for (int x = 0; x < 2; x++) { n       for (int y = 0; y < 2; y++) { n         if (!dp[i][x][y]) continue; n         for (int a = 0; a < 2; a++) { n           if (!i && a) continue; n           for (int b = 0; b < 2; b++) { n             if (i == n - 1 - i && a != b) continue; n             if (a > b && !x) continue; n             if (a > !b && !y) continue; n             upd(dp[i + 1][x | (a < b)][y | (a < !b)], dp[i][x][y]); n           } n         } n       } n     } n   } n   long long all = dp[(n + 1) / 2][0][0] + dp[(n + 1) / 2][0][1] + n                   dp[(n + 1) / 2][1][0] + dp[(n + 1) / 2][1][1]; n   all--; n   if (all < need) { n     printf( -1 n ); n     return 0; n   } n   for (int i = 0; i < n; i++) { n     ans[i] = 0; n     long long num = getval(i, ans[i]); n     if (num < need || (i == n - 1 && !hasone)) { n       ans[i] = 1; n       need -= num; n       hasone = 1; n     } n   } n   for (int i = 0; i < n; i++) printf( %d , ans[i]); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n template <typename T> n inline void read(T& x) { n   int f = 0, c = getchar(); n   x = 0; n   while (!isdigit(c)) f |= c ==  - , c = getchar(); n   while (isdigit(c)) x = x * 10 + c - 48, c = getchar(); n   if (f) x = -x; n } n template <typename T, typename... Args> n inline void read(T& x, Args&... args) { n   read(x); n   read(args...); n } n template <typename T> n void write(T x) { n   if (x < 0) x = -x, putchar( - ); n   if (x > 9) write(x / 10); n   putchar(x % 10 + 48); n } n template <typename T> n void writes(T x) { n   write(x); n   putchar(   ); n } n template <typename T> n void writeln(T x) { n   write(x); n   puts(  ); n } n template <typename T> n inline bool chkmin(T& x, const T& y) { n   return y < x ? (x = y, true) : false; n } n template <typename T> n inline bool chkmax(T& x, const T& y) { n   return x < y ? (x = y, true) : false; n } n const int maxn = (int)3e5 + 10; n const long long inf = (long long)1e18; n const int mod = (int)1e9 + 7; n int n, a[maxn]; n long long ans; n vector<int> v[maxn]; n int main() { n   read(n); n   for (int i = (1); i < (2 * n + 1); i++) read(a[i]); n   for (int i = (1); i < (2 * n + 1); i++) { n     v[a[i]].push_back(i); n   } n   int now = 1; n   for (int i = (1); i < (n + 1); i++) { n     ans += abs(v[i][0] - now); n     now = v[i][0]; n   } n   now = 1; n   for (int i = (1); i < (n + 1); i++) { n     ans += abs(v[i][1] - now); n     now = v[i][1]; n   } n   write(ans); n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const bool debug = 1; n int xl = 1 << 30, xr = -(1 << 30), yl = 1 << 30, yr = -(1 << 30), zl = 1 << 30, n     zr = -(1 << 30); n bool getpod(pair<int, int> p, int s) { n   int pzl = p.first - p.second - s; n   int pzr = p.first - p.second + s; n   int pxl = p.first - s; n   int pxr = p.first + s; n   int pyl = p.second - s; n   int pyr = p.second + s; n   if (pzl <= zl && pzr >= zr && pyl <= yl && pyr >= yr && pxl <= xl && n       pxr >= xr) n     return 1; n   return 0; n } n int main() { n   if (!debug) { n     cin.tie(0); n     cout.tie(0); n     ios::sync_with_stdio(0); n   } n   int n; n   cin >> n; n   vector<pair<int, int>> pt(n, {0, 0}); n   for (int i = 0; i < n; i++) { n     string s; n     cin >> s; n     for (int j = 0; j < s.size(); j++) n       if (s[j] ==  B ) n         pt[i].first++; n       else n         pt[i].second++; n   } n   for (int i = 0; i < n; i++) { n     xl = min(pt[i].first, xl); n     xr = max(pt[i].first, xr); n     yl = min(pt[i].second, yl); n     yr = max(pt[i].second, yr); n     zl = min(pt[i].first - pt[i].second, zl); n     zr = max(pt[i].first - pt[i].second, zr); n   } n   vector<pair<int, int>> p(12); n   vector<int> s(12); n   { n     int l = -1, r = 1 << 23; n     while (l + 1 < r) { n       int c = (l + r) / 2; n       pair<int, int> p = {zr + yl, yl + c}; n       if (getpod(p, c)) n         r = c; n       else n         l = c; n     } n     s[0] = r; n     p[0] = {zr + yl, yl + s[0]}; n   } n   { n     int l = -1, r = 1 << 23; n     while (l + 1 < r) { n       int c = (l + r) / 2; n       pair<int, int> p = {xl + c, xl - zl}; n       if (getpod(p, c)) n         r = c; n       else n         l = c; n     } n     s[1] = r; n     p[1] = {xl + s[1], xl - zl}; n   } n   { n     int l = -1, r = 1 << 23; n     while (l + 1 < r) { n       int c = (l + r) / 2; n       pair<int, int> p = {zl + yr, yr - c}; n       if (getpod(p, c)) n         r = c; n       else n         l = c; n     } n     s[2] = r; n     p[2] = {zl + yr, yr - s[2]}; n   } n   { n     int l = -1, r = 1 << 23; n     while (l + 1 < r) { n       int c = (l + r) / 2; n       pair<int, int> p = {xr - c, xr - zr}; n       if (getpod(p, c)) n         r = c; n       else n         l = c; n     } n     s[3] = r; n     p[3] = {xr - s[3], xr - zr}; n   } n   { n     int l = -1, r = 1 << 23; n     while (l + 1 < r) { n       int c = (l + r) / 2; n       pair<int, int> p = {xr - c, yr - c}; n       if (getpod(p, c)) n         r = c; n       else n         l = c; n     } n     s[4] = r; n     p[4] = {xr - s[4], yr - s[4]}; n   } n   { n     int l = -1, r = 1 << 23; n     while (l + 1 < r) { n       int c = (l + r) / 2; n       pair<int, int> p = {xl + c, yl + c}; n       if (getpod(p, c)) n         r = c; n       else n         l = c; n     } n     s[5] = r; n     p[5] = {xl + s[5], yl + s[5]}; n   } n   { n     int l = -1, r = zl - xl + yr; n     while (l + 1 < r) { n       int c = (l + r) / 2; n       pair<int, int> p = {xl + c, yr - c}; n       if (getpod(p, c)) n         r = c; n       else n         l = c; n     } n     s[6] = r; n     p[6] = {xl + s[6], yr - s[6]}; n   } n   { n     int l = -1, r = xr - yl - zr; n     while (l + 1 < r) { n       int c = (l + r) / 2; n       pair<int, int> p = {xr - c, yl + c}; n       if (getpod(p, c)) n         r = c; n       else n         l = c; n     } n     s[7] = r; n     p[7] = {xr - s[7], yl + s[7]}; n   } n   { n     int l = -1, r = xr - zl - yr; n     while (l + 1 < r) { n       int c = (l + r) / 2; n       pair<int, int> p = {xr - c, xr - zl - 2 * c}; n       if (getpod(p, c)) n         r = c; n       else n         l = c; n     } n     s[8] = r; n     p[8] = {xr - s[8], xr - zl - 2 * s[8]}; n   } n   { n     int l = -1, r = zr + yr - xr; n     while (l + 1 < r) { n       int c = (l + r) / 2; n       pair<int, int> p = {zr + yr - 2 * c, yr - c}; n       if (getpod(p, c)) n         r = c; n       else n         l = c; n     } n     s[9] = r; n     p[9] = {zr + yr - 2 * s[9], yr - s[9]}; n   } n   { n     int l = -1, r = yl + zr - xl; n     while (l + 1 < r) { n       int c = (l + r) / 2; n       pair<int, int> p = {xl + c, xl - zr + 2 * c}; n       if (getpod(p, c)) n         r = c; n       else n         l = c; n     } n     s[10] = r; n     p[10] = {xl + s[10], xl - zr + 2 * s[10]}; n   } n   { n     int l = -1, r = xl - zl - yl; n     while (l + 1 < r) { n       int c = (l + r) / 2; n       pair<int, int> p = {zl + yl + 2 * c, yl + c}; n       if (getpod(p, c)) n         r = c; n       else n         l = c; n     } n     s[11] = r; n     p[11] = {zl + yl + 2 * s[11], yl + s[11]}; n   } n   int iout = 0; n   for (int i = 0; i < 12; i++) n     if (s[i] < s[iout] && getpod(p[i], s[i])) iout = i; n   cout << s[iout] <<   n ; n   for (int i = 0; i < p[iout].first; i++) cout <<  B ; n   for (int i = 0; i < p[iout].second; i++) cout <<  N ; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int main() { n   int arr[3][3]; n   int cnt1, cnt2, cnt3; n   for (int i = 0; i < 3; i++) n     for (int j = 0; j < 3; j++) scanf( %d , &arr[i][j]); n   cnt1 = arr[0][1] + arr[0][2]; n   cnt2 = arr[1][0] + arr[1][2]; n   cnt3 = arr[2][0] + arr[2][1]; n   if (cnt1 >= cnt2 && cnt1 >= cnt3) { n     for (int i = 1; i <= 1e5; i++) n       if (cnt1 + i == cnt2 + (cnt1 - cnt2 + i) && n           cnt1 + i == cnt3 + (cnt1 - cnt3 + i) && n           i + (cnt1 - cnt3 + i) + (cnt1 - cnt2 + i) == cnt1 + i) { n         arr[0][0] = i; n         arr[1][1] = (cnt1 - cnt2 + i); n         arr[2][2] = (cnt1 - cnt3 + i); n         break; n       } n   } else if (cnt2 >= cnt1 && cnt2 >= cnt3) { n     for (int i = 1; i <= 1e5; i++) n       if (cnt2 + i == cnt1 + (cnt2 - cnt1 + i) && n           cnt2 + i == cnt3 + (cnt2 - cnt3 + i) && n           i + (cnt2 - cnt3 + i) + (cnt2 - cnt1 + i) == cnt2 + i) { n         arr[0][0] = (cnt2 - cnt1 + i); n         arr[1][1] = i; n         arr[2][2] = (cnt2 - cnt3 + i); n         break; n       } n   } else if (cnt3 >= cnt1 && cnt3 >= cnt2) { n     for (int i = 1; i <= 1e5; i++) n       if (cnt3 + i == cnt1 + (cnt3 - cnt1 + i) && n           cnt3 + i == cnt2 + (cnt3 - cnt2 + i) && n           i + (cnt3 - cnt2 + i) + (cnt3 - cnt1 + i) == cnt3 + i) { n         arr[0][0] = (cnt3 - cnt1 + i); n         arr[1][1] = (cnt3 - cnt2 + i); n         arr[2][2] = i; n         break; n       } n   } n   for (int i = 0; i < 3; i++) { n     for (int j = 0; j < 3; j++) printf( %d  , arr[i][j]); n     puts(  ); n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n long long n, x, a1, a2; n int main() { n   scanf( %lld , &n); n   for (int i = 1; i <= n; ++i) { n     scanf( %lld , &x); n     if (i % 2 == 0) { n       a1 += (x + 1) / 2; n       a2 += x / 2; n     } else { n       a1 += x / 2; n       a2 += (x + 1) / 2; n     } n   } n   printf( %lld n , min(a1, a2)); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int main() { n   ios_base::sync_with_stdio(0), cin.tie(NULL), cout.tie(NULL); n   int a, b, c; n   cin >> a >> b >> c; n   cout << ((a + c - 1) * (b + c - 1) - c * (c - 1)) <<   n ; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const long long mod = 1e9 + 7; n long long dx[] = {-1, 0, 1, 0}; n long long dy[] = {0, -1, 0, 1}; n vector<long long> p(10000005, -1); n void f(long long n = 10000005) { n   p[2] = 2; n   for (long long i = 4; i < n; i += 2) { n     p[i] = 2; n   } n   for (long long i = 3; i < n; i += 2) { n     if (p[i] == -1) { n       p[i] = i; n       for (long long j = i * i; j < n; j += i) { n         if (p[j] == -1) p[j] = i; n       } n     } n   } n } n void find(long long x, vector<long long>& v) { n   while (x != 1) { n     v.push_back(p[x]); n     x /= p[x]; n   } n } n void solve() { n   long long n, m; n   cin >> n >> m; n   vector<vector<long long>> v(n, vector<long long>(m)); n   map<long long, vector<long long>> z; n   for (long long i = 0; i < n; i++) { n     for (long long j = 0; j < m; j++) { n       cin >> v[i][j]; n       z[i + j].push_back(v[i][j]); n     } n   } n   long long f = 0, r = n + m - 2; n   long long ans = 0; n   while (f < r) { n     map<long long, long long> p; n     for (auto x : z[f]) p[x]++; n     for (auto x : z[r]) p[x]++; n     long long t = 0, mx = 0; n     for (auto x : p) { n       t += x.second; n       mx = max(mx, x.second); n     } n     ans += t - mx; n     f++; n     r--; n   } n   cout << ans <<   n ; n } n int32_t main() { n   ios::sync_with_stdio(false); n   cin.tie(0); n   cout.tie(0); n   long long t; n   cin >> t; n   while (t--) { n     solve(); n   } n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n char str[100005]; n int cnt[250]; n int main() { n   scanf( %s , &str); n   int len = strlen(str); n   set<char> myset; n   for (int i = 0; i < len; i++) { n     myset.insert(str[i]); n     cnt[str[i]]++; n   } n   if (myset.size() == 1 || myset.size() > 4) { n     printf( NO ); n     return 0; n   } n   if (myset.size() == 4) { n     printf( YES ); n     return 0; n   } n   if (myset.size() == 3) { n     if (len == 3) { n       printf( NO ); n       return 0; n     } else { n       printf( YES ); n       return 0; n     } n   } n   if (myset.size() == 2) { n     for (int i =  a ; i <=  z ; i++) { n       if (cnt[i] == 1) { n         printf( NO ); n         return 0; n       } n     } n     printf( YES ); n   } n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int MAX_N = 100005; n int n, m; n int t[MAX_N], x[MAX_N]; n int nxt; n int idx[MAX_N]; n int res[MAX_N]; n bool mycmp(const int a, const int b) { n   if (x[a] != x[b]) return x[a] < x[b]; n   return a < b; n } n int main() { n   scanf( %d%d , &n, &m); n   for (int i = 0; i < n; ++i) scanf( %d%d , &t[i], &x[i]); n   int time = 0; n   for (int step = 0; step < n; step += m) { n     nxt = 0; n     for (int i = step; i < min(step + m, n); ++i) idx[nxt++] = i; n     time += max(0, t[idx[nxt - 1]] - time); n     sort(idx, idx + nxt, mycmp); n     for (int i = 0; i < nxt;) { n       int j = i; n       for (; j < nxt && x[idx[i]] == x[idx[j]]; ++j) n         ; n       time += x[idx[i]]; n       if (i > 0) time -= x[idx[i - 1]]; n       for (int k = i; k < j; ++k) res[idx[k]] = time; n       time += 1 + (j - i) / 2; n       i = j; n     } n     time += x[idx[nxt - 1]]; n   } n   printf( %d , res[0]); n   for (int i = 1; i < n; ++i) printf(  %d , res[i]); n   printf(  n ); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int maxn = 2e5 + 7; n const int mod = 1e9 + 7; n const long long INF = 1e18; n string a[30], b[30], ans[407]; n void rua() { n   int n, m; n   cin >> n >> m; n   for (int i = 0; i < n; i++) cin >> a[i]; n   for (int i = 0; i < m; i++) cin >> b[i]; n   int cnt = 0, s1 = -1, s2 = -1; n   while (cnt < n * m) { n     s1 = (s1 + 1) % n; n     s2 = (s2 + 1) % m; n     ans[cnt++] = a[s1] + b[s2]; n   } n   int q; n   cin >> q; n   while (q--) { n     int x; n     cin >> x; n     cout << ans[(x - 1) % (n * m)] << endl; n   } n } n int main() { n   rua(); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n int main(int argc, char *argv[]) { n   int n, i, a, b, c, d; n   long int s; n   scanf( %d , &n); n   s = 0; n   for (i = 1; i <= n; i++) { n     scanf( %d %d %d %d , &a, &b, &c, &d); n     s = s + (1 + abs(a - c)) * (1 + abs(b - d)); n   } n   printf( %ld , s); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int gcd(int a, int b) { n   if (b == 0) n     return a; n   else n     return gcd(b, a % b); n } n long long lcm(long long a, long long b) { return a / gcd(a, b) * b; } n int main() { n   ios_base::sync_with_stdio(false); n   int n, m; n   cin >> n >> m; n   vector<vector<int> > edges(n + 10, vector<int>()); n   for (int i = 0; i < m; i++) { n     int x, y; n     cin >> x >> y; n     edges[x].push_back(y); n     edges[y].push_back(x); n   } n   map<int, int> not_first; n   map<int, int> not_second; n   map<int, int> not_third; n   set<int> first; n   set<int> second; n   set<int> third; n   for (int i = 1; i < n + 1; i++) { n     if (not_first.find(i) == not_first.end()) { n       first.insert(i); n       for (int j = 0; j < edges[i].size(); j++) { n         not_first[edges[i][j]]++; n       } n     } else if (not_second.find(i) == not_second.end()) { n       second.insert(i); n       for (int j = 0; j < edges[i].size(); j++) { n         not_second[edges[i][j]]++; n       } n     } else if (not_third.find(i) == not_third.end()) { n       third.insert(i); n       for (int j = 0; j < edges[i].size(); j++) { n         not_third[edges[i][j]]++; n       } n     } else { n       cout << -1; n       return 0; n     } n   } n   if (second.size() == 0 or third.size() == 0) { n     cout << -1; n   } else { n     for (auto i = not_first.begin(); i != not_first.end(); i++) { n       if (i->second != first.size()) { n         cout << -1; n         return 0; n       } n     } n     for (auto i = not_second.begin(); i != not_second.end(); i++) { n       if (i->second != second.size()) { n         cout << -1; n         return 0; n       } n     } n     for (auto i = not_third.begin(); i != not_third.end(); i++) { n       if (i->second != third.size()) { n         cout << -1; n         return 0; n       } n     } n     vector<int> cols(n + 1, 0); n     for (auto i = first.begin(); i != first.end(); i++) { n       cols[*i] = 1; n     } n     for (auto i = second.begin(); i != second.end(); i++) { n       cols[*i] = 2; n     } n     for (auto i = third.begin(); i != third.end(); i++) { n       cols[*i] = 3; n     } n     for (int i = 1; i < n + 1; i++) { n       cout << cols[i] <<    ; n     } n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n #pragma GCC optimization( unroll-loops ) n #pragma GCC optimize( Ofast ) n #pragma GCC target( sse,sse2,sse3,ssse3,sse4 ) n using namespace std; n const int BASE = 1000000; n char what[1 << 20]; n pair<int, int> nxt[10][1 << 20]; n pair<long long, int> to[10][10]; n inline long long Calc(long long x) { n   long long suff = x / BASE, pref = x % BASE; n   long long ans = suff; n   while (suff > 0) { n     ans += nxt[what[suff]][pref].first; n     pref = nxt[what[suff]][pref].second; n     pref += BASE - max(what[suff], what[pref]); n     --suff; n   } n   return ans + nxt[0][pref].first; n } n inline long long Process(long long x) { n   long long suff = x / (1LL * BASE * BASE), psuff = x / BASE % BASE, n             pref = x % BASE; n   if (suff == 0) { n     return Calc(x); n   } n   long long ans = 0; n   while (psuff >= 0) { n     ans += nxt[max(what[psuff], what[suff])][pref].first + 1; n     pref = nxt[max(what[psuff], what[suff])][pref].second; n     pref += BASE - max(what[psuff], max(what[suff], what[pref])); n     --psuff; n   } n   --suff; n   while (suff > 0) { n     ans += to[what[suff]][BASE - pref].first; n     pref = to[what[suff]][BASE - pref].second; n     --suff; n   } n   return ans + Calc(1LL * (BASE - 1) * BASE + pref); n } n int main() { n   for (int i = 1; i <= BASE; ++i) { n     what[i] = i % 10 > what[i / 10] ? i % 10 : what[i / 10]; n     for (int d = 0; d < 10; ++d) { n       char r = what[i] < d ? d : what[i]; n       if (i >= r) { n         nxt[d][i] = make_pair(nxt[d][i - r].first + 1, nxt[d][i - r].second); n       } else { n         nxt[d][i] = make_pair(0, i); n       } n     } n   } n   for (char d = 1; d < 10; ++d) { n     for (int l = 0; l < 10; ++l) { n       int suff = BASE - 1, pref = BASE - l; n       to[d][l].first = BASE; n       while (suff >= 0) { n         char r = (d < what[suff] ? what[suff] : d); n         to[d][l].first += nxt[r][pref].first; n         pref = nxt[r][pref].second; n         pref += BASE - (r < what[pref] ? what[pref] : r); n         --suff; n       } n       to[d][l].second = pref; n     } n   } n   long long n; n   cin >> n; n   cout << Process(n) <<   n ; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n const int MAXN = 200000 + 10; n const int INF = 0x7fffffff; n using namespace std; n struct EDGE { n   int u, v, w; n   bool operator<(const EDGE &b) const { return w > b.w; } n }; n int fa[MAXN + MAXN]; n int n, m, vis[MAXN]; n int Min[MAXN]; n vector<EDGE> edge; n int Find(int x) { return fa[x] < 0 ? x : fa[x] = Find(fa[x]); } n int main() { n   edge.clear(); n   scanf( %d%d , &n, &m); n   memset(fa, -1, sizeof(fa)); n   memset(vis, 0, sizeof(vis)); n   for (int i = 1; i <= m; i++) { n     int a, b, w; n     scanf( %d%d%d , &a, &b, &w); n     edge.push_back((EDGE){a, b, w}); n   } n   sort(edge.begin(), edge.end()); n   long long Ans = 0ll; n   for (int i = 0; i < m; i++) { n     int u = edge[i].u, v = edge[i].v; n     u = Find(u); n     v = Find(v); n     if (u == v) { n       if (fa[u] == -2) continue; n       fa[u] = -2; n       Ans += (long long)edge[i].w; n       continue; n     } n     if (fa[u] == -2 && fa[v] == -2) continue; n     fa[v] = min(fa[v], fa[u]); n     Ans += (long long)edge[i].w; n     fa[u] = v; n   } n   printf( %lld n , Ans); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int intervalo[200010]; n int aparicoes[200010]; n int aceito[200010]; n int main() { n   int n, k, q; n   cin >> n >> k >> q; n   int l, r; n   for (int i = 0; i < n; i++) { n     cin >> l >> r; n     intervalo[l] += 1; n     intervalo[r + 1] -= 1; n   } n   int x = 0; n   for (int i = 1; i <= 200000; i++) { n     x += intervalo[i]; n     aparicoes[i] = x; n   } n   for (int i = 1; i <= 200000; i++) { n     if (aparicoes[i] >= k) n       aceito[i] = 1; n     else n       aceito[i] = 0; n     aceito[i] += aceito[i - 1]; n   } n   for (int i = 0; i < q; i++) { n     cin >> l >> r; n     cout << aceito[r] - aceito[l - 1] << endl; n   } n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int main() { n   string a, b; n   cin >> a; n   b = a; n   for (string::reverse_iterator itr = a.rbegin(); itr != a.rend(); itr++) n     b += *itr; n   cout << b << endl; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n using lint = long long; n const int inf = 1000000007; n const int MOD = 1000000007; n int f(int x) { n   int res = 0; n   while (x > 0) { n     res += x % 10; n     x /= 10; n   } n   return res; n } n bool calc(int n, int k) { n   int sm = 0; n   for (int i = 0; i < k; ++i) { n     sm += f(i); n   } n   for (int i = k; i <= 100000; ++i) { n     sm += f(i); n     if (sm == n) { n       cout << i - k <<   n ; n       return true; n     } n     sm -= f(i - k); n   } n   if (n <= 45) { n     cout << -1 <<   n ; n     return true; n   } n   return false; n } n void solve() { n   int n, k; n   cin >> n >> k; n   if (calc(n, k)) return; n   n -= k * (k + 1) / 2; n   if (n < 0) { n     cout << -1 <<   n ; n     return; n   } n   int top = 0; n   string mid; n   int last = 0; n   int cnt = 0; n   while (n % (k + 1) != 0) { n     n += 9; n     cnt++; n     if (cnt > 9) { n       cout << -1 <<   n ; n       return; n     } n   } n   if (n - cnt * 9 < (k - cnt) * 9) { n     cout << -1 <<   n ; n     return; n   } n   last = 9 - (k - cnt); n   n /= (k + 1); n   n -= last; n   while (n > 9) { n     n -= 9; n     mid +=  9 ; n   } n   top = n; n   if (cnt > 0) { n     int l = mid.length(); n     if (l != 0) { n       mid[l - 1] =  8 ; n       top++; n     } n   } n   string hoge; n   while (top > 9) { n     top -= 9; n     hoge +=  9 ; n   } n   if (top > 0) cout << top; n   cout << hoge << mid << last <<   n ; n } n signed main() { n   int t; n   cin >> t; n   for (int i = 0; i < t; ++i) solve(); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n #pragma GCC optimize( O3,no-stack-protector,unroll-loops,fast-math ) n using namespace std; n struct coor { n   long long x, y, x1, y1; n }; n vector<struct coor> v; n struct coor ldp[200005], rdp[200005]; n struct coor inter(struct coor l, struct coor r) { n   struct coor res = {INT_MIN, INT_MIN, INT_MIN, INT_MIN}; n   if (min(l.x1, r.x1) < max(r.x, l.x) || min(l.y1, r.y1) < max(r.y, l.y)) n     return res; n   res.x = max(l.x, r.x); n   res.x1 = min(l.x1, r.x1); n   res.y = max(l.y, r.y); n   res.y1 = min(l.y1, r.y1); n   return res; n } n bool check(struct coor l) { return (l.x != INT_MIN); } n int main() { n   ios_base::sync_with_stdio(false); n   cin.tie(NULL); n   cout.tie(NULL); n   long long a = 0, b = 0, c, d, e, f = 0, l, g, m, n, k, i, j, t, p, q; n   cin >> n; n   for (i = 0; i < n; i++) { n     cin >> a >> b >> c >> d; n     v.push_back({a, b, c, d}); n   } n   ldp[0] = v[0]; n   for (i = 1; i < n; i++) { n     ldp[i] = inter(ldp[i - 1], v[i]); n   } n   rdp[n - 1] = v[n - 1]; n   for (i = n - 2; i >= 0; i--) { n     rdp[i] = inter(rdp[i + 1], v[i]); n   } n   if (check(ldp[n - 2])) { n     cout << ldp[n - 2].x <<     << ldp[n - 2].y <<   n ; n   } else if (check(rdp[1])) { n     cout << rdp[1].x <<     << rdp[1].y <<   n ; n   } else { n     for (i = 1; i < n - 1; i++) { n       struct coor fin = inter(ldp[i - 1], rdp[i + 1]); n       if (check(fin)) { n         cout << fin.x <<     << fin.y <<   n ; n         return 0; n       } n     } n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int main() { n   int t, n, a, b, c, d; n   cin >> t; n   while (t--) { n     cin >> n >> a >> b >> c >> d; n     int mi = (a - b) * n, ma = (a + b) * n; n     if ((mi > c + d) || (ma < c - d)) n       cout <<  NO  << endl; n     else n       cout <<  YES  << endl; n   } n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n #pragma GCC optimize( Ofast ) n using namespace std; n const long long mod = 1000000007; n void solve() { n   int n, m, u, v; n   cin >> n >> m; n   vector<int> adj[n + 1]; n   for (int i = 0; i < m; i++) { n     cin >> u >> v; n     adj[u].push_back(v); n     adj[v].push_back(u); n   } n   vector<pair<long long, long long> > hash, hash_orig; n   hash.reserve(n); n   long long p1 = 31, p2 = 53, h1, h2; n   long long pow_p1[n + 1], pow_p2[n + 1]; n   pow_p1[0] = pow_p2[0] = 1; n   for (int i = 1; i <= n; i++) { n     pow_p1[i] = pow_p1[i - 1] * p1 % mod; n     pow_p2[i] = pow_p2[i - 1] * p2 % mod; n   } n   for (int i = 1; i <= n; i++) { n     h1 = 0; n     h2 = 0; n     for (int &j : adj[i]) { n       h1 += pow_p1[j]; n       h2 += pow_p2[j]; n     } n     hash.push_back({h1, h2}); n   } n   hash_orig = hash; n   sort((hash).begin(), (hash).end()); n   long long ans = 0; n   int cnt = 1; n   for (int i = 1; i < n; i++) { n     if (hash[i] != hash[i - 1]) { n       ans += 1ll * cnt * (cnt - 1) / 2; n       cnt = 1; n     } else n       cnt++; n   } n   ans += 1ll * cnt * (cnt - 1) / 2; n   for (int i = 1; i <= n; i++) { n     hash_orig[i - 1].first += pow_p1[i]; n     hash_orig[i - 1].second += pow_p2[i]; n   } n   for (int i = 1; i <= n; i++) { n     for (int &j : adj[i]) { n       if (j < i || adj[i].size() != adj[j].size()) continue; n       if (hash_orig[i - 1] == hash_orig[j - 1]) ans++; n     } n   } n   cout << ans <<   n ; n } n signed main() { n   ios_base::sync_with_stdio(false); n   cin.tie(NULL); n   cout.tie(NULL); n   int t = 1; n   while (t--) { n     solve(); n   } n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n using namespace std; n typedef long long int ll; n typedef unsigned long long int ull; n inline void smax(int &x, int y) { x = max(x, y); } n inline void smin(int &x, int y) { x = min(x, y); } n ll gcd(ll a, ll b) { return ((b == 0) ? a : gcd(b, a % b)); } n const double PI = acos(-1.0l); n vector<long long> rev; n vector<complex<double> > omega; n void calc_rev(long long n, long long log_n) { n   rev.resize(n); n   omega.resize(n); n   for (long long i = 0; i < n; i++) { n     rev[i] = 0; n     for (long long j = 0; j < log_n; j++) { n       if ((i >> j) & 1) rev[i] |= 1 << (log_n - j - 1); n     } n   } n } n void fft(vector<complex<double> > &A, long long n, bool invert) { n   for (long long i = 0; i < n; i++) { n     if (i < rev[i]) swap(A[i], A[rev[i]]); n   } n   for (long long len = 2; len <= n; len <<= 1) { n     double ang = 2 * PI / len * (invert ? -1 : +1); n     long long half = (len >> 1); n     complex<double> curomega(cos(ang), sin(ang)); n     omega[0] = complex<double>(1, 0); n     for (long long i = 1; i < half; i++) omega[i] = omega[i - 1] * curomega; n     for (long long i = 0; i < n; i += len) { n       complex<double> t; n       long long pu = i, pv = i + half, pu_end = i + half, pw = 0; n       for (; pu != pu_end; pu++, pv++, pw++) { n         t = A[pv] * omega[pw]; n         A[pv] = A[pu] - t; n         A[pu] += t; n       } n     } n   } n   if (invert) n     for (long long i = 0; i < n; i++) A[i] /= n; n } n void multiply(long long n, vector<complex<double> > &A, n               vector<complex<double> > &B, vector<long long> &C) { n   fft(A, n, false); n   fft(B, n, false); n   for (long long i = 0; i < n; i++) A[i] *= B[i]; n   fft(A, n, true); n   for (long long i = 0; i < n; i++) { n     C[i] = (long long)(A[i].real() + 0.5); n     C[i] = min(C[i], 1LL); n   } n } n void Solve(long long n, vector<long long> &coeffA, vector<long long> &coeffB, n            vector<long long> &result) { n   vector<complex<double> > A(n), B(n); n   for (long long i = 0; i < n; i++) A[i] = coeffA[i]; n   for (long long i = 0; i < n; i++) B[i] = coeffB[i]; n   multiply(n, A, B, result); n } n void do_FFT(vector<long long> &A, vector<long long> &B, n             vector<long long> &result) { n   long long n = 1, bits = 0; n   while (n < 2 * A.size() || n < 2 * B.size()) n <<= 1, bits++; n   result.resize(n, 0); n   calc_rev(n, bits); n   vector<long long> tempA(A.begin(), A.end()); n   vector<long long> tempB(B.begin(), B.end()); n   tempA.resize(n); n   tempB.resize(n); n   Solve(n, tempA, tempB, result); n } n vector<ll> polpow(vector<ll> &arr, long long k) { n   vector<ll> sol; n   while (k > 0) { n     if (k % 2) { n       if (sol.size() == 0) n         for (__typeof(arr.size()) i = (0) - ((0) > (arr.size())); n              i != (arr.size()) - ((0) > (arr.size())); n              i += 1 - 2 * ((0) > (arr.size()))) n           sol.push_back(arr[i]); n       else n         do_FFT(sol, arr, sol); n     } n     do_FFT(arr, arr, arr); n     k = k / 2; n   } n   return sol; n } n int32_t main() { n   long long n, k; n   cin >> n >> k; n   vector<long long> v(n); n   for (__typeof(n) i = (0) - ((0) > (n)); i != (n) - ((0) > (n)); n        i += 1 - 2 * ((0) > (n))) n     cin >> v[i]; n   vector<ll> arr(1001); n   for (__typeof(n) i = (0) - ((0) > (n)); i != (n) - ((0) > (n)); n        i += 1 - 2 * ((0) > (n))) { n     arr[v[i]] = 1; n   } n   while (arr.back() == 0) { n     arr.pop_back(); n   } n   vector<ll> res = polpow(arr, k); n   for (__typeof(res.size()) i = (1) - ((1) > (res.size())); n        i != (res.size()) - ((1) > (res.size())); n        i += 1 - 2 * ((1) > (res.size()))) { n     if (res[i] > 0) cout << i <<    ; n   } n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int main() { n   int n, m = 0; n   cin >> n; n   int last; n   for (int(i) = 0; (i) < (n); ++(i)) { n     cin >> last; n     m += last; n   } n   cout << ((n - m == 1 && n > 1) || (n == 1 && m == 1) ?  YES n  :  NO n ); n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int n, k, trie[100100][27], sz = 1, ok[2][100100]; n char s[100100]; n void add() { n   int v = 0; n   for (int i = 0; s[i] !=   0 ; i++) { n     if (trie[v][s[i] -  a ] == 0) trie[v][s[i] -  a ] = sz++; n     v = trie[v][s[i] -  a ]; n   } n } n void calc(int v, bool bo, int temp[30]) { n   int arr[5]; n   for (int i = 0; i < 5; i++) arr[i] = 0; n   for (int i = 0; i < 26; i++) { n     if (temp[i] == -1) continue; n     if (temp[i] == 0) { n       ok[bo][v] = 0; n       break; n     } n     if (temp[i] == 1) { n       if (arr[2]) { n         ok[bo][v] = 0; n         break; n       } n     } n     if (temp[i] == 2) { n       if (arr[1]) { n         ok[bo][v] = 0; n         break; n       } n     } n     arr[temp[i]]++; n   } n   if (ok[bo][v] != 0) n     ok[bo][v] = (arr[3] && !arr[1] && !arr[2] ? 3 : (arr[1] ? 1 : 2)); n } n int dfs(int v, bool st, bool bo) { n   int cnt = 0, temp[26]; n   for (int i = 0; i < 26; i++) temp[i] = -1; n   for (int i = 0; i < 26; i++) { n     if (!trie[v][i]) continue; n     cnt++; n     temp[i] = dfs(trie[v][i], !st, bo); n     if (temp[i] == 1) n       ok[bo][v] = (ok[bo][v] < 2 ? 1 : 3); n     else if (temp[i] == 2) n       ok[bo][v] = (ok[bo][v] == 2 || ok[bo][v] == 0 ? 2 : 3); n     else if (temp[i] == 3) n       ok[bo][v] = 3; n   } n   if (cnt > 1 && !st && !bo) calc(v, bo, temp); n   if (cnt > 1 && st && bo) calc(v, bo, temp); n   if (cnt == 0) ok[bo][v] = (st ? 2 : 1); n   return ok[bo][v]; n } n int main() { n   scanf( %d%d , &n, &k); n   for (int i = 0; i < n; i++) { n     scanf( %s , &s); n     add(); n   } n   dfs(0, 1, 0); n   dfs(0, 1, 1); n   if (ok[0][0] == 3) n     printf( First n ); n   else if (ok[0][0] == 1) { n     if (k % 2) n       printf( First n ); n     else n       printf( Second n ); n   } else if (ok[0][0] == 2) n     printf( Second n ); n   else { n     if (ok[1][0] == 3) n       printf( Second n ); n     else if (ok[1][0] == 1) { n       if (k % 2) n         printf( First n ); n       else n         printf( Second n ); n     } else if (ok[1][0] == 2) n       printf( Second n ); n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int N = 1e5 + 5; n int t, id, n, m, x, y, k, c, p, dif, ans, sum, pre, rem, cur, tmp, tot, r, l, u, n     d, xx, yy; n int a[N], vis[N], f[N], b[N], cu[N]; n vector<int> v, adj[N]; n bool fl, ok; n int dp[N]; n int mem[N]; n int sol(int i = n) { n   int &ret = mem[i]; n   if (~ret) return ret; n   if (!i) return ret = 0; n   ret = sol(i - 1) + 20; n   int B90 = upper_bound(a + 1, a + n + 1, a[i] - 90) - (a + 1); n   ret = min(ret, sol(B90) + 50); n   int Bday = upper_bound(a + 1, a + n + 1, a[i] - 1440) - (a + 1); n   ret = min(ret, sol(Bday) + 120); n   return ret; n } n int main() { n   scanf( %d , &n); n   for (int i = 1; i <= (int)n; ++i) scanf( %d , &a[i]); n   memset(mem, -1, sizeof mem); n   ; n   sol(); n   for (int i = 1; i <= (int)n; ++i) printf( %d n , sol(i) - sol(i - 1)); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int mod = 1e9 + 7; n char maz[505][505]; n int dp[10][505][505]; n inline void cm(int& x) { n   if (x >= mod) x -= mod; n } n int main() { n   int n, m; n   scanf( %d%d , &n, &m); n   for (int i = 1; i <= n; ++i) scanf( %s , maz[i] + 1); n   int up = (n + m - 1) / 2; n   if (maz[1][1] != maz[n][m]) { n     puts( 0 ); n     return 0; n   } n   dp[0][1][m] = 1; n   for (int i = 0; i < up; ++i) { n     int ni = (i + 1) & 1, li = i & 1; n     memset(dp[ni], 0, sizeof(dp[ni])); n     for (int j = 1; j <= m; ++j) { n       int y1 = i + 2 - j; n       if (y1 < 1 || y1 > n) continue; n       for (int k = m; k >= 1; --k) { n         int y2 = n + m - i - k; n         if (y2 < 1 || y2 > n || maz[y1][j] != maz[y2][k]) continue; n         if (y1 < n && y2 > 1 && maz[y1 + 1][j] == maz[y2 - 1][k]) n           dp[ni][j][k] += dp[li][j][k]; n         if (y1 < n && k > 1 && maz[y1 + 1][j] == maz[y2][k - 1]) n           dp[ni][j][k - 1] += dp[li][j][k]; n         if (j < m && y2 > 1 && maz[y1][j + 1] == maz[y2 - 1][k]) n           dp[ni][j + 1][k] += dp[li][j][k]; n         if (j < m && k > 1 && maz[y1][j + 1] == maz[y2][k - 1]) n           dp[ni][j + 1][k - 1] += dp[li][j][k]; n         cm(dp[ni][j][k]); n         cm(dp[ni][j][k - 1]); n         cm(dp[ni][j + 1][k]); n         cm(dp[ni][j + 1][k - 1]); n       } n     } n   } n   int ans = 0; n   if ((n + m - 1) % 2) { n     for (int i = 1; i <= n; ++i) { n       ans += dp[up & 1][up + 2 - i][up + 2 - i]; n       cm(ans); n     } n   } else { n     up--; n     for (int i = 1; i <= n; ++i) { n       ans += dp[up & 1][up + 2 - i][up + 3 - i]; n       cm(ans); n       ans += dp[up & 1][up + 2 - i][up + 2 - i]; n       cm(ans); n     } n   } n   printf( %d n , ans); n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n void task(); n int main() { n   task(); n   return 0; n } n const int N = 2e5 + 10; n const long long int MOD = (long long int)1e9 + 7; n const int INF = 0x3f3f3f3f; n const long long int LINF = (long long int)4e18 + 100; n const int BUF_SIZE = (int)1e6 + 10; n const double PI = acos(-1); n pair<int, int> a[N]; n double u[N], ad[N], bd[N]; n long long int sq_dist(long long int x1, long long int y1, long long int x2, n                       long long int y2) { n   return (x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2); n } n double dist(long long int x1, long long int y1, long long int x2, n             long long int y2) { n   return sqrt(sq_dist(x1, y1, x2, y2)); n } n double dp[N][2][2]; n void task() { n   int ai, aj, bi, bj, ui, uj; n   cin >> ai >> aj >> bi >> bj >> ui >> uj; n   int n; n   cin >> n; n   for (int i = 0; i < n; ++i) { n     cin >> a[i].first >> a[i].second; n   } n   for (int i = 0; i < n; ++i) { n     u[i] = dist(ui, uj, a[i].first, a[i].second); n     (void(1)); n     ; n   } n   for (int i = 0; i < n; ++i) { n     ad[i] = dist(ai, aj, a[i].first, a[i].second) + u[i]; n     (void(1)); n     ; n   } n   for (int i = 0; i < n; ++i) { n     bd[i] = dist(bi, bj, a[i].first, a[i].second) + u[i]; n     (void(1)); n     ; n   } n   fill(dp[0][0], dp[0][0] + N * 2 * 2, LINF); n   dp[0][1][1] = 0; n   for (int i = 0; i < n; ++i) { n     for (int j = 0; j < 2; ++j) { n       for (int k = 0; k < 2; ++k) { n         (void(1)); n         ; n         if (j == 1) { n           dp[i + 1][j - 1][k] = min(dp[i][j][k] + ad[i], dp[i + 1][j - 1][k]); n         } n         if (k == 1) { n           dp[i + 1][j][k - 1] = min(dp[i][j][k] + bd[i], dp[i + 1][j][k - 1]); n         } n         dp[i + 1][j][k] = min(dp[i + 1][j][k], dp[i][j][k] + 2 * u[i]); n       } n     } n   } n   double ans = LINF; n   for (int i = 0; i < 2; ++i) { n     for (int j = 0; j < 2; ++j) n       if (!(i == 1 && j == 1)) { n         (void(1)); n         ; n         ans = min(ans, dp[n][i][j]); n       } n   } n   cout << fixed << setprecision(12) << ans; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int main() { n   int t; n   cin >> t; n   while (t--) { n     int n; n     cin >> n; n     int f = 1; n     int s = 0; n     vector<int> A; n     for (int i = 0; i < n; i++) { n       int a; n       cin >> a; n       A.push_back(a); n     } n     if (A.size() == 1) { n       cout <<  First  << endl; n       continue; n     } n     if (n == 2) { n       if (A[0] != 1) { n         cout <<  First  << endl; n         continue; n       } else { n         cout <<  Second  << endl; n         continue; n       } n     } n     for (int i = 0; i < n - 2; i++) { n       if (A[i] != 1 && A[i + 1] != 1) { n         if (f == 1) { n           f = 1; n           s = 0; n         } else { n           s = 1; n           f = 0; n         } n       } else if (A[i] != 1 && A[i + 1] == 1) { n         int count = 0; n         int j = i + 1; n         while (A[j] == 1 && j <= n - 2) { n           count++; n           j++; n         } n         if (count % 2 == 1) { n           if (f == 1) { n             s = 1; n             f = 0; n           } else { n             f = 1; n             s = 0; n           } n         } else { n           if (f == 1) { n             f = 1; n             s = 0; n           } else { n             s = 1; n             f = 0; n           } n         } n       } else if (A[i] == 1) { n         if (f == 1) { n           s = 1; n           f = 0; n         } else { n           f = 1; n           s = 0; n         } n       } n     } n     if (A[n - 2] != 1 && f == 1) { n       cout <<  First  << endl; n       continue; n     } else if (A[n - 2] == 1 && f == 1) { n       cout <<  Second  << endl; n       continue; n     } else if (A[n - 2] != 1 && s == 1) { n       cout <<  Second  << endl; n       continue; n     } else if (A[n - 2] == 1 && s == 1) { n       cout <<  First  << endl; n       continue; n     } n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int maxn = 500100; n multiset<pair<long long, long long> > intervals; n long long n, k; n int main() { n   ios_base::sync_with_stdio(false); n   cin.tie(0); n   cin >> n >> k; n   for (int i = 0; i < k; i++) intervals.insert(make_pair(0, i)); n   long long s, d; n   for (int i = 0; i < n; i++) { n     cin >> s >> d; n     auto x = intervals.begin(); n     long long stx = (*x).first; n     long long idx = (*x).second; n     if (stx < s) stx = s; n     stx += d; n     cout << stx <<   n ; n     intervals.erase(x); n     intervals.insert(make_pair(stx, idx)); n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n struct node { n   int x, y; n }; n vector<node> q; n int n, m, sum[2020][2020]; n char g[2020][2020]; n void init() { n   for (int i = 0; i < (n); i++) n     for (int j = 0; j < (m); j++) n       if (g[i][j] ==  w ) q.push_back((node){i, j}); n   for (int i = 0; i < (n); i++) n     for (int j = 0; j < (m); j++) n       if (g[i][j] ==  w ) sum[i][j] = 1; n   for (int i = 0; i < (n); i++) n     for (int j = 0; j < (m); j++) n       if (j - 1 >= 0) sum[i][j] = sum[i][j - 1] + sum[i][j]; n   for (int i = 0; i < (m); i++) n     for (int j = 0; j < (n); j++) n       if (j - 1 >= 0) sum[j][i] = sum[j - 1][i] + sum[j][i]; n } n bool cmpx(node a, node b) { return a.x < b.x; } n bool cmpy(node a, node b) { return a.y < b.y; } n int getlen() { n   int res = -1; n   sort(q.begin(), q.end(), cmpx); n   res = max(res, abs(q[0].x - q[q.size() - 1].x) + 1); n   sort(q.begin(), q.end(), cmpy); n   res = max(res, abs(q[0].y - q[q.size() - 1].y) + 1); n   return res; n } n int getarea(int x1, int y1, int x2, int y2) { n   if (x1 > x2 || y1 > y2) return 0; n   int res = sum[x2][y2]; n   if (x1 - 1 >= 0) res -= sum[x1 - 1][y2]; n   if (y1 - 1 >= 0) res -= sum[x2][y1 - 1]; n   if (x1 - 1 >= 0 && y1 - 1 >= 0) res += sum[x1 - 1][y1 - 1]; n   return res; n } n bool check(int x, int y, int len) { n   int x2 = x - len + 1; n   int y2 = y - len + 1; n   int in = getarea(x2 + 1, y2 + 1, x - 1, y - 1); n   int out = getarea(0, 0, n - 1, m - 1) - getarea(x2, y2, x, y); n   if (in || out) n     return false; n   else n     return true; n } n void filling(int x, int y, int x2, int y2) { n   for (int i = x; i <= x2; i++) n     for (int j = y; j <= y2; j++) n       if (i == x || i == x2 || j == y || j == y2) n         g[i][j] = (g[i][j] ==  . ) ?  +  :  w ; n } n int main() { n   scanf( %d%d , &n, &m); n   for (int i = 0; i < (n); i++) scanf( %s , g[i]); n   init(); n   int len = getlen(); n   bool flg = 0; n   for (int i = 0; i < (n); i++) n     for (int j = 0; j < (m); j++) n       if (i + 1 >= len && j + 1 >= len) { n         if (flg) break; n         if (check(i, j, len)) { n           flg = true; n           filling(i - len + 1, j - len + 1, i, j); n           break; n         } n       } n   if (flg) n     for (int i = 0; i < (n); i++) printf( %s n , g[i]); n   else n     printf( -1 n ); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n template <class T, class U> n void maximize(T &x, U y) { n   if (x < y) x = y; n } n template <class T, class U> n void minimize(T &x, U y) { n   if (x > y) x = y; n } n template <class T> n T Abs(T x) { n   return (x < (T)0 ? -x : x); n } n template <class T> n T safe_sqrt(T x) { n   return sqrt(max((T)0, x)); n } n template <class T, class U, class V> n T addmod(T x, U k, V mod) { n   return ((x + k) % mod + mod) % mod; n } n template <class T, class U, class V> n T submod(T x, U k, V mod) { n   return ((x - k) % mod + mod) % mod; n } n template <class T, class U, class V> n T mulmod(T x, U k, V mod) { n   return (int64_t)x * k % mod; n } n namespace task { n int64_t dp[11][100][1200]; n int b; n int64_t l, r; n vector<int> digits; n vector<int> trans(int64_t x, int b) { n   vector<int> vec; n   while (x > 0) vec.push_back(x % b), x /= b; n   return vec; n } n int64_t calc(int base, int idx, int mask, bool flag) { n   if (idx == -1) return (mask == 0); n   if (~dp[base][idx][mask] and flag) return dp[base][idx][mask]; n   int64_t ret = 0; n   int k = flag ? b - 1 : digits[idx]; n   for (int i = 0; i <= k; ++i) n     ret += calc(base, idx - 1, mask ^ ((1LL) << (i)), flag | (i < k)); n   if (flag) dp[base][idx][mask] = ret; n   return ret; n } n int64_t f(int64_t x) { n   if (!x) return 0ll; n   digits.clear(); n   digits = trans(x, b); n   int64_t ret = 0; n   for (int i = 0; i < ((digits).size()); ++i) { n     int up = (i == ((digits).size()) - 1 ? digits[i] : b - 1); n     for (int j = 1; j <= up; ++j) n       ret += n           calc(b, i - 1, ((1LL) << (j)), (i < ((digits).size()) - 1 or j < up)); n   } n   return ret; n } n void solve() { n   int q; n   scanf( %d , &q); n   memset(dp, -1ll, sizeof(dp)); n   while (q--) { n     scanf( %d%I64d%I64d , &b, &l, &r); n     int64_t x = f(r); n     int64_t y = f(l - 1); n     int64_t ans = f(r) - f(l - 1); n     printf( %I64d n , ans); n   } n } n }  // namespace task n int main(void) { task::solve(); } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int n, a[1050]; n int main() { n   cin >> n; n   for (int i = 0; i < n; i++) cin >> a[i]; n   int tens = a[0]; n   set<int> answer; n   for (int rem = 0; rem < 10000000; rem++) { n     double fuel = tens * 10 + static_cast<double>(rem) / 1000000; n     double addend = fuel; n     bool isValid = true; n     for (int i = 0; isValid and i < n; i++) { n       fuel -= (a[i] - (i == 0 ? 0 : a[i - 1])) * 10; n       if (fuel < 0 or fuel >= 10 - 1e-6) { n         isValid = false; n       } n       fuel += addend; n     } n     if (isValid) { n       answer.insert(static_cast<int>(fuel) / 10 + a[n - 1]); n     } n   } n   if (answer.size() > 1) n     cout <<  not unique  << endl; n   else n     cout <<  unique  << endl << *answer.begin() << endl; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int MAXN = (int)2e5 + 10; n vector<pair<int, int> > a, b; n vector<int> L; n int n, m, q[MAXN], id[MAXN], Tohka[MAXN], l[MAXN], r[MAXN], t[MAXN], fa[MAXN], n     T[MAXN]; n bool cmp(int first, int second) { return q[first] < q[second]; } n bool cmp1(int first, int second) { return t[first] < t[second]; } n int Getp(int a) { return lower_bound(L.begin(), L.end(), a) - L.begin(); } n int getf(int first) { n   if (fa[first] == first) return first; n   fa[first] = getf(fa[first]); n   return fa[first]; n } n int main() { n   scanf( %d%d , &n, &m); n   for (int i = 1; i <= m; ++i) { n     scanf( %d%d%d , &l[i], &r[i], &t[i]); n     L.push_back(l[i]), L.push_back(r[i]); n     id[i] = i; n   } n   sort(L.begin(), L.end()); n   L.erase(unique(L.begin(), L.end()), L.end()); n   for (int i = 0; i < ((int)(L).size()); ++i) fa[i] = i; n   sort(id + 1, id + m + 1, cmp1); n   memset(T, -1, sizeof(T)); n   for (int i = 1; i <= m; ++i) { n     int tl = Getp(l[id[i]]), tr = Getp(r[id[i]]), tT = t[id[i]]; n     for (tl = getf(tl); tl < tr; T[tl] = tT, fa[tl] = tl + 1, tl = getf(tl)) n       ; n   } n   for (int i = 0; i + 1 < ((int)(L).size()); ++i) { n     int l = L[i], r = L[i + 1], t = T[i]; n     if (T[i] == -1) continue; n     a.push_back(make_pair(t - r, 1)), a.push_back(make_pair(t - l, -1)); n     b.push_back(make_pair(t - r, -(t - r))), n         b.push_back(make_pair(t - l, (t - r))); n     b.push_back(make_pair(t - l, (r - l))); n   } n   sort(a.begin(), a.end()); n   sort(b.begin(), b.end()); n   for (int i = 1; i <= n; ++i) scanf( %d , &q[i]), id[i] = i; n   sort(id + 1, id + n + 1, cmp); n   long long s1 = 0, s2 = 0; n   for (int i = 1, p1 = 0, p2 = 0; i <= n; ++i) { n     for (; p1 < ((int)(a).size()) && a[p1].first <= q[id[i]]; n          s1 += a[p1].second, ++p1) n       ; n     for (; p2 < ((int)(b).size()) && b[p2].first <= q[id[i]]; n          s2 += b[p2].second, ++p2) n       ; n     Tohka[id[i]] = s1 * q[id[i]] + s2; n   } n   for (int i = 1; i <= n; ++i) printf( %d n , Tohka[i]); n   fclose(stdin); n   fclose(stdout); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int main() { n   int n, m, q; n   scanf( %d %d %d , &n, &m, &q); n   int log_n = 0; n   while (1 << log_n <= n) { n     ++log_n; n   } n   int jump_small = pow(n, 1.0 / 3), jump_large = pow(n, 2.0 / 3); n   vector<vector<int>> rmq_min(log_n, vector<int>(n)), n       rmq_max(log_n, vector<int>(n)); n   vector<int> a(n), next(n), jump(n), times(n), now_min(n), now_max(n); n   priority_queue<pair<int, int>> heap; n   for (int i = 0; i < n; ++i) { n     scanf( %d , &a[i]); n     rmq_min[0][i] = rmq_max[0][i] = a[i]; n     next[i] = i + 1; n     jump[i] = min(i + jump_small, n); n     times[i] = jump[i] - i; n   } n   for (int i = 0; i < n - 1; ++i) { n     now_min[i] = min(a[i], a[i + 1]); n     now_max[i] = max(a[i], a[i + 1]); n     heap.push(make_pair(now_min[i] - now_max[i], i)); n   } n   for (int i = 1; i < log_n; ++i) { n     for (int j = 0; j + (1 << i) <= n; ++j) { n       rmq_min[i][j] = min(rmq_min[i - 1][j], rmq_min[i - 1][j + (1 << i - 1)]); n       rmq_max[i][j] = max(rmq_max[i - 1][j], rmq_max[i - 1][j + (1 << i - 1)]); n     } n   } n   vector<int> last(n); n   vector<bool> visit(n); n   auto update = [&](int x, int limit) { n     while (next[x] < n && next[x] - x <= jump_large && n            now_max[x] - now_min[x] <= limit) { n       ++next[x]; n       if (next[x] < n) { n         now_max[x] = max(now_max[x], a[next[x]]); n         now_min[x] = min(now_min[x], a[next[x]]); n       } n     } n     if (next[x] < n && next[x] - x <= jump_small) { n       heap.push(make_pair(now_min[x] - now_max[x], x)); n     } n     vector<int> stack; n     jump[x] = x; n     times[x] = 0; n     stack.push_back(jump[x]); n     while (jump[x] < n && next[jump[x]] - x <= jump_small) { n       jump[x] = next[jump[x]]; n       ++times[x]; n       stack.push_back(jump[x]); n     } n     last[x] = stack.size(); n     visit[x] = true; n     for (int i = x - 1; i >= x - jump_small && ~i; --i) { n       if (next[i] < n && visit[next[i]]) { n         while (stack.back() - i > jump_small) { n           stack.pop_back(); n         } n         jump[i] = stack.back(); n         times[i] = times[next[i]] + 1 + stack.size() - last[next[i]]; n         last[i] = stack.size(); n         visit[i] = true; n       } n     } n     for (int i = x; i >= x - jump_small && ~i; --i) { n       visit[i] = false; n     } n   }; n   auto query = [&](int limit) { n     while (!heap.empty() && -heap.top().first <= limit) { n       int x = heap.top().second; n       heap.pop(); n       update(x, limit); n     } n     int answer = -1, x = 0; n     while (x < n) { n       int dist = next[x] - x; n       if (dist <= jump_small) { n         answer += times[x]; n         x = jump[x]; n       } else { n         while (next[x] < n && next[x] - x <= jump_large && n                now_max[x] - now_min[x] <= limit) { n           ++next[x]; n           if (next[x] < n) { n             now_max[x] = max(now_max[x], a[next[x]]); n             now_min[x] = min(now_min[x], a[next[x]]); n           } n         } n         dist = next[x] - x; n         if (dist <= jump_large) { n           ++answer; n           x = next[x]; n         } else { n           ++answer; n           int current_min = a[x], current_max = a[x]; n           for (int i = log_n - 1; ~i; --i) { n             if (x + (1 << i) <= n) { n               int next_min = min(current_min, rmq_min[i][x]); n               int next_max = max(current_max, rmq_max[i][x]); n               if (next_max - next_min <= limit) { n                 current_min = next_min; n                 current_max = next_max; n                 x += 1 << i; n               } n             } n           } n         } n       } n     } n     return answer; n   }; n   vector<pair<int, int>> queries(q); n   vector<int> answer(q); n   for (int i = 0; i < q; ++i) { n     scanf( %d , &queries[i].first); n     queries[i].first = m - queries[i].first; n     queries[i].second = i; n   } n   sort(queries.begin(), queries.end()); n   for (auto p : queries) { n     answer[p.second] = query(p.first); n   } n   for (int i = 0; i < q; ++i) { n     printf( %d n , answer[i]); n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int main() { n   long int n, i; n   cin >> n; n   long long int a[n]; n   for (i = 0; i < n; i++) { n     cin >> a[i]; n   } n   if (n == 1) { n     cout << a[0]; n     return 0; n   } n   sort(a, a + n); n   long long int sum = 0; n   if (a[0] >= 0) { n     sum = -1 * a[0]; n     for (i = 1; i < n; i++) { n       sum += a[i]; n     } n   } else if (a[n - 1] < 0) { n     sum = a[n - 1]; n     for (i = 0; i < n - 1; i++) { n       sum -= a[i]; n     } n   } else { n     for (i = 0; i < n; i++) { n       if (a[i] < 0) { n         sum -= a[i]; n       } else { n         sum += a[i]; n       } n     } n   } n   cout << sum << endl; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int N = 1e6 + 6; n const long long M = 1e9 + 7; n const double eps = 1e-7; n int a[N]; n int Int() { n   int x; n   scanf( %d , &x); n   return x; n } n long long Lnt() { n   long long x; n   scanf( %I64d , &x); n   return x; n } n long long Bigmod(long long A, long long B, long long C) { n   if (B == 0LL) return 1LL; n   long long x = Bigmod(A, B / 2LL, C); n   x = (x * x) % C; n   if (B % 2 == 1) x = (x * A) % C; n   return x; n } n struct mar { n   int i, j, c, d; n } cr[N]; n bool cmp(mar a, mar b) { n   if (a.i == b.i) return a.j < b.j; n   return a.i < b.i; n } n bool Cmp(int a, int b) { return a > b; } n void print(int n) { printf( %d n , n); } n void Print(long long n) { printf( %I64d n , n); } n void debug(int n) { printf( %d  , n); } n int main() { n   int x1 = Int(), x2 = Int(), x3 = Int(), x4 = Int(), x5 = Int(), x6 = Int(); n   int c = x3 + x5; n   int d = max(x4, x6); n   if (x1 > x2) swap(x1, x2); n   if ((x1 >= c && x2 >= d) or (x2 >= c && x1 >= d)) return puts( YES ), 0; n   c = x3 + x6; n   d = max(x4, x5); n   if ((x1 >= c && x2 >= d) or (x1 >= d and x2 >= c)) return puts( YES ), 0; n   c = x4 + x5; n   d = max(x3, x6); n   if ((x1 >= c && x2 >= d) or (x1 >= d and x2 >= c)) return puts( YES ), 0; n   c = x4 + x6; n   d = max(x3, x5); n   if ((x1 >= c && x2 >= d) or (x1 >= d and x2 >= c)) return puts( YES ), 0; n   return puts( NO ); n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n long long int a[2005]; n long long int cnt[2005]; n long long int b[2005]; n long long int vis[2005]; n vector<long long int> v; n vector<long long int> vv; n vector<long long int> ans; n long long int prime[2005]; n bool pr[2005]; n set<char> st; n priority_queue<long long int> bob; n priority_queue<long long int> ali; n priority_queue<long long int> bth; n queue<long long int> q; n map<long long int, long long int> mp; n long long int taken[105]; n map<long long int, long long int>::iterator it; n map<long long int, vector<long long int> > ck; n string ss, tt; n long long int pos[205]; n long long int afs[205]; n long long int pre[2005]; n long long int aa[2005]; n long long int cs[27]; n long long int ct[27]; n long long int power(long long int k, long long int i) { n   long long int res = 1; n   for (long long int j = 1; j <= i; j++) { n     res = res * k; n   } n   return res; n } n int main() { n   long long int n, i, j, k, t, m; n   cin >> t; n   long long int minis; n   long long int res; n   long long int x, y; n   long long int pp; n   string fg; n   long long int l, r; n   long long int h; n   long long int p, q; n   string tt; n   while (t--) { n     v.clear(); n     cin >> n; n     cin >> ss >> tt; n     string fg; n     long long int kk = n; n     res = 0; n     for (i = n - 1; i >= 0; i--) { n       if (ss[i] == tt[i]) { n         kk--; n         continue; n       } else { n         if (ss[0] == tt[i]) { n           res = res + 1; n           v.push_back(1); n           if (ss[0] ==  0 ) n             ss[0] =  1 ; n           else n             ss[0] =  0 ; n         } n         fg.clear(); n         for (j = 0; j <= i; j++) { n           if (ss[j] ==  0 ) n             fg.push_back( 1 ); n           else n             fg.push_back( 0 ); n         } n         reverse(fg.begin(), fg.end()); n         res = res + 1; n         v.push_back(kk); n         for (j = 0; j <= i; j++) { n           ss[j] = fg[j]; n         } n       } n       kk--; n     } n     cout << res <<    ; n     for (i = 0; i < v.size(); i++) cout << v[i] <<    ; n     cout <<   n ; n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int main() { n   string s; n   cin >> s; n   int n = (int)int(s.size()); n   int num = (s[n - 1] -  0 ) + 10 * (s[n - 2] -  0 ); n   if (num % 4 == 0) n     cout << 4; n   else n     cout << 0; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n void dfs(long long a, long long b, char A, char B) { n   if (a == 1 && b == 1) return; n   if (a < b) swap(a, b), swap(A, B); n   printf( %I64d%c , (a - 1) / b, A); n   dfs(a - (a - 1) / b * b, b, A, B); n } n long long gcd(long long a, long long b) { n   if (b == 0) return a; n   return gcd(b, a % b); n } n int main() { n   long long a, b; n   cin >> a >> b; n   if (gcd(a, b) != 1) { n     puts( Impossible ); n     return 0; n   } n   dfs(a, b,  A ,  B ); n   puts(  ); n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int q, ans; n char s[300010]; n set<int> len, hs[300010]; n int p[300010], v[300010]; n int main() { n   int i, l, op; n   for (i = 1, p[0] = 1; i <= 300000; ++i) n     p[i] = 1LL * p[i - 1] * 27 % 1000000007; n   scanf( %d , &q); n   while (q--) { n     scanf( %d%s , &op, s + 1); n     l = strlen(s + 1); n     for (i = 1, v[0] = 0; i <= l; ++i) n       v[i] = (1LL * v[i - 1] * 27 + s[i] -  a  + 1) % 1000000007; n     if (op == 1) { n       len.insert(l); n       hs[l].insert(v[l]); n     } else if (op == 2) n       hs[l].erase(v[l]); n     else { n       ans = 0; n       for (auto it = len.begin(); it != len.end(); it++) n         for (i = *it; i <= l; i++) n           ans += (hs[*it].find((v[i] - 1LL * v[i - *it] * p[*it] % 1000000007 + n                                 1000000007) % n                                1000000007) != hs[*it].end()); n       printf( %d n , ans); n       fflush(stdout); n     } n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n struct node; n typedef node *Node; n const int inf = 1000000; n bool fl = 0; n struct node { n   Node left, right, link, parent; n   int size, prior, sum, number; n   set<int> all; n   pair<int, int> mmin; n   node(int number) : number(number) { n     left = right = link = parent = NULL; n     prior = rand() + (rand() << 16); n     update(); n   } n   int key() { n     int ans = 1; n     if (left) ans += left->size; n     return ans; n   } n   void update() { n     size = 1; n     sum = all.size(); n     if (sum == 0) n       mmin = make_pair(inf, inf); n     else n       mmin = make_pair(*all.begin(), number); n     if (left) { n       size += left->size; n       sum += left->sum; n       mmin = min(mmin, left->mmin); n       left->parent = this; n     } n     if (right) { n       size += right->size; n       sum += right->sum; n       mmin = min(mmin, right->mmin); n       right->parent = this; n     } n   } n }; n void upd_min(Node t) { n   while (t) { n     t->update(); n     t = t->parent; n   } n } n void add_ppl(Node &t, int ppl) { n   t->all.insert(ppl); n   t->sum++; n   upd_min(t); n } n void del_ppl(Node &t, int ppl) { n   t->all.erase(ppl); n   t->sum--; n   upd_min(t); n } n Node merge(Node l, Node r) { n   if (!l) return r; n   if (!r) return l; n   if (l->prior > r->prior) { n     l->right = merge(l->right, r); n     l->update(); n     return l; n   } else { n     r->left = merge(l, r->left); n     r->update(); n     return r; n   } n } n void split(Node t, int key, Node &l, Node &r) { n   if (!t) return void(l = r = NULL); n   if (t->key() <= key) { n     split(t->right, key - t->key(), t->right, r); n     l = t; n   } else { n     split(t->left, key, l, t->left); n     r = t; n   } n   t->update(); n   t->parent = NULL; n } n int get_pos(Node t) { n   vector<char> vc; n   Node v = t; n   while (v->parent) { n     if (v->parent->left == v) n       vc.push_back(0); n     else n       vc.push_back(1); n     v = v->parent; n   } n   reverse(vc.begin(), vc.end()); n   int pos = 0; n   for (int i = 0; i < vc.size(); ++i) { n     if (vc[i] == 0) n       v = v->left; n     else n       pos += v->key(), v = v->right; n   } n   pos += v->key(); n   return pos; n } n Node get_root(Node t) { n   Node ans = NULL; n   while (t) { n     ans = t; n     t = t->parent; n   } n   return ans; n } n Node leftmost(Node t) { n   Node ans = NULL; n   while (t) { n     ans = t; n     t = t->left; n   } n   return ans; n } n Node rightmost(Node t) { n   Node ans = NULL; n   while (t) { n     ans = t; n     t = t->right; n   } n   return ans; n } n void set_link(Node t, Node v) { n   if (!t) return; n   t->link = v; n } n void cut_out(Node t) { n   int pos = get_pos(t); n   Node l, r; n   split(get_root(t), pos, l, r); n   set_link(leftmost(r), t); n } n void cut_out1(Node t) { n   int pos = get_pos(t); n   Node l, r; n   split(get_root(t), pos - 1, l, r); n   set_link(leftmost(r), rightmost(l)); n } n void expose(Node v) { n   cut_out(v); n   v = leftmost(get_root(v)); n   while (v->link) { n     cut_out(v->link); n     merge(get_root(v->link), get_root(v)); n     set_link(v, NULL); n     v = leftmost(get_root(v)); n   } n } n void link(Node u, Node v) { n   set_link(u, v); n   expose(u); n } n void cut(Node u, Node v) { n   expose(v); n   set_link(u, NULL); n } n Node lca(Node v, Node u, bool &one_tree) { n   expose(u); n   if (get_root(u) == get_root(v)) { n     one_tree = 1; n     return v; n   } n   expose(v); n   expose(u); n   return leftmost(get_root(v))->link; n } n vector<Node> nodes; n const int maxn = 100000; n vector<pair<int, int> > add; n vector<int> g[maxn + 1]; n vector<int> deep; n void dfs(int v, int p = -1) { n   for (int i = 0; i < g[v].size(); ++i) { n     int tv = g[v][i]; n     if (tv == p) continue; n     deep[tv] = deep[v] + 1; n     dfs(tv, v); n   } n } n void print_(Node v) { n   if (!v) return; n   print_(v->left); n   cout <<   t  << v->number <<     << (v->link ? v->link->number : -1) << endl; n   print_(v->right); n } n void print(Node v) { print_(get_root(v)); } n void print_all(int n) { n   for (int i = 1; i <= n; ++i) { n     cout << i <<  : n ; n     print(nodes[i]); n     cout << endl; n   } n } n void do_the_thing(Node v, int x) { n   Node t = get_root(v); n   int k = min(x, t->sum); n   cout << k <<    ; n   vector<pair<int, int> > add_after; n   for (int i = 0; i < k; ++i) { n     pair<int, int> cmin = t->mmin; n     cout << cmin.first <<    ; n     del_ppl(nodes[cmin.second], cmin.first); n     add_after.push_back(cmin); n   } n   cout << endl; n   for (int i = 0; i < add_after.size(); ++i) { n     pair<int, int> ct = add_after[i]; n     add_ppl(nodes[ct.second], ct.first); n   } n } n int main() { n   srand(time(NULL)); n   ios_base::sync_with_stdio(0); n   int n, m, q; n   cin >> n >> m >> q; n   nodes.resize(n + 1); n   deep.assign(n + 1, 0); n   for (int i = 1; i <= n; ++i) nodes[i] = new node(i); n   for (int i = 0; i < n - 1; ++i) { n     int a, b; n     cin >> a >> b; n     add.push_back(make_pair(a, b)); n     g[a].push_back(b); n     g[b].push_back(a); n   } n   dfs(1); n   for (int i = 0; i < add.size(); ++i) { n     int a = add[i].first; n     int b = add[i].second; n     if (deep[a] < deep[b]) swap(a, b); n     link(nodes[a], nodes[b]); n   } n   for (int i = 1; i <= m; ++i) { n     int city; n     cin >> city; n     add_ppl(nodes[city], i); n   } n   for (int i = 0; i < q; ++i) { n     int v, u, x; n     cin >> v >> u >> x; n     bool one_tree = 0; n     Node t = lca(nodes[v], nodes[u], one_tree); n     if (one_tree) { n       cut_out1(nodes[v]); n       do_the_thing(nodes[v], x); n     } else { n       int split_key = get_root(nodes[v])->size; n       cut_out1(t); n       merge(get_root(nodes[v]), get_root(t)); n       do_the_thing(nodes[v], x); n       Node l, r; n       split(get_root(nodes[v]), split_key, l, r); n     } n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n #pragma comment(linker,  /STACK:100000000000000 ) n using namespace std; n const long long int INF = 2e18; n int nex[20000][35]; n int at[35]; n int main() { n   string f, s; n   cin >> f >> s; n   memset(nex, -1, sizeof nex); n   memset(at, -1, sizeof at); n   for (int i = 0; i < f.size(); i++) { n     int he = f[i] -  a ; n     if (at[he] == -1) { n       at[he] = i; n     } n   } n   for (int i = f.size() - 1; i >= 0; i--) { n     for (int j = 0; j < 35; j++) { n       nex[i][j] = at[j]; n     } n     at[f[i] -  a ] = i; n   } n   int now = (f[0] == s[0] ? 0 : nex[0][s[0] -  a ]); n   int cur = 0; n   int cnt = 1; n   while (cur < s.size()) { n     if (now == -1) { n       cout << -1; n       return 0; n     } n     cur++; n     if (cur == s.size()) break; n     int gogo = nex[now][s[cur] -  a ]; n     if (gogo == -1) { n       cout << -1; n       return 0; n     } n     if (gogo <= now) { n       cnt++; n     } n     now = gogo; n   } n   cout << cnt; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int main() { n   int n, m; n   cin >> n >> m; n   vector<int> dis(n + 1, n), cnt(n + 1, -1); n   while (m--) { n     int a, b; n     cin >> a >> b; n     ++cnt[a]; n     dis[a] = min(dis[a], a > b ? b - a + n : b - a); n   } n   for (int i = 1; i <= n; ++i) { n     int res = 0; n     for (int j = 1; j <= n; ++j) n       if (~cnt[j]) n         res = max(res, (i > j ? j - i + n : j - i) + cnt[j] * n + dis[j]); n     cout << res <<    ; n   } n   cout << endl; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int main() { n   ios_base::sync_with_stdio(0); n   cin.tie(); n   string s, mx; n   cin >> s; n   int len = s.length(); n   for (int i = 1; i < 1 << len; i++) { n     string foo; n     for (int j = 0; j < len; j++) n       if (i & (1 << j)) foo += s[j]; n     bool flag = 1; n     for (int k = 0; k <= foo.length() / 2; k++) n       if (foo[k] != foo[foo.length() - k - 1]) flag = 0; n     if (flag && foo > mx) mx = foo; n   } n   cout << mx; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int size = 300000001; n bitset<size> gut; n int main() { n   int l, r; n   cin >> l >> r; n   gut.set(); n   for (int i = 3; i * i <= r; i += 2) { n     if (gut[i]) n       for (int j = i * i; j <= r; j += (i << 1)) { n         gut[j] = false; n       } n   } n   int rez = 0; n   rez = (l <= 2 && r >= 2); n   for (int i = 5; i <= r; i += 4) { n     if (i >= l && gut[i]) rez++; n   } n   cout << rez << endl; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int N = 3010; n struct edge { n   int v, next, flag; n } e[N << 2]; n int head[N], cnt; n void addedge(int u, int v, int flag) { n   e[cnt].v = v; n   e[cnt].flag = flag; n   e[cnt].next = head[u]; n   head[u] = cnt++; n } n int sum[N], dp[N]; n void dfs(int u, int pre) { n   sum[u] = 0; n   for (int i = head[u]; i != -1; i = e[i].next) { n     if (e[i].v == pre) continue; n     dfs(e[i].v, u); n     int v = e[i].v; n     sum[u] += sum[v] + e[i].flag; n   } n   dp[u] = sum[u]; n   for (int i = head[u]; i != -1; i = e[i].next) { n     if (e[i].v == pre) continue; n     int v = e[i].v; n     dp[u] = min(dp[u], sum[u] - sum[v] + 1 - e[i].flag + dp[v] - e[i].flag); n   } n } n int main() { n   memset(head, -1, sizeof(head)); n   int n; n   scanf( %d , &n); n   for (int i = 1; i < n; i++) { n     int x, y, z; n     scanf( %d%d , &x, &y); n     addedge(x, y, 0); n     addedge(y, x, 1); n   } n   int ans = 0x7fffffff; n   for (int i = 1; i <= n; i++) { n     dfs(i, -1); n     for (int j = 1; j <= n; j++) { n       ans = min(ans, sum[i] - sum[j] + dp[j]); n     } n   } n   printf( %d n , ans); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int MAXN = 1e3 + 100; n int N; n int p[MAXN], rp[MAXN]; n char ans[MAXN][MAXN]; n bool v[MAXN]; n int lvl, C; n bool pd; n bool id(int* a, int as) { n   for (int i = 1; i <= as; i++) n     if (a[i] != i) return false; n   return true; n } n char get_dir(bool d) { return d ?  /  :     ; } n char get_dir(int a, int b) { n   assert(a != b); n   return get_dir(a < b); n } n bool addE(int a, int b) { n   assert(a != b); n   if (a < b) { n     ans[lvl][a] = ans[lvl][b] =  / ; n     return true; n   } n   if (a > b) { n     ans[lvl][a] = ans[lvl][b] =     ; n     return false; n   } n   assert(false); n   return false; n } n void init(int n) { n   assert(p[n] != n); n   v[n] = true; n   C = n; n   for (int i = p[n]; i != n; i = p[i]) { n     v[i] = true; n     pd = addE(p[i], i); n     lvl--; n   } n } n int addFE(int n, int lf) { n   if ((pd) xor (n > C)) { n     ans[lvl][n] = get_dir(p[n], C); n     ans[lf][C] = get_dir(C, n); n     pd = C < n; n     ans[lf][n] = get_dir(C, n); n     return -1; n   } n   if ((p[n] < n) xor (n < C)) { n     ans[lvl - 1][C] = get_dir(p[n], C); n     ans[lf][C] = get_dir(C, n); n     ans[lf][n] = get_dir(C, n); n     return -1; n   } n   assert(false); n   return -1; n } n void fill(int n) { n   v[n] = true; n   int l = 1, s = -1; n   for (int i = p[n]; i != n; i = p[i]) { n     v[i] = true, l++; n     if (((p[n] < n) xor (C < n)) or (pd xor (n > C))) s = i; n   } n   lvl += addFE(s, lvl - l); n   for (int i = p[s]; i != s; i = p[i]) { n     addE(p[i], i), lvl--; n   } n } n int main() { n   scanf( %d , &N); n   lvl = N; n   pd = false; n   for (int i = 0; i <= N; i++) v[i] = false, p[i] = rp[i] = -1; n   for (int i = 1; i <= N; i++) scanf( %d , rp + i); n   for (int i = 1; i <= N; i++) p[rp[i]] = i; n   for (int i = 1; i <= N; i++) n     for (int j = 1; j <= N; j++) ans[i][j] =  . ; n   if (id(p, N)) { n     printf( %d n , N); n     for (int i = 1; i <= N; i++, printf(  n )) n       for (int j = 1; j <= N; j++) printf( %c , ans[i][j]); n     return 0; n   } n   for (int i = 1; i <= N; i++) n     if (p[i] == i) v[i] = true; n   for (int i = 1, c = 1; c and i <= N; i++) n     if (!v[i]) init(i), c = 0; n   lvl++; n   for (int i = 1; i <= N; i++) n     if (!v[i]) fill(i); n   printf( %d n , N - 1); n   for (int i = 1; i <= N; i++, printf(  n )) n     for (int j = 1; j <= N; j++) printf( %c , ans[i][j]); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int t[35], mp[400][400], n; n void dfs(int step, int x, int y, int dir) { n   if (step > n) return; n   if (dir == 0) { n     dfs(step + 1, x, y + t[step], 1 - dir); n     for (int i = 0; i < 400; i++) n       for (int j = 0; j < 400; j++) n         if (mp[i][j]) { n           mp[i][j] = mp[x * 2 - i][j] = 1; n         } n     for (int i = 1; i <= t[step]; i++) mp[x][y + i] = 1; n   } else { n     dfs(step + 1, x + t[step], y + t[step], 1 - dir); n     int b = y - x; n     for (int i = 0; i < 400; i++) n       for (int j = 0; j < 400; j++) n         if (mp[i][j]) { n           mp[i][j] = mp[j - b][i + b] = 1; n         } n     for (int i = 1; i <= t[step]; i++) { n       mp[x + i][y + i] = 1; n     } n   } n } n int main() { n   scanf( %d , &n); n   for (int i = 1; i <= n; i++) scanf( %d , t + i); n   memset(mp, 0, sizeof(mp)); n   dfs(1, 200, 199, 0); n   int ans = 0; n   for (int i = 0; i < 400; i++) n     for (int j = 0; j < 400; j++) n       if (mp[i][j]) ans++; n   cout << ans << endl; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int MAXN = 2000000; n char a[MAXN + 10], b[MAXN + 10]; n int main(void) { n   int n; n   scanf( %d%s%s , &n, a, b); n   int cnt[2][2]; n   for (int i = 0; i < (2); ++i) { n     for (int j = 0; j < (2); ++j) { n       cnt[i][j] = 0; n     } n   } n   n *= 2; n   for (int i = 0; i < (n); ++i) { n     ++cnt[a[i] -  0 ][b[i] -  0 ]; n   } n   int sA = 0, sB = 0; n   for (int i = 0; i < (n); ++i) { n     if (cnt[1][1] > 0) { n       --cnt[1][1]; n       ++sA; n     } else if (cnt[1][0] > 0) { n       --cnt[1][0]; n       ++sA; n     } else if (cnt[0][1] > 0) { n       --cnt[0][1]; n     } else { n       --cnt[0][0]; n     } n     if (cnt[1][1] > 0) { n       --cnt[1][1]; n       ++sB; n     } else if (cnt[0][1] > 0) { n       --cnt[0][1]; n       ++sB; n     } else if (cnt[1][0] > 0) { n       --cnt[1][0]; n     } else { n       --cnt[0][0]; n     } n   } n   if (sA > sB) { n     puts( First ); n   } else if (sA < sB) { n     puts( Second ); n   } else { n     puts( Draw ); n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int main() { n   int n, m, X, Y, Z, p; n   int x, y; n   while (scanf( %d%d%d%d%d%d , &n, &m, &X, &Y, &Z, &p) != EOF) { n     X %= 4; n     Y %= 2; n     Z %= 4; n     int tn = n; n     int tm = m; n     for (int i = 1; i <= p; i++) { n       n = tn; n       m = tm; n       scanf( %d%d , &x, &y); n       if (X == 1) { n         int xx = x; n         x = y; n         y = n + 1 - xx; n         int nn = n; n         n = m; n         m = nn; n       } else if (X == 2) { n         x = n + 1 - x; n         y = m + 1 - y; n       } else if (X == 3) { n         int xx = x; n         x = m + 1 - y; n         y = xx; n         int nn = n; n         n = m; n         m = nn; n       } n       if (Y == 1) { n         y = m + 1 - y; n       } n       if (Z == 1) { n         int xx = x; n         x = m + 1 - y; n         y = xx; n         int nn = n; n         n = m; n         m = nn; n       } else if (Z == 2) { n         x = n + 1 - x; n         y = m + 1 - y; n       } else if (Z == 3) { n         int xx = x; n         x = y; n         y = n + 1 - xx; n         int nn = n; n         n = m; n         m = nn; n       } n       printf( %d %d n , x, y); n     } n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n #pragma GCC optimize(2) n using namespace std; n const int INF = 1e9 + 7; n const int N = 4e5 + 7; n const int M = 5e6 + 7; n int vis[M]; n int p[N]; n int qt[N]; n signed main() { n   ios::sync_with_stdio(false); n   int q, x, y; n   cin >> q >> x; n   set<pair<int, int>> vals; n   for (int i = 0; i < x; i++) vals.insert({qt[i], i}); n   while (q--) { n     int y; n     cin >> y; n     y %= x; n     vals.erase({qt[y], y}); n     vals.insert({++qt[y], y}); n     auto k = *vals.begin(); n     int nVal = k.first * x + k.second; n     cout << nVal << endl; n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int main() { n   double n, m; n   cin >> n >> m; n   printf( %.10lf n , n * pow(1.000000011, m)); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int n, x, l[60], r[60], ans; n int main() { n   scanf( %d %d , &n, &x); n   for (int i = 1; i <= n; ++i) { n     scanf( %d %d , &l[i], &r[i]); n   } n   for (int i = 1; i <= n; ++i) { n     ans += (l[i] - r[i - 1] - 1) % x; n     ans += r[i] - l[i] + 1; n   } n   printf( %d , ans); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int N = 2000 + 7, Mod = 1000000000 + 7; n inline int Inc(int A, int B) { n   A += B; n   return A >= Mod ? A - Mod : A; n } n inline int Dec(int A, int B) { n   A -= B; n   return A < 0 ? A + Mod : A; n } n int n, m, A, B, Dpd[N][N], Dpr[N][N], Sumd[N][N], Sumr[N][N], d[N][N], r[N][N]; n char Map[N][N]; n int main() { n   scanf( %d%d , &n, &m); n   for (int i = (1), iLimit = (n); i <= iLimit; (++(i))) n     for (int j = (1), jLimit = (m); j <= jLimit; (++(j))) cin >> Map[i][j]; n   if (n == 1 && m == 1) { n     if (Map[1][1] ==  R ) n       puts( 0 ); n     else n       puts( 1 ); n     return 0; n   } n   for (int i = (n), iLimit = (1); i >= iLimit; (--(i))) n     for (int j = (m), jLimit = (1); j >= jLimit; (--(j))) { n       d[i][j] = d[i + 1][j] + (Map[i + 1][j] ==  R ); n       r[i][j] = r[i][j + 1] + (Map[i][j + 1] ==  R ); n     } n   Dpd[n][m] = Dpr[n][m] = Sumd[n][m] = Sumr[n][m] = (Map[n][m] !=  R ); n   for (int i = (n), iLimit = (1); i >= iLimit; (--(i))) n     for (int j = (m), jLimit = (1); j >= jLimit; (--(j))) n       if (i != n || j != m) { n         Dpr[i][j] = Dec(Sumd[i][j + 1], Sumd[i][m - r[i][j] + 1]); n         Dpd[i][j] = Dec(Sumr[i + 1][j], Sumr[n - d[i][j] + 1][j]); n         Sumr[i][j] = Inc(Sumr[i + 1][j], Dpr[i][j]); n         Sumd[i][j] = Inc(Sumd[i][j + 1], Dpd[i][j]); n       } n   printf( %d , Inc(Dpr[1][1], Dpd[1][1])); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n #pragma comment(linker,  /STACK:256000000 ) n const long long INF = 1e9; n const long long mod = 1e9 + 7; n const long long LINF = 1e14; n using namespace std; n long long n, l; n vector<long long> c; n vector<int> b; n int main() { n   std::ios::sync_with_stdio(false); n   cin >> n >> l; n   c.resize(n); n   cin >> c[0]; n   for (long long i = (1); i < (n); i++) { n     cin >> c[i]; n     c[i] = min(c[i - 1] * 2, c[i]); n   } n   while (l > 0) b.push_back(l % 2), l /= 2; n   while (c.size() < b.size()) c.push_back(c.back() * 2); n   while (b.size() < c.size()) b.push_back(0); n   c.push_back(c.back() * 2); n   n = b.size(); n   vector<long long> d(n + 1, LINF); n   d[0] = 0; n   for (long long i = (1); i < (n + 1); i++) { n     d[i] = min(d[i - 1], c[i - 1]); n     if (b[i - 1] == 1) d[i] += c[i - 1]; n   } n   cout << min(d[n], c.back()) << endl; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int main() { n   int x; n   cin >> x; n   int k = x % 4; n   if (k == 1) { n     cout << 0 <<   A  << endl; n   } else if (k == 0) { n     cout << 1 <<   A  << endl; n   } else if (k == 2) { n     cout << 1 <<   B  << endl; n   } else { n     cout << 2 <<   A  << endl; n   } n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n char arr[50][50]; n int main() { n   int n, m; n   cin >> n >> m; n   for (int i = 0; i < n; i++) n     for (int j = 0; j < m; j++) { n       if ((i % 2 == 0 || n            ((i % 4 == 1 && j == m - 1) || (i % 4 == 3 && j == 0)))) n         arr[i][j] =  # ; n       else n         arr[i][j] =  . ; n     } n   for (int i = 0; i < n; i++) { n     for (int j = 0; j < m; j++) cout << arr[i][j]; n     cout <<   n ; n   } n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n template <typename A, typename B> n inline void chmin(A &a, B b) { n   if (a > b) a = b; n } n template <typename A, typename B> n inline void chmax(A &a, B b) { n   if (a < b) a = b; n } n struct UnionFindTree { n   vector<long long> par, sz; n   UnionFindTree(long long n) { n     par.resize(n); n     sz.resize(n); n     for (long long i = 0; i < n; i++) { n       par[i] = i; n       sz[i] = 1; n     } n   } n   long long find(long long x) { n     return x == par[x] ? x : par[x] = find(par[x]); n   } n   void unite(long long x, long long y) { n     x = find(x); n     y = find(y); n     if (x == y) return; n     if (sz[x] < sz[y]) swap(x, y); n     sz[x] += sz[y]; n     par[y] = x; n   } n   bool areSame(long long x, long long y) { return find(x) == find(y); } n   long long size(long long x) { return sz[find(x)]; } n }; n const long long SIZE = 1000000; n long long N, M; n long long A[SIZE], B[SIZE]; n long long cnt[SIZE]; n signed main() { n   scanf( %lld%lld , &N, &M); n   for (long long i = 0; i < (M); i++) scanf( %lld%lld , &A[i], &B[i]); n   vector<long long> vs; n   for (long long i = 0; i < (M); i++) { n     vs.push_back(A[i]); n     vs.push_back(B[i]); n   } n   sort((vs).begin(), (vs).end()); n   vs.erase(unique((vs).begin(), (vs).end()), vs.end()); n   for (long long i = 0; i < (M); i++) { n     A[i] = lower_bound((vs).begin(), (vs).end(), A[i]) - vs.begin(); n     B[i] = lower_bound((vs).begin(), (vs).end(), B[i]) - vs.begin(); n   } n   N = vs.size(); n   UnionFindTree uf(N); n   for (long long i = 0; i < (M); i++) uf.unite(A[i], B[i]); n   if (uf.size(0) != N) { n     puts( 0 ); n     return 0; n   } n   long long luz = 0; n   for (long long i = 0; i < (M); i++) { n     if (A[i] == B[i]) n       luz++; n     else { n       cnt[A[i]]++; n       cnt[B[i]]++; n     } n   } n   long long ans = 0; n   ans += luz * (M - luz); n   ans += luz * (luz - 1) / 2; n   for (long long i = 0; i < N; i++) ans += cnt[i] * (cnt[i] - 1) / 2; n   cout << ans << endl; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n long long int N = 100000, M = 100000; n long long int MOD = 1000000007; n void solve() { n   long long int n; n   cin >> n; n   long long int a[n + 1], b[n + 1]; n   for (long long int i = 0; i < n; i++) cin >> a[i]; n   for (long long int i = 0; i < n; i++) { n     b[i] = a[i] - i; n     if (b[i] < 0) n       b[i] = 0; n     else if (b[i] % n == 0) n       b[i] = b[i] / n; n     else n       b[i] = (b[i] / n) + 1; n   } n   for (long long int i = 0; i < n; i++) b[i] = i + (n * b[i]); n   long long int min1 = b[0]; n   long long int ans = 0; n   for (long long int i = 0; i < n; i++) { n     if (min1 > b[i]) { n       min1 = b[i]; n       ans = i; n     } n   } n   cout << ans + 1; n } n int main() { n   long long int t = 1; n   while (t--) { n     solve(); n   } n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int k, m; n set<int> S; n int pw[10]; n void rec(int ind, int number, int value) { n   if (ind == 4) { n     if (value > k && value - k < 10000) { n       S.insert(number * 10000 + (value - k)); n     } n     if (k >= value && k - value < 10000) { n       S.insert(number * 10000 + (k - value)); n     } n     return; n   } n   for (int i = 1; i + ind < 5; i++) { n     for (int j = 0; j < pw[i]; j++) { n       if (ind == 0) { n         rec(ind + i, j, j); n       } else { n         rec(ind + i, number * pw[i] + j, value + j); n         rec(ind + i, number * pw[i] + j, value - j); n         rec(ind + i, number * pw[i] + j, value * j); n       } n     } n   } n } n int main() { n   scanf( %d , &k); n   scanf( %d , &m); n   pw[0] = 1; n   for (int i = 1; i <= 6; i++) pw[i] = pw[i - 1] * 10; n   rec(0, 0, 0); n   for (set<int>::iterator it = S.begin(); (it != S.end()) && m; it++, m--) { n     cout << setw(8) << setfill( 0 ) << (*it) << endl; n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n #pragma comment(linker,  /STACK:102400000,102400000 ) n using namespace std; n int main() { n   int cases; n   scanf( %d , &cases); n   while (cases--) { n     char str[1009]; n     int ret[9]; n     scanf( %s , str); n     int num = 0; n     int i; n     int cnt = 0; n     int flag = -1; n     for (i = 0; str[i]; i++) { n       if (str[i] >=  A  && str[i] <=  Z ) { n         str[i] = str[i] -  A  +  a ; n       } n       if (str[i] ==  : ) { n         if (str[i + 1] ==  : ) { n           flag = cnt; n           i++; n         } n         ret[cnt] = num; n         cnt++; n         num = 0; n       } else if (str[i] >=  0  && str[i] <=  9 ) { n         num = num * 16 + str[i] -  0 ; n       } else { n         num = num * 16 + str[i] -  a  + 10; n       } n     } n     ret[cnt++] = num; n     int k = 0; n     for (int j = 0; j < cnt; j++) { n       printf( %04x , ret[j]); n       k++; n       if (k != 8) { n         putchar( : ); n       } n       if (flag == j) { n         for (i = 0; i < 8 - cnt; i++) { n           printf( 0000 ); n           k++; n           if (k != 8) { n             putchar( : ); n           } n         } n       } n     } n     putchar(10); n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int main() { n   long long n, i, j, r, mn, mx, x, cnt = 0, a = 1, b = 1; n   string s; n   cin >> n; n   for (i = 0; i < n; i++) { n     cin >> s; n     if (s ==  UR  || s ==  DL ) n       a++; n     else if (s ==  UL  || s ==  DR ) n       b++; n     else { n       a++, b++; n     } n   } n   cout << a * b << endl; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int INF = 2e9; n int n; n pair<int, int> p[25]; n int dis[25][25]; n int dp[1 << 24 | 1]; n int pre[1 << 24 | 1]; n int main() { n   scanf( %d%d%d , &p[0].first, &p[0].second, &n); n   for (int i = 1; i <= n; ++i) { n     scanf( %d%d , &p[i].first, &p[i].second); n   } n   for (int i = 0; i <= n; ++i) n     for (int j = i; j <= n; ++j) { n       dis[i][j] = dis[j][i] = n           pow(p[i].first - p[j].first, 2) + pow(p[i].second - p[j].second, 2); n     } n   for (int m = 1; m < (1 << n); ++m) { n     dp[m] = INF; n   } n   dp[0] = 0; n   for (int m = 0; m < (1 << n); ++m) { n     if (dp[m] == INF) continue; n     for (int i = 1; i <= n; ++i) { n       if (m & 1 << (i - 1)) continue; n       for (int j = 1; j <= n; ++j) { n         if (m & 1 << (j - 1)) continue; n         if (dp[m | (1 << i - 1) | (1 << j - 1)] > n             dp[m] + dis[0][i] + dis[i][j] + dis[j][0]) { n           dp[m | (1 << i - 1) | (1 << j - 1)] = n               dp[m] + dis[0][i] + dis[i][j] + dis[j][0]; n           pre[m | (1 << i - 1) | (1 << j - 1)] = m; n         } n       } n       break; n     } n   } n   printf( %d n , dp[(1 << n) - 1]); n   int num = (1 << n) - 1; n   while (num) { n     printf( 0  ); n     int t = pre[num] ^ num; n     for (int i = 0; i < n; ++i) { n       if (t & (1 << i)) { n         printf( %d  , i + 1); n       } n     } n     num = pre[num]; n   } n   printf( 0 n ); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const long long MAXN = 1000001; n long long n, l[MAXN], r[MAXN], id[MAXN], K; n bool cmp(long long i, long long j) { n   return (l[i] / K == l[j] / K) n              ? ((l[i] / K & 1) ? (r[i] < r[j]) : (r[i] > r[j])) n              : (l[i] < l[j]); n } n int main() { n   scanf( %lld , &n); n   K = 1000; n   for (long long i = 1; i <= n; i++) scanf( %lld%lld , &l[i], &r[i]), id[i] = i; n   sort(id + 1, id + 1 + n, cmp); n   for (int i = 1; i <= n; i++) printf( %lld  , id[i]); n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const long long neutral = 0; n class SegmentTree { n   vector<long long> a; n   int n; n  n  public: n   SegmentTree(long long* st, long long* en) { n     int sz = int(en - st); n     for (n = 1; n < sz; n <<= 1) n       ; n     a.assign(n << 1, neutral); n     for (int i = 0; i < sz; i++) a[i + n] = st[i]; n     for (int i = n + sz - 1; i > 1; i--) a[i >> 1] = ((a[i >> 1]) | (a[i])); n   } n   void update(int i, long long x) { n     a[i += n] = x; n     for (i >>= 1; i; i >>= 1) a[i] = ((a[i << 1]) | (a[1 + (i << 1)])); n   } n   long long query(int l, int r) { n     long long ans = neutral; n     for (l += n, r += n + 1; l < r; l >>= 1, r >>= 1) { n       if (l & 1) ans = ((ans) | (a[l++])); n       if (r & 1) ans = ((ans) | (a[--r])); n     } n     return ans; n   } n }; n int main() { n   cin.sync_with_stdio(0); n   cin.tie(0); n   cin.exceptions(cin.failbit); n   int n, q, m; n   string s; n   cin >> s; n   n = (int)(s).size(); n   long long v[n]; n   for (int i = 0; i < (n); ++i) { n     v[i] = 1LL << (s[i] -  a ); n   } n   cin >> q; n   SegmentTree st(v, v + n); n   while (q--) { n     int t; n     cin >> t; n     if (t == 2) { n       int a, b; n       cin >> a >> b; n       long long res = st.query(a - 1, b - 1), c = 0; n       while (res > 0) c++, res -= (res & -res); n       cout << c << endl; n     } else { n       int a; n       char c; n       cin >> a >> c; n       int b = c -  a ; n       st.update(a - 1, 1LL << b); n     } n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int N = 2e5 + 10, size = 1 << 20, mod = 998244353, inf = 2e9; n const long long INF = 1e15; n template <class o> n void qr(o& x) { n   char c = getchar(); n   x = 0; n   int f = 1; n   while (!isdigit(c)) { n     if (c ==  - ) f = -1; n     c = getchar(); n   } n   while (isdigit(c)) x = x * 10 + c -  0 , c = getchar(); n   x *= f; n } n template <class o> n void qw(o x) { n   if (x / 10) qw(x / 10); n   putchar(x % 10 +  0 ); n } n template <class o> n void pr1(o x) { n   if (x < 0) x = -x, putchar( - ); n   qw(x); n   putchar(   ); n } n template <class o> n void pr2(o x) { n   if (x < 0) x = -x, putchar( - ); n   qw(x); n   putchar(10); n } n template <class o> n void cmax(o& x, o y) { n   if (x < y) x = y; n } n void cmax(int& x, int y) { x = x - y >> 31 ? y : x; } n template <class o> n void cmin(o& x, o y) { n   if (x > y) x = y; n } n void cmin(int& x, int y) { x = x - y >> 31 ? x : y; } n int n, m, a[N], p[N], b[N]; n struct BIT { n   int c[N]; n   void clear() { memset(c + 1, 0, n * sizeof(int)); } n   void clear(int x) { n     for (; x <= n; x += x & -x) c[x] = 0; n   } n   int ask(int x) { n     int y = 0; n     for (; x; x -= x & -x) y += c[x]; n     return y; n   } n   int ask(int l, int r) { return ask(r) - ask(l - 1); } n   void add(int x, int y) { n     for (; x <= n; x += x & -x) c[x] += y; n   } n } tr; n struct Q { n   int l, r, y, v, id; n   Q(int _l, int _r, int _y, int _v, int _id = 0) n       : l(_l), r(_r), y(_y), v(_v), id(_id){}; n   Q(){}; n   bool operator<(Q b) const { return y < b.y; } n } q[N * 5], t[N * 5]; n int tot, ans[N], id; n void cdq(int l, int r) { n   if (r - l < 100) { n     int j = 0; n     for (auto i = l; i <= r; i++) { n       if (!q[i].id) n         t[++j] = q[i]; n       else n         for (auto k = 1; k <= j; k++) { n           if (q[i].l <= t[k].l && t[k].l <= q[i].r && t[k].y <= q[i].y) n             ans[q[i].id] += q[i].v * t[k].v; n         } n     } n     sort(q + l, q + r + 1); n     return; n   } n   int mid = (l + r) / 2; n   cdq(l, mid); n   cdq(mid + 1, r); n   Q* p = t; n   for (int i = l, j = mid + 1; i <= mid || j <= r;) { n     if (j > r || (i <= mid && q[i].y <= q[j].y)) { n       if (!q[i].id) tr.add(q[i].l, q[i].v); n       *p++ = q[i++]; n     } else { n       if (q[j].id) ans[q[j].id] += q[j].v * tr.ask(q[j].l, q[j].r); n       *p++ = q[j++]; n     } n   } n   if (r - l > 2333) n     tr.clear(); n   else n     for (auto i = l; i <= mid; i++) n       if (!q[i].id) tr.clear(q[i].l); n   for (auto i = r; i >= l; i--) q[i] = *--p; n } n void solve() { n   qr(n); n   qr(m); n   for (auto i = 1; i <= n; i++) qr(a[i]), p[a[i]] = i; n   for (auto i = 1; i <= n; i++) n     qr(b[i]), b[i] = p[b[i]], q[++tot] = Q(i, i, b[i], 1); n   int op, x, y, l, r; n   while (m--) { n     qr(op); n     qr(x); n     qr(y); n     if (op == 1) { n       qr(l); n       qr(r); n       ++id; n       q[++tot] = Q(l, r, y, 1, id); n       q[++tot] = Q(l, r, x - 1, -1, id); n     } else { n       q[++tot] = Q(x, x, b[x], -1); n       q[++tot] = Q(y, y, b[y], -1); n       swap(b[x], b[y]); n       q[++tot] = Q(x, x, b[x], 1); n       q[++tot] = Q(y, y, b[y], 1); n     } n   } n   cdq(1, tot); n   for (auto i = 1; i <= id; i++) pr2(ans[i]); n } n int main() { n   int T = 1; n   while (T--) solve(); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n template <class T> n class _Fenwick { n  private: n   std::vector<T> sum; n   int _size; n  n  public: n   _Fenwick() { _size = 0; } n   void reset(int n) { n     _size = n; n     sum.clear(); n     sum.resize(n + 1); n   } n   void add(int x, T y) { n     while (x <= _size) { n       sum[x] += y; n       x += x & -x; n     } n   } n   T query(int x, T y) { n     T ans = y; n     while (x) { n       ans += sum[x]; n       x -= x & -x; n     }; n     return ans; n   } n   void build(T *a, int n) { n     reset(n); n     for (int i = 1; i <= n; ++i) add(i, a[i]); n   } n }; n template <typename T> n void read(T &x); n template <typename T> n void read(T &x, T &y); n template <typename T> n void read(T &x, T &y, T &z); n template <typename T> n void write(T x); n template <typename T> n void writeC(T x); n template <typename T> n void writeN(T x); n template <typename T> n void _binary(T x, int len); n long long _qpow(long long a, long long b, long long M); n long long _inv(long long x, long long M); n long long ans; n int n, a[200005], b[200005][31], R[200005][31], L[200005][31], pre[35]; n signed main() { n   read(n); n   for (int i = 1; i <= (n); ++i) read(a[i]); n   ; n   long long ans = (long long)n * (n + 1) / 2; n   for (int i = 1; i <= n; ++i) n     for (int j = 0; j <= 30; ++j) b[i][j] = (a[i] >> j) & 1; n   for (int i = 1; i <= n; ++i) { n     for (int j = 0; j <= 30; ++j) { n       L[i][j] = pre[j]; n       if (b[i][j]) pre[j] = i; n     } n   } n   for (int i = 0; i <= 30; ++i) pre[i] = n + 1; n   for (int i = n; i >= 1; i--) { n     for (int j = 0; j <= 30; ++j) { n       R[i][j] = pre[j]; n       if (b[i][j]) pre[j] = i; n     } n   } n   std::map<int, int> last; n   for (int i = 1; i <= n; ++i) { n     int l = last[a[i]] + 1, r = n; n     for (int j = 0; j <= 30; ++j) n       if (!b[i][j]) { n         l = std::max(l, L[i][j] + 1); n         r = std::min(r, R[i][j] - 1); n       } n     ans -= (long long)(i - l + 1) * (r - i + 1); n     last[a[i]] = i; n   } n   printf( %lld , ans); n } n template <typename T> n void read(T &x) { n   x = 0; n   char c = getchar(); n   T flag = 1; n   while (c <  0  || c >  9 ) { n     if (c ==  - ) flag = -flag; n     c = getchar(); n   } n   while ( 0  <= c && c <=  9 ) { n     x = x * 10 + c -  0 ; n     c = getchar(); n   } n   x *= flag; n } n template <typename T> n void read(T &x, T &y) { n   read(x); n   read(y); n } n template <typename T> n void read(T &x, T &y, T &z) { n   read(x); n   read(y); n   read(z); n } n template <typename T> n void writeC(T x) { n   if (x < 0) x = ~x + 1, putchar( - ); n   if (x > 9) writeC(x / 10); n   putchar(x % 10 +  0 ); n } n template <typename T> n void write(T x) { n   writeC(x); n   putchar(   ); n } n template <typename T> n void writeN(T x) { n   writeC(x); n   puts(  ); n } n template <typename T> n void _binary(T x, int len) { n   for (int i = len - 1; i >= 0; --i) writeC((x >> i) & 1); n } n long long _inv(long long x, long long M) { n   assert(x != 0); n   return x == 1 ? 1 : (M - M / x) * _inv(M % x, M) % M; n } n long long _qpow(long long a, long long b, long long M) { n   long long res = 1; n   while (b > 0) { n     if (b & 1) res = res * a % M; n     a = a * a % M; n     b >>= 1; n   } n   return res; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int num[400005]; n int tot = 0; n set<int> st; n int mp[20]; n int freq[20]; n long long push[20][20]; n long long addp[20][1048576]; n vector<int> pos[20]; n long long sum[20]; n int cnt[20]; n long long memo[1048576]; n long long cost(int mask, int ofst, int id) { n   return sum[id] + addp[id][mask] - n          1LL * (ofst + 1 + ofst + cnt[id]) * cnt[id] / 2; n   ; n } n long long dp(int i, int mask, int ofst) { n   if (i == tot) return 0; n   if (memo[mask] != -1) return memo[mask]; n   long long mn = 1000000000000000000; n   int id; n   for (int j = (0); j <= (tot - 1); j++) { n     if ((mask >> j) & 1) continue; n     long long v = n         dp(i + 1, mask | (1 << j), ofst + cnt[j]) + cost(mask, ofst, j); n     if (v < mn) { n       mn = v; n       id = j; n     } n   } n   return memo[mask] = mn; n } n int main() { n   int n; n   scanf( %d , &n); n   for (int i = (1); i <= (n); i++) { n     scanf( %d , &num[i]); n     --num[i]; n     st.insert(num[i]); n   } n   for (auto u : st) { n     mp[u] = tot++; n   } n   for (int i = (0); i <= (tot - 1); i++) pos[i].push_back(0); n   for (int i = (1); i <= (n); i++) { n     num[i] = mp[num[i]]; n     int t = num[i]; n     pos[t].push_back(i); n     cnt[t]++; n     sum[t] += i; n   } n   memset(push, 0, sizeof(push)); n   for (int i = (1); i <= (n); i++) { n     freq[num[i]]++; n     for (int j = (0); j <= (tot - 1); j++) { n       push[num[i]][j] += cnt[j] - freq[j]; n     } n   } n   memset(addp, 0, sizeof(addp)); n   for (int i = (0); i <= (tot - 1); i++) { n     for (int j = (0); j <= ((1 << tot) - 1); j++) { n       if ((j >> i) & 1) continue; n       for (int k = (0); k <= (tot - 1); k++) { n         if (~(j >> k) & 1) continue; n         addp[i][j] += push[i][k]; n       } n     } n   } n   memset(memo, -1, sizeof(memo)); n   printf( %lld n , dp(0, 0, 0)); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n vector<int> adj[200010]; n long long int ans = 0LL; n int odd = 0, sz[200010] = {}; n void dfs(int cur, int par = -1, int ht = 0) { n   sz[cur]++; n   for (int u : adj[cur]) { n     if (u == par) continue; n     dfs(u, cur, ht ^ 1); n     sz[cur] += sz[u]; n   } n   if (ht) odd++; n } n int main() { n   int n; n   scanf( %d , &n); n   for (int i = 0; i < n - 1; i++) { n     int x, y; n     scanf( %d %d , &x, &y); n     adj[x].push_back(y); n     adj[y].push_back(x); n   } n   dfs(1); n   for (int i = 1; i <= n; i++) ans += (1LL) * sz[i] * (n - sz[i]); n   ans += (1LL) * odd * (n - odd); n   printf( %lld n , ans / 2); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n vector<int> adj[300003]; n vector<int> adje[300003]; n int d[300003]; n int pickd[300003]; n bool vis[300003]; n int n, m; n int x; n int dfs1(int u) { n   int ans = 0; n   if (d[u] == -1) n     x = u; n   else if (d[u] == 1) n     ++ans; n   vis[u] = true; n   for (int v : adj[u]) { n     if (!vis[v]) { n       ans += dfs1(v); n     } n   } n   return ans; n } n int dfs2(int u) { n   int ans = 0; n   if (d[u] == 1) ++ans; n   vis[u] = true; n   for (int i = 0; i < ((int)(adj[u].size())); ++i) { n     int v = adj[u][i]; n     if (!vis[v]) { n       int c = dfs2(v); n       if (c % 2) pickd[adje[u][i]] = 1; n       ans += c; n     } n   } n   return ans; n } n bool solve() { n   memset(vis, 0, sizeof(vis)); n   for (int i = 1; i <= n; ++i) { n     if (!vis[i]) { n       x = -1; n       int c = dfs1(i); n       if (c % 2) { n         if (x == -1) n           return false; n         else { n           d[x] = 1; n         } n       } n     } n   } n   memset(vis, 0, sizeof(vis)); n   memset(pickd, 0, sizeof(pickd)); n   for (int i = 1; i <= n; ++i) { n     if (!vis[i]) { n       dfs2(i); n     } n   } n   int k = accumulate(pickd + 1, pickd + m + 1, 0); n   cout << k <<   n ; n   for (int i = 1; i <= m; ++i) { n     if (pickd[i]) { n       cout << i <<    n [(--k) == 0]; n     } n   } n   return true; n } n int main() { n   ios ::sync_with_stdio(0); n   while (cin >> n >> m) { n     for (int i = 1; i <= n; ++i) { n       cin >> d[i]; n     } n     for (int i = 1; i <= m; ++i) { n       int u, v; n       cin >> u >> v; n       adj[u].push_back(v); n       adj[v].push_back(u); n       adje[u].push_back(i); n       adje[v].push_back(i); n     } n     if (!solve()) cout <<  -1 n ; n     for (int i = 1; i <= n; ++i) { n       adj[i].clear(); n       adje[i].clear(); n     } n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n inline void read(int &x) { n   char ch = getchar(); n   x = 0; n   while (!isdigit(ch)) ch = getchar(); n   while (isdigit(ch)) x = x * 10 + ch - 48, ch = getchar(); n } n int n, m, mx, now, a[5200]; n signed main() { n   read(n), read(m); n   int tmp = 0; n   for (int i = 3; i <= n; ++i) { n     if (i & 1) ++tmp; n     mx += tmp; n   } n   if (m > mx) return puts( -1 ), 0; n   a[1] = 1, a[2] = 2; n   int p = n + 1; n   tmp = 0; n   for (int i = 3; i <= n; ++i) { n     if (i & 1) ++tmp; n     if (now + tmp > m) { n       p = i - 1; n       break; n     } n     now += tmp, a[i] = i; n   } n   m -= now; n   if (m) n     a[p + 1] = p - m * 2 + 1 + p, p += 2; n   else n     ++p; n   for (int i = p; i <= n; ++i) a[i] = 200000000 + i * n; n   for (int i = 1; i <= n; ++i) printf( %d  , a[i]); n   puts(  ); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const long long INF = 1e9 + 7; n const int N = 5e3 + 10; n vector<double> vd; n int flag = 0; n vector<int> check(double x, int sz) { n   vector<int> v; n   int cur = 0; n   double tot = x; n   while (v.size() < sz) { n     int o = tot / 10; n     cur += o; n     v.push_back(cur); n     tot -= o * 10; n     if (v.size() == sz) break; n     tot += x; n   } n   if (flag) vd.push_back(tot); n   return v; n } n double solve(vector<int>& v1, int o = 0) { n   double l = 10 + 1e-10; n   double r = INF; n   int cnt = 200; n   while (cnt--) { n     double mid = (l + r) / 2; n     auto v2 = check(mid, v1.size()); n     for (int i = 0; i < v1.size(); i++) { n       if (v1[i] < v2[i]) { n         r = mid; n         break; n       } n       if (v1[i] > v2[i]) { n         l = mid; n         break; n       } n     } n     if (v1 != v2) continue; n     if (o == 0) n       l = mid; n     else n       r = mid; n   } n   return l; n } n int main() { n   int n; n   cin >> n; n   vector<int> v(n); n   for (auto& x : v) cin >> x; n   double key1 = solve(v, 0); n   double key2 = solve(v, 1); n   flag = 1; n   if (key1 > key2) swap(key1, key2); n   int ans1 = check(key1, n + 1).back(); n   int ans2 = check(key2, n + 1).back(); n   if (abs(vd[0] - 10) <= 1e-8) ans1++; n   if (ans1 == ans2) n     puts( unique ), printf( %d n , ans1), exit(0); n   else n     puts( not unique ); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n long long p[11]; n int main() { n   string s; n   cin >> s; n   int n = s.size(); n   p[0] = 1; n   for (int i = 1; i < n; i++) p[i] = p[i - 1] * 9ll; n   long long ans = 1ll; n   for (char c : s) ans *= (long long)(c -  0 ); n   ans = max(ans, p[n - 1]); n   long long pre = 1; n   for (int i = 1; i <= n; i++) { n     for (long long j = 1; j < s[i - 1] -  0 ; j++) { n       ans = max(ans, pre * j * p[n - i]); n     } n     pre *= (long long)(s[i - 1] -  0 ); n   } n   cout << ans <<   n ; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int main() { n   int n; n   cin >> n; n   string a; n   cin >> a; n   int sum = 0; n   char b[3] = { R ,  G ,  B }; n   for (int i = 1; i < n; i++) { n     if (a[i - 1] == a[i] && a[i] == a[i + 1]) { n       for (int j = 0; j < 3; j++) { n         if (b[j] != a[i]) { n           a[i] = b[j]; n           break; n         } n       } n       sum++; n     } else if (a[i - 1] == a[i]) { n       for (int j = 0; j < 3; j++) { n         if (b[j] != a[i] && b[j] != a[i + 1]) { n           a[i] = b[j]; n           break; n         } n       } n       sum++; n     } n   } n   printf( %d n , sum); n   for (int i = 0; i < n; i++) { n     printf( %c , a[i]); n   } n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int main() { n   long long r, i; n   int flag = 1; n   cin >> r; n   for (i = 1; i <= 1000000; i++) { n     if ((r - i * i - i - 1) > 0 && (r - i * i - i - 1) % (2 * i) == 0) { n       flag = 0; n       break; n     } n   } n   if (flag == 0) n     printf( %lld %lld n , i, (r - i * i - i - 1) / 2 * i); n   else n     puts( NO ); n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int distance(int x1, int y1, int x2, int y2) { n   return (int)ceil(sqrt(pow(x2 - x1, 2) + pow(y2 - y1, 2))); n } n int main() { n   ios::sync_with_stdio(0); n   cin.tie(0); n   cout.tie(0); n   int n, m, x, q, cnt = 0; n   string t; n   char ch; n   map<char, vector<pair<int, int>>> keys; n   int freq[26] = {0}; n   cin >> n >> m >> x; n   for (int i = 1; i <= n; i++) { n     for (int j = 1; j <= m; j++) { n       cin >> ch; n       if (!freq[ch -  a ]) freq[ch -  a ]++; n       keys[ch].push_back(make_pair(i, j)); n     } n   } n   if (keys.count( S )) { n     vector<pair<int, int>> shiftCords = keys[ S ]; n     vector<pair<int, int>> chCords; n     for (int i =  a ; i <=  z ; i++) { n       if (keys.count(i)) { n         chCords = keys[i]; n         bool validDistance = 0; n         for (int j = 0; j < (int)chCords.size(); j++) { n           for (int k = 0; k < (int)shiftCords.size(); k++) { n             if (distance(chCords[j].first, chCords[j].second, n                          shiftCords[k].first, shiftCords[k].second) <= x) { n               freq[i -  a ]++; n               validDistance = 1; n               break; n             } n           } n           if (validDistance) break; n         } n       } n     } n   } n   cin >> q; n   cin >> t; n   for (int i = 0; i < q; i++) { n     char c = t[i]; n     if (islower(c)) { n       if (!freq[c -  a ]) { n         cout << -1 << endl; n         return 0; n       } n     } else { n       c = tolower(c); n       if (!keys.count( S ) || !freq[c -  a ]) { n         cout << -1 << endl; n         return 0; n       } else { n         if (freq[c -  a ] == 1) cnt++; n       } n     } n   } n   cout << cnt << endl; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int main() { n   int k; n   cin >> k; n   int maxP = 0; n   int maxQ = 0; n   for (int i = 0; i < k; i++) { n     int p = 0; n     int q = 0; n     cin >> p; n     cin >> q; n     if (p < q) { n       cout <<  Happy Alex  << endl; n       return 0; n     } n   } n   cout <<  Poor Alex  << endl; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n const int maxn = 4e5 + 10; n const int maxm = 2e5 + 10; n const int inf = 0x3f3f3f3f; n const long long mod = 1e9 + 7; n const double eps = 1e-7; n using namespace std; n long long cnt[25][25], dp[1 << 21]; n int n; n vector<int> col[25]; n int main() { n   ios::sync_with_stdio(false); n   cin.tie(0); n   cout.tie(0); n   cin >> n; n   for (int i = 1; i <= n; i++) { n     int x; n     cin >> x; n     col[x].push_back(i); n   } n   for (int i = 1; i <= 20; ++i) n     for (int j = 1; j <= 20; ++j) n       if (i != j) { n         if (!col[i].size() || !col[j].size()) continue; n         int l = 0; n         for (int k = 0; k < col[i].size(); ++k) { n           while (true) { n             if (l == col[j].size() - 1 || col[j][l + 1] > col[i][k]) break; n             l++; n           } n           if (col[j][l] < col[i][k]) cnt[i][j] += l + 1; n         } n       } n   memset(dp, 0x3f, sizeof dp); n   dp[0] = 0; n   for (int S = 0; S < 1 << 20; ++S) { n     for (int i = 0; i < 20; ++i) n       if (!(S >> i & 1)) { n         long long sum(0); n         for (int j = 0; j < 20; ++j) n           if (S >> j & 1) sum += cnt[j + 1][i + 1]; n         dp[S | (1 << i)] = min(dp[S | (1 << i)], dp[S] + sum); n       } n   } n   cout << dp[(1 << 20) - 1] << endl; n   return ~~(0 - 0); n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); } n long long lcm(long long a, long long b) { return a * (b / gcd(a, b)); } n int main() { n   ios::sync_with_stdio(false); n   cin.tie(0); n   cout.tie(0); n   long long v; n   cin >> v; n   for (long long i = 0; i < v; i++) { n     vector<long double> arr(250); n     for (long long j = 0; j < 250; j++) cin >> arr[j]; n     long double avg1 = 0; n     for (long long j = 0; j < 250; j++) avg1 += arr[j]; n     avg1 /= 250.0; n     sort(arr.begin(), arr.end()); n     long double v1 = ((arr[249] - arr[0]) * (arr[249] - arr[0])) / 12.0; n     long double v2 = 0; n     for (long long j = 0; j < 250; j++) n       v2 += ((avg1 - arr[j]) * (avg1 - arr[j])); n     v2 /= 250.0; n     long double avg2 = 0; n     if (abs(v2 - avg1) > abs(v1 - v2)) n       cout <<  uniform n ; n     else n       cout <<  poisson n ; n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n bool check(string new_l, string old_l) { n   int len_1; n   int col_izm; n   col_izm = 0; n   len_1 = new_l.length(); n   if (len_1 == old_l.length()) { n     for (int i = 0; i < len_1; i++) { n       if (new_l[i] == old_l[i]) { n         col_izm++; n       } else if (((new_l[i] ==  1 ) || (new_l[i] ==  i ) || (new_l[i] ==  l ) || n                   (new_l[i] ==  I ) || (new_l[i] ==  L )) && n                  ((old_l[i] ==  1 ) || (old_l[i] ==  i ) || (old_l[i] ==  l ) || n                   (old_l[i] ==  I ) || (old_l[i] ==  L ))) { n         col_izm++; n       } else if (((new_l[i] ==  0 ) || (new_l[i] ==  o ) || n                   (new_l[i] ==  O )) && n                  ((old_l[i] ==  0 ) || (old_l[i] ==  o ) || n                   (old_l[i] ==  O ))) { n         col_izm++; n       } else if (((new_l[i] - old_l[i]) == 32) || n                  ((new_l[i] - old_l[i]) == -32)) { n         col_izm++; n       } else n         return true; n     } n     if (col_izm == len_1) n       return false; n     else n       return true; n   } else n     return true; n } n int main() { n   string n_login, login; n   int col; n   cin >> n_login; n   cin >> col; n   for (int i = 0; i < col; i++) { n     cin >> login; n     if (!check(n_login, login)) { n       cout <<  No  << endl; n       return 0; n     } n   } n   cout <<  Yes  << endl; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n int cmp(const void *a, const void *b) { return *((int *)a) - *((int *)b); } n int maximum(int a, int b) { n   if (a > b) { n     return a; n   } else { n     return b; n   } n } n int minimum(int a, int b) { n   if (a < b) { n     return a; n   } else { n     return b; n   } n } n int main() { n   int a[2000]; n   int p = 0, q = 1, x = 1, i, j; n   int pl, pr, vl, vr, k; n   long long c = 0, d; n   a[0] = 0; n   for (i = 0; i < 9; i++) { n     for (j = p; j < q; j++) { n       a[x++] = a[j] * 10 + 4; n       a[x++] = a[j] * 10 + 7; n     } n     p = q; n     q = x; n   } n   qsort(a, x, sizeof(int), cmp); n   a[x] = 1000000001; n   scanf( %d %d %d %d %d , &pl, &pr, &vl, &vr, &k); n   d = (long long)(pr - pl + 1) * (vr - vl + 1); n   for (i = 1; i <= x - k; i++) { n     if (pl <= a[i] && vr >= a[i + k - 1]) { n       int s1 = minimum(a[i], pr); n       int s2 = maximum(a[i - 1] + 1, pl); n       int t1 = maximum(a[i + k - 1], vl); n       int t2 = minimum(a[i + k] - 1, vr); n       if (s1 - s2 >= 0 && t2 - t1 >= 0) { n         c += (long long)(s1 - s2 + 1) * (t2 - t1 + 1); n       } n     } n     if (vl <= a[i] && pr >= a[i + k - 1]) { n       int s1 = minimum(a[i], vr); n       int s2 = maximum(a[i - 1] + 1, vl); n       int t1 = maximum(a[i + k - 1], pl); n       int t2 = minimum(a[i + k] - 1, pr); n       if (s1 - s2 >= 0 && t2 - t1 >= 0) { n         c += (long long)(s1 - s2 + 1) * (t2 - t1 + 1); n       } n     } n   } n   if (k == 1) { n     for (i = 1; i < x; i++) { n       if (pl <= a[i] && pr >= a[i] && vl <= a[i] && vr >= a[i]) c--; n     } n   } n   printf( %.20lf n , (double)c / d); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int N = 5100; n char Map[N][N]; n int dp[N][N]; n int main() { n   int i, j; n   int line, row; n   scanf( %d%d , &line, &row); n   for (i = 0; i < line; i++) scanf( %s , Map[i]); n   for (i = 0; i < line; i++) { n     for (j = row - 1; j >= 0; j--) { n       if (Map[i][j] ==  1 ) n         dp[j][i] = dp[j + 1][i] + 1; n       else n         dp[j][i] = 0; n     } n   } n   int ret = 0; n   for (i = 0; i < row; i++) { n     sort(dp[i], dp[i] + line); n     for (j = 0; j < line; j++) { n       ret = max(ret, (line - j) * dp[i][j]); n     } n   } n   printf( %d n , ret); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n long long s[1000005]; n int main(void) { n   int n, d, ans = 0; n   cin >> n >> d >> s[1]; n   for (int i = 2; i <= n; ++i) { n     cin >> s[i]; n     int cnt = 0; n     if (s[i] <= s[i - 1]) cnt = (s[i - 1] - s[i] + d) / d; n     s[i] += cnt * d; n     ans += cnt; n   } n   return cout << ans <<   n , 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n #pragma GCC optimize( Ofast ) n #pragma GCC target( sse,sse2,sse3,sse3,sse4,popcnt,abm,mmx ) n using namespace std; n const double eps = 0.000001; n const long double pi = acos(-1); n const int maxn = 1e7 + 9; n const int mod = 1e9 + 7; n const long long MOD = 1e18 + 9; n const long long INF = 1e18 + 123; n const int inf = 2e9 + 11; n const int mxn = 1e6 + 9; n const int N = 3e5 + 123; n const int PRI = 555557; n const int pri = 997; n int tests = 1; n int n, m, q; n int sz[N], pr[N], ans[N]; n bool u[N]; n vector<int> g[N]; n void dfs(int v, int p = 1) { n   sz[v] = 1; n   pr[v] = p; n   for (int to : g[v]) { n     if (to == p) continue; n     dfs(to, v); n     sz[v] += sz[to]; n   } n } n void dfs_center(int v) { n   u[v] = 1; n   if (sz[v] == 1) { n     ans[v] = v; n     return; n   } n   int mx = g[v].back(); n   for (int to : g[v]) { n     if (u[to]) continue; n     dfs_center(to); n     if (sz[mx] < sz[to]) { n       mx = to; n     } n   } n   int c = ans[mx]; n   while (sz[v] > sz[c] * 2) { n     c = pr[c]; n   } n   ans[v] = c; n } n inline void Solve() { n   cin >> n >> q; n   for (int i = 2; i <= n; i++) { n     int x; n     cin >> x; n     g[x].push_back(i); n   } n   dfs(1); n   dfs_center(1); n   while (q--) { n     int x; n     cin >> x; n     cout << ans[x] <<   n ; n   } n } n int main() { n   ios_base::sync_with_stdio(0), cin.tie(0); n   while (tests--) { n     Solve(); n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int main() { n   string s; n   cin >> s; n   regex w( WUB ); n   cout << regex_replace(s, w,    ); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int main() { n   long n, m, i, j; n   char x[2], y[2], t; n   cin >> n >> m; n   cin >> x[0]; n   for (i = 2; i < n; i++) cin >> t; n   cin >> x[1] >> y[0]; n   y[0] = (y[0] ==  ^ ) ?  >  :  < ; n   for (j = 2; j < m; j++) cin >> t; n   cin >> y[1]; n   y[1] = (y[1] ==  ^ ) ?  >  :  < ; n   if (x[0] == y[0] && x[1] == y[1] && x[0] != x[1]) n     cout <<  YES ; n   else n     cout <<  NO ; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n long long MOD = int(1e9) + 7; n int debug = 0; n const int N = int(2e3) + 5; n using namespace std; n int a[N], b[N], p[N]; n int main() { n   int i, j, n, t; n   ios::sync_with_stdio(false); n   cin >> n; n   for (i = 0; i < n; i++) cin >> a[i]; n   for (i = 0; i < n; i++) cin >> b[i]; n   int ans = 0; n   vector<pair<int, int> > moves; n   for (i = 0; i < n; i++) p[a[i]] = i; n   for (i = 0; i < n; i++) { n     int pos = -1; n     for (j = 0; j < n; j++) n       if (debug) n         cerr <<  j  n              <<  :   << j <<   |   n              <<  b[j]  n              <<  :   << b[j] << endl; n     ; n     for (j = 0; j < n; j++) n       if (p[b[j]] == i) pos = j; n     if (j == i) continue; n     if (debug) n       cerr <<  pos  n            <<  :   << pos <<   |   n            <<  i  n            <<  :   << i << endl; n     ; n     int cur = pos; n     for (j = pos - 1; j >= i; j--) { n       if (p[b[j]] >= cur) { n         ans += cur - j; n         moves.push_back(make_pair(j, cur)); n         b[cur] = b[j]; n         b[j] = i; n         cur = j; n       } n     } n   } n   cout << ans <<   n ; n   reverse(moves.begin(), moves.end()); n   cout << moves.size() <<   n ; n   for (i = 0; i < moves.size(); i++) n     cout << moves[i].second + 1 <<     << moves[i].first + 1 <<   n ; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int maxn = 3079; n int r, c, n, k; n vector<int> nx(maxn, -1), pv(maxn, -1), kth(maxn, -1); n vector<vector<int> > my(maxn); n class point { n  public: n   int x, y; n }; n bool cmp(point& a, point& b) { return (a.y == b.y ? a.x < b.x : a.y < b.y); } n vector<point> v(maxn); n long long sum(int i) { return (v[i].y - v[pv[i]].y) * (c + 1 - v[kth[i]].y); } n int main() { n   ios::sync_with_stdio(false); n   cin.tie(0); n   cin >> r >> c >> n >> k; n   long long ans = 0; n   int m = n + k + 1; n   for (int i = 1; i <= n; i++) cin >> v[i].x >> v[i].y; n   v[0] = {r + 1, 0}; n   for (int i = n + 1; i < m; i++) v[i] = {r + 1, c + 1}; n   sort(v.begin(), v.begin() + m, cmp); n   for (int i = n + 1; i < m; i++) n     kth[i] = m - 1, pv[i] = i - 1, nx[i] = min(m - 1, i + 1); n   for (int i = m - 1; i >= 0; i--) my[v[i].x].push_back(i); n   for (int x1 = 1; x1 <= r; x1++) { n     int p = 0; n     for (int i = 1; i <= n; i++) { n       if (v[i].x < x1) continue; n       nx[p] = i, pv[i] = p; n       p = i; n     } n     nx[p] = n + 1, pv[n + 1] = p; n     kth[p] = (k == 1 ? p : pv[m - 1]); n     for (int i = p; i >= 0; i = pv[i]) kth[i] = pv[kth[nx[i]]]; n     long long cur = 0; n     for (int i = nx[0]; i <= n; i = nx[i]) cur += sum(i); n     for (int x2 = r; x2 >= x1; x2--) { n       ans += cur; n       for (int i : my[x2]) { n         cur -= sum(i); n         for (int j = pv[i], cnt = 0; cnt < k - 1 && j; cnt++, j = pv[j]) { n           cur -= sum(j); n           if (j < i) kth[j] = nx[kth[j]]; n           cur += sum(j); n         } n         cur -= sum(nx[i]); n         nx[pv[i]] = nx[i], pv[nx[i]] = pv[i]; n         cur += sum(nx[i]); n       } n     } n   } n   cout << ans <<   n ; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int N = 5e5 + 233; n const int INF = numeric_limits<int>::max(); n void read(int &x) { n   x = 0; n   char ch = getchar(); n   int f = 1; n   while (!isdigit(ch)) (ch ==  -  ? f = -1 : 0), ch = getchar(); n   while (isdigit(ch)) x = x * 10 + ch -  0 , ch = getchar(); n   x *= f; n } n int f[N][105], g[105]; n int n, K, p, a[N], nw, s[N]; n int x, sum, st[N], tp; n signed main() { n   memset(g, 0x7f, sizeof(g)); n   memset(f, 0x7f, sizeof(f)); n   read(n); n   read(K); n   read(p); n   if (p * K > n) { n     for (int i = 1; i <= n; ++i) { n       read(x); n       x %= p; n       a[i] = x; n       sum = (sum + a[i]) % p; n       f[i][1] = sum; n       g[1] = sum; n       for (int j = min(K, i); j >= 2; --j) n         if (i == j) { n           f[i][j] = f[i - 1][j - 1] + x; n           g[j] = x; n         } else { n           int l = f[i - 1][j - 1] + x; n           int r = f[i - 1][j] + x; n           if (g[j] + x >= p) r -= p; n           if (l < r) n             f[i][j] = l, g[j] = x; n           else if (l > r) n             f[i][j] = r, g[j] = (g[j] + x) % p; n           else n             f[i][j] = l, g[j] = max(x, (g[j] + x) % p); n         } n     } n     return printf( %d , f[n][K]), 0; n   } n   for (int i = 1; i <= n; ++i) n     read(a[i]), a[i] %= p, sum += a[i], s[i] = (s[i - 1] + a[i]) % p; n   for (int i = 1; i <= n - 1; ++i) { n     int pos = upper_bound(st + 1, st + 1 + tp, s[i]) - st; n     if (pos > tp) ++tp; n     st[pos] = s[i]; n   } n   int pos = upper_bound(st + 1, st + 1 + tp, s[n]) - st; n   if (pos >= K) n     printf( %d , s[n]); n   else n     printf( %d , s[n] + p); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int n, k; n int y; n vector<pair<int, int> > p[3]; n int dp[111][111][3]; n bool check(int x, int t, int y) { n   for (int i = 0; i < p[y].size(); i++) { n     if (x >= p[y][i].first - 2 * t && x <= p[y][i].second - 2 * t) return false; n   } n   return true; n } n int go(int x, int t, int y) { n   if (x == n - 1) return true; n   int& res = dp[x][t][y]; n   if (res != -1) return res; n   res = 0; n   for (int i = 0; i < p[y].size(); i++) { n     if (x >= p[y][i].first - 2 * t && x <= p[y][i].second - 2 * t || n         x + 1 >= p[y][i].first - 2 * t && x + 1 <= p[y][i].second - 2 * t) n       return res = false; n   } n   if (check(x + 1, t, y)) res |= go(x + 1, t + 1, y); n   if (check(x + 1, t, min(2, y + 1))) res |= go(x + 1, t + 1, min(2, y + 1)); n   if (check(x + 1, t, max(y - 1, 0))) res |= go(x + 1, t + 1, max(y - 1, 0)); n   return res; n } n void R(string s, int v) { n   int i = 0; n   if (s[0] ==  s ) { n     y = v; n     s[0] =  . ; n   } n   while (i < s.size()) { n     if (s[i] !=  . ) { n       int l = i; n       int r = l; n       while (i < s.size() && s[i] == s[l]) i++; n       r = i - 1; n       i--; n       p[v].push_back(make_pair(l, r)); n       if (i == s.size() - 1) return; n     } n     i++; n   } n } n int main() { n   int t; n   cin >> t; n   for (int i = 0; i < t; i++) { n     p[0].clear(); n     p[1].clear(); n     p[2].clear(); n     memset(dp, -1, sizeof(dp)); n     cin >> n >> k; n     string s1, s2, s3; n     cin >> s1 >> s2 >> s3; n     R(s1, 0); n     R(s2, 1); n     R(s3, 2); n     if (go(0, 0, y)) n       cout <<  YES  << endl; n     else n       cout <<  NO  << endl; n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n namespace IO { n const int sz = 1 << 15; n char inbuf[sz], outbuf[sz]; n char *pinbuf = inbuf + sz; n char *poutbuf = outbuf; n inline char _getchar() { n   if (pinbuf == inbuf + sz) fread(inbuf, 1, sz, stdin), pinbuf = inbuf; n   return *(pinbuf++); n } n inline void _putchar(char x) { n   if (poutbuf == outbuf + sz) fwrite(outbuf, 1, sz, stdout), poutbuf = outbuf; n   *(poutbuf++) = x; n } n inline void flush() { n   if (poutbuf != outbuf) n     fwrite(outbuf, 1, poutbuf - outbuf, stdout), poutbuf = outbuf; n } n }  // namespace IO n inline int read() { n   int x = 0, p = 1; n   char c = IO::_getchar(); n   while (c <  0  || c >  9 ) { n     if (c ==  - ) p = -1; n     c = IO::_getchar(); n   } n   while (c >=  0  && c <=  9 ) x = x * 10 + c - 48, c = IO::_getchar(); n   return x * p; n } n namespace Mymath { n long long qp(long long x, long long p, long long mod) { n   long long ans = 1; n   while (p) { n     if (p & 1) ans = ans * x % mod; n     x = x * x % mod; n     p >>= 1; n   } n   return ans; n } n long long inv(long long x, long long mod) { return qp(x, mod - 2, mod); } n long long C(long long N, long long K, long long fact[], long long mod) { n   return fact[N] * inv(fact[K], mod) % mod * inv(fact[N - K], mod) % mod; n } n template <typename Tp> n Tp gcd(Tp A, Tp B) { n   if (B == 0) return A; n   return gcd(B, A % B); n } n template <typename Tp> n Tp lcm(Tp A, Tp B) { n   return A * B / gcd(A, B); n } n };  // namespace Mymath n const int Maxn = 705; n const long long mod = 1e9 + 7; n int dp[Maxn][3][Maxn][11]; n int tot[11][Maxn]; n char c[Maxn]; n int n; n void Add(int &x, int y) { n   x += y; n   if (x >= mod) x -= mod; n } n int main() { n   scanf( %s , c); n   n = strlen(c); n   for (int i = 0; i <= 9; i++) dp[0][1][0][i] = 1; n   for (int i = 0; i < n; i++) { n     int curv = c[i] -  0 ; n     for (int j = 0; j <= i; j++) { n       for (int k = 0; k <= 9; k++) { n         if (i) n           for (int l = 0; l < 3; l++) Add(tot[k][j], dp[i][l][j][k]); n         Add(dp[i + 1][1][j + (curv >= k)][k], dp[i][1][j][k]); n         for (int l = 0; l <= 9; l++) { n           if (!i && !l) continue; n           if (l == curv) continue; n           Add(dp[i + 1][(l < curv) ? 0 : 2][j + (l >= k)][k], dp[i][1][j][k]); n         } n         for (int l = 0; l <= 9; l++) { n           if (!i && !l) continue; n           Add(dp[i + 1][0][j + (l >= k)][k], dp[i][0][j][k]); n           Add(dp[i + 1][2][j + (l >= k)][k], dp[i][2][j][k]); n         } n       } n     } n   } n   for (int j = 0; j <= n; j++) { n     for (int k = 0; k <= 9; k++) { n       for (int l = 0; l < 2; l++) Add(tot[k][j], dp[n][l][j][k]); n     } n   } n   for (int i = 0; i <= 9; i++) { n     for (int j = n; j >= 0; j--) { n       Add(tot[i][j], tot[i][j + 1]); n     } n   } n   long long ans = 0; n   int w = 1; n   for (int i = 0; i < n; i++) { n     for (int j = 1; j <= 9; j++) { n       int cnt = tot[j][i + 1] - tot[j + 1][i + 1]; n       if (cnt < 0) cnt += mod; n       ans += 1ll * cnt * w % mod * j; n       ans %= mod; n     } n     w = 1ll * w * 10 % mod; n   } n   printf( %I64d n , ans); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n template <typename T> n std::ostream &operator<<(std::ostream &out, vector<T> &v) { n   for (typename vector<T>::size_type i = 0; i < v.size(); ++i) n     out << v[i] <<    ; n   out <<   n ; n   return out; n } n template <typename T> n std::ostream &operator<<(std::ostream &out, vector<vector<T> > &v) { n   for (size_t i = 0; i < v.size(); ++i) { n     for (size_t j = 0; j < v[i].size(); ++j) { n       out << v[i][j] <<    ; n     } n     out <<   n ; n   } n   return out; n } n int main() { n   std::ios::sync_with_stdio(false); n   cin.tie(0); n   cout.tie(0); n   long long n, k; n   cin >> n >> k; n   vector<long long> divisors; n   for (long long i = 1; i * i <= n; ++i) { n     if (n % i == 0) { n       divisors.push_back(i); n       if (n / i != i) { n         divisors.push_back(n / i); n       } n     } n   } n   if (k > divisors.size()) { n     cout <<  -1 n ; n     return 0; n   } n   sort(divisors.begin(), divisors.end()); n   cout << divisors[k - 1] <<   n ; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int maxn = 100000; n struct node { n   int n; n   int i; n   node(int n, int i) : n(n), i(i) {} n   node() {} n   bool operator<(const node& n1) const { return n < n1.n; } n   bool is_happy() const { n     int a = n; n     while (a) { n       if (a % 10 != 7 && a % 10 != 4) return false; n       a /= 10; n     } n     return true; n   } n }; n node nodes[maxn]; n int rev[maxn]; n inline void sw(int i, int j, vector<pair<int, int> >& ans) { n   ans.push_back(pair<int, int>(nodes[i].i, nodes[j].i)); n   swap(nodes[i].i, nodes[j].i); n   rev[nodes[i].i] = i; n   rev[nodes[j].i] = j; n } n int main() { n   int n; n   scanf( %d , &n); n   bool sorted = true; n   int x = -1, prev; n   for (int i = 0; i < n; i++) { n     prev = x; n     scanf( %d , &x); n     if (prev > x) sorted = false; n     nodes[i] = node(x, i); n   } n   if (sorted) { n     printf( 0 n ); n     return 0; n   } n   sort(nodes, nodes + n); n   for (int i = 0; i < n; i++) { n     rev[nodes[i].i] = i; n   } n   int happy = -1; n   for (int i = 0; i < n; i++) { n     if (nodes[i].is_happy()) { n       happy = i; n       break; n     } n   } n   if (happy == -1) { n     printf( -1 n ); n     return 0; n   } n   vector<pair<int, int> > ans; n   for (int i = 0; i < n; i++) n     if (i != happy && nodes[i].i != i) { n       if (rev[i] != happy) sw(rev[i], happy, ans); n       sw(happy, i, ans); n     } n   printf( %d n , ans.size()); n   for (int i = 0; i < ans.size(); i++) { n     printf( %d %d n , ans[i].first + 1, ans[i].second + 1); n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int Mod = 1e9 + 7; n int qpow(long long a, long long b) { n   long long c = 1; n   while (b) { n     if (b & 1) c = c * a % Mod; n     if (b >>= 1) a = a * a % Mod; n   } n   return c; n } n int n; n long long a; n int p, q; n int main() { n   scanf( %d , &n); n   bool minus = 1; n   q = 2; n   for (int i = 1; i <= n; i++) { n     scanf( %I64d , &a); n     if (!(a & 1)) minus = 0; n     q = qpow(q, a); n   } n   q = q * 500000004ll % Mod; n   if (minus) { n     p = q - 1; n     if (p < 0) p += Mod; n   } else n     p = q + 1; n   p = p * 333333336ll % Mod; n   printf( %d/%d n , p, q); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n long long int dx[4] = {-1, 0, 0, +1}; n long long int dy[4] = {0, -1, +1, 0}; n const long long int LINF = 1e18; n const long long int INF = 1e9; n const long long int mod = 1e9 + 7; n long long int power(long long int a, long long int b, long long int m) { n   if (b == 0) return 1; n   if (b == 1) return a % m; n   long long int t = power(a, b / 2, m); n   t = (t * t) % m; n   if (b & 1) t = (t * a) % m; n   return t; n } n long long int modInverse(long long int a, long long int m) { n   return power(a, m - 2, m); n } n int main() { n   ios_base::sync_with_stdio(false); n   cin.tie(NULL); n   cout.tie(NULL); n   long long int t; n   cin >> t; n   while (t--) { n     long long int n, ans = 0, i, j; n     string ip; n     cin >> ip; n     long long int sz = ip.size(); n     if (ip[0] ==  ? ) { n       if (sz >= 2 && ip[1] ==  a ) n         ip[0] =  b ; n       else n         ip[0] =  a ; n     } n     for (long long int i = 1; i <= -1 + ip.size(); i++) { n       if (ip[i] ==  ? ) { n         if (ip[i - 1] ==  a ) { n           if ((i + 1) < sz && ip[i + 1] ==  b ) n             ip[i] =  c ; n           else n             ip[i] =  b ; n         } else if (ip[i - 1] ==  b ) { n           if ((i + 1) < sz && ip[i + 1] ==  a ) n             ip[i] =  c ; n           else n             ip[i] =  a ; n         } else if (ip[i - 1] ==  c ) { n           if ((i + 1) < sz && ip[i + 1] ==  a ) n             ip[i] =  b ; n           else n             ip[i] =  a ; n         } else n           ip[i] =  a ; n       } n     } n     bool poss = true; n     for (long long int i = 1; i <= sz - 1; i++) { n       if (ip[i] == ip[i - 1]) { n         cout << -1 << endl; n         poss = false; n         break; n       } n     } n     if (poss) cout << ip << endl; n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int n, a[105], b[105], c[105], tot, ans; n char s[105]; n int main() { n   scanf( %d , &n); n   scanf( %s , s + 1); n   for (int i = 1; i <= n; i++) { n     scanf( %d%d , &a[i], &b[i]); n     c[i] = s[i] -  0 ; n     if (c[i] == 1) tot++; n   } n   ans = tot; n   for (int i = 1; i <= 125; i++) { n     for (int j = 1; j <= n; j++) { n       if (i < b[j]) continue; n       int k = i - b[j]; n       if (k % a[j] != 0) continue; n       tot -= c[j]; n       c[j] ^= 1; n       tot += c[j]; n     } n     ans = max(ans, tot); n   } n   printf( %d n , ans); n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int INF = 0x7fffffff; n const int oo = 0x3f3f3f3f; n template <typename T> n inline void rd(T &x) { n   x = 0; n   int f = 1; n   char CH = getchar(); n   while (!isdigit(CH)) { n     if (CH ==  - ) f = 0; n     CH = getchar(); n   } n   while (isdigit(CH)) { n     x = ((x + (x << 2)) << 1) + (CH - 48); n     CH = getchar(); n   } n   x = (f == 1) ? x : -x; n   return; n } n const int MXN = 2e6; n int a[MXN], n; n inline void solve() { n   long long fuck; n   rd(fuck); n   if (fuck > 36) { n     cout << -1; n     return; n   } n   if (fuck == 1) n     cout << 6; n   else if (fuck == 2) n     cout << 8; n   else if (fuck > 2) { n     while (fuck > 2) fuck -= 2, cout << 8; n     if (fuck == 1) cout << 0; n     if (fuck == 2) cout << 8; n   } n } n int main() { solve(); } n "}
+{"func_code_string": "#include <bits/stdc++.h> n const int MAXN = 100; n char s[MAXN + 5]; n int main() { n   int n, p, q; n   scanf( %d%d%d , &n, &p, &q); n   scanf( %s , s); n   for (int i = 0; p * i <= n; i++) { n     if ((n - p * i) % q == 0) { n       int j = (n - p * i) / q; n       printf( %d n , i + j); n       int pos = 0; n       for (int k = 1; k <= i; k++) { n         for (int l = 1; l <= p; l++) { n           printf( %c , s[pos]); n           pos++; n         } n         puts(  ); n       } n       for (int k = 1; k <= j; k++) { n         for (int l = 1; l <= q; l++) { n           printf( %c , s[pos]); n           pos++; n         } n         puts(  ); n       } n       return 0; n     } n   } n   puts( -1 ); n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n template <typename T> n void read(T &x) { n   x = 0; n   bool f = 0; n   char c = getchar(); n   for (; !isdigit(c); c = getchar()) n     if (c ==  - ) f = 1; n   for (; isdigit(c); c = getchar()) x = x * 10 + (c ^ 48); n   if (f) x = -x; n } n long long T, n, m, k; n int main() { n   read(T); n   while (T--) { n     read(n), read(k); n     k = k * k; n     if ((n & 1) != (k & 1) || k > n) n       puts( NO ); n     else n       puts( YES ); n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int mxn(3e5 + 10), mxm(4e5 + 10); n const long long modl(998244353); n int nm, n, m, p, t, k; n int ans; n int a[mxn], b[mxn], c[mxn]; n int main() { n   ios_base::sync_with_stdio(false); n   cin >> nm; n   while (cin >> n >> m) { n     ans = max(0, n + m - 3) / m + 1; n     cout << ans; n     cout << endl; n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int N = 1e5 + 27; n vector<vector<int>> g; n int t, tin[N], tout[N], up[N][20], sz[N], d[N]; n void dfs(int v, int p = 0, int dp = 0) { n   tin[v] = t++; n   d[v] = dp; n   sz[v] = 1; n   up[v][0] = p; n   for (int i = 1; i < 20; i++) up[v][i] = up[up[v][i - 1]][i - 1]; n   for (int u : g[v]) { n     if (u != p) { n       dfs(u, v, dp + 1); n       sz[v] += sz[u]; n     } n   } n   tout[v] = t++; n } n bool is(int a, int b) { return tin[a] <= tin[b] && tout[b] <= tout[a]; } n int get_up(int a, int b) { n   for (int i = 18; i >= 0; i--) { n     if (!is(up[a][i], b)) a = up[a][i]; n   } n   return a; n } n int lca(int a, int b) { n   if (is(a, b)) return a; n   if (is(b, a)) return b; n   return up[get_up(a, b)][0]; n } n int main() { n   int n; n   cin >> n; n   g.resize(n + 1); n   for (int i = 1; i < n; i++) { n     int a, b; n     cin >> a >> b; n     g[a].push_back(b); n     g[b].push_back(a); n   } n   tin[0] = -1; n   tout[0] = 3 * N; n   dfs(1); n   int q; n   cin >> q; n   for (int o = 0; o < q; o++) { n     int a, b; n     cin >> a >> b; n     int l = lca(a, b); n     if (a == b) n       cout << n <<   n ; n     else if (d[b] - d[l] == d[a] - d[l]) { n       a = get_up(a, l); n       b = get_up(b, l); n       cout << n - sz[a] - sz[b] <<   n ; n     } else { n       if (d[a] < d[b]) swap(a, b); n       int dist = d[a] + d[b] - 2 * d[l]; n       if (dist % 2) { n         puts( 0 ); n         continue; n       } n       dist /= 2; n       int u = a; n       for (int i = 18; i >= 0; i--) { n         if (d[a] - d[up[u][i]] < dist) u = up[u][i]; n       } n       int m = up[u][0]; n       cout << sz[m] - sz[u] <<   n ; n     } n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n string s; n int l, t, c, a; n bool vis[26]; n bool ok = false; n int main() { n   cin >> s; n   l = s.size(); n   if (l < 26) { n     cout << -1 << endl; n     return 0; n   } n   for (int i = 0; i < l; ++i) { n     memset(vis, 0, sizeof vis); n     t = c = 0; n     for (int j = i; j < i + 26 && j < l; ++j) { n       if (vis[s[j] -  A ]) break; n       if (s[j] ==  ? ) { n         c++; n         continue; n       } n       vis[s[j] -  A ]++; n       t++; n     } n     if (c + t == 26) { n       a = i; n       ok = true; n       break; n     } n   } n   if (!ok) { n     cout << -1 << endl; n     return 0; n   } n   queue<char> q; n   for (int j = 0; j < 26; ++j) { n     if (!vis[j]) q.push((char)j +  A ); n   } n   for (int i = 0; i < a; ++i) n     if (s[i] !=  ? ) n       cout << s[i]; n     else n       cout <<  A ; n   for (int i = a; i < 26 + a; ++i) n     if (s[i] !=  ? ) n       cout << s[i]; n     else { n       cout << q.front(); n       q.pop(); n     } n   for (int i = 26 + a; i < l; ++i) n     if (s[i] !=  ? ) n       cout << s[i]; n     else n       cout <<  A ; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int main(void) { n   ios::sync_with_stdio(false); n   cin.tie(NULL); n   long long k; n   cin >> k; n   long long second = 2000 + k; n   long long ar[2000]; n   ar[0] = -1; n   for (long long int i = 1; i < 2000; i++) { n     if (second <= 1000000) { n       ar[i] = second; n       second = 0; n     } else { n       ar[i] = 1000000; n       second -= 1000000; n     } n   } n   cout << 2000 <<   n ; n   for (long long int i = 0; i < 2000; i++) n     cout << ar[i] << ((i == (2000 - 1)) ?   n  :    ); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n vector<long long> blame(1002, 0); n vector<bool> visited(1002, false); n long long dfs(long long u) { n   if (visited[u]) return u; n   visited[u] = true; n   return dfs(blame[u]); n } n int main() { n   ios_base::sync_with_stdio(false); n   cin.tie(0); n   cout.tie(0); n   long long n; n   cin >> n; n   for (long long i = 1; i <= n; i++) { n     cin >> blame[i]; n   } n   for (long long i = 1; i <= n; i++) { n     cout << dfs(i) <<    ; n     fill(visited.begin(), visited.end(), false); n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n long long g; n void ex_gcd(long long a, long long b, long long& x, long long& y) { n   if (!b) { n     g = a; n     x = 1, y = 0; n   } else { n     ex_gcd(b, a % b, y, x); n     y = y - a / b * x; n   } n } n int main() { n   long long a, b, c; n   scanf( %lld%lld%lld , &a, &b, &c); n   long long x, y; n   ex_gcd(a, b, x, y); n   if (c % g != 0) return 0 * printf( -1 n ); n   return 0 * printf( %lld %lld n , x * (-c / g), y * (-c / g)); n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int n, m, x[300300], y[300300]; n vector<int> graph[300300]; n int counter, dfs_num[300300], dfs_low[300300], dfs_parent[300300]; n vector<pair<int, int> > bs; n void bridges(int u) { n   dfs_low[u] = dfs_num[u] = counter++; n   for (int v : graph[u]) { n     if (!dfs_num[v]) { n       dfs_parent[v] = u; n       bridges(v); n       if (dfs_low[v] > dfs_num[u]) bs.push_back(pair<int, int>(u, v)); n       dfs_low[u] = min(dfs_low[u], dfs_low[v]); n     } else if (v != dfs_parent[u]) { n       dfs_low[u] = min(dfs_low[u], dfs_num[v]); n     } n   } n } n vector<pair<int, int> > ng[300300]; n struct subset { n   int parent, _rank; n } subsets[300300]; n int Find(int i) { n   if (subsets[i].parent != i) subsets[i].parent = Find(subsets[i].parent); n   return subsets[i].parent; n } n void Union(int x, int y) { n   int xroot = Find(x), yroot = Find(y); n   if (subsets[xroot]._rank < subsets[yroot]._rank) n     subsets[xroot].parent = yroot; n   else if (subsets[xroot]._rank > subsets[yroot]._rank) n     subsets[yroot].parent = xroot; n   else { n     subsets[yroot].parent = xroot; n     subsets[xroot]._rank++; n   } n } n int maxi = 1, dist[300300]; n void dfs(int u, int p, int d) { n   if (d > dist[maxi]) maxi = u; n   dist[u] = d; n   for (pair<int, int> v : ng[u]) { n     if (v.first != p) { n       dfs(v.first, u, d + v.second); n     } n   } n } n int main() { n   scanf( %d %d , &n, &m); n   for (int i = 0; i < m; i++) { n     scanf( %d %d , &x[i], &y[i]); n     graph[x[i]].push_back(y[i]); n     graph[y[i]].push_back(x[i]); n   } n   counter = 1; n   for (int i = 1; i <= n; i++) n     if (!dfs_num[i]) bridges(i); n   for (int i = 1; i <= n; i++) { n     subsets[i].parent = i; n     subsets[i]._rank = 1; n   } n   for (int i = 0; i < bs.size(); i++) { n     Union(bs[i].first, bs[i].second); n     ng[bs[i].first].push_back(pair<int, int>(bs[i].second, 1)); n     ng[bs[i].second].push_back(pair<int, int>(bs[i].first, 1)); n   } n   for (int i = 0; i < m; i++) { n     if (Find(x[i]) == Find(y[i])) continue; n     Union(x[i], y[i]); n     ng[x[i]].push_back(pair<int, int>(y[i], 0)); n     ng[y[i]].push_back(pair<int, int>(x[i], 0)); n   } n   dfs(1, 0, 0); n   memset(dist, 0, sizeof dist); n   dfs(maxi, 0, 0); n   printf( %d n , dist[maxi]); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int A[100005], D[100005], n, m, w, L[100005]; n bool go(int h) { n   fill(L, L + n, 0); n   for (int i = 0; i < n; ++i) D[i] = max(h - A[i], 0); n   int pow = 0, cap = m, d; n   for (int i = 0; i < n; ++i) { n     pow -= L[i]; n     d = max(D[i] - pow, 0); n     if (d > cap) return false; n     pow += d; n     cap -= d; n     if (i + w < n) L[i + w] += d; n   } n   return true; n } n int main() { n   std::ios::sync_with_stdio(false); n   int mini = 2e9; n   cin >> n >> m >> w; n   for (int i = 0; i < n; ++i) { n     cin >> A[i]; n     mini = min(mini, A[i]); n   } n   int lo = mini, hi = mini + m + 1, mid; n   while (hi - lo > 1) { n     mid = (hi + lo) >> 1; n     if (go(mid)) n       lo = mid; n     else n       hi = mid; n   } n   cout << lo << endl; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n int main(void) { n   int t, n, d; n   scanf( %d , &t); n   while (t--) { n     scanf( %d %d , &n, &d); n     int i = 0; n     int flag = 1; n     while (i < n) { n       int te = d / (i + 1); n       te = te * (i + 1) == d ? te : te + 1; n       if (i + te <= n) { n         printf( YES n ); n         flag = 0; n         break; n       } n       i++; n     } n     if (flag) printf( NO n ); n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int main() { n   ios::sync_with_stdio(0); n   cin.tie(0); n   cout.tie(0); n   int n, m1 = 0, m2 = 0; n   cin >> n; n   vector<vector<long long> > m(n, vector<long long>(n)); n   vector<int> a(n); n   for (int i = 0; i < n; i++) n     for (int j = 0; j < n; j++) cin >> m[i][j]; n   for (int i = 1; i < n - 1; i++) n     a[i] = sqrt(m[i][i + 1] * m[i - 1][i] / m[i - 1][i + 1]); n   a[0] = m[0][1] / a[1]; n   a[n - 1] = m[0][n - 1] / a[0]; n   for (int i = 0; i < n; i++) cout << a[i] <<    ; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n const long long maxm = 1e5 + 100; n long long n, m; n struct node { n   long long col[maxm * 4], tag[maxm * 4], sum[maxm * 4], siz[maxm * 4]; n   inline void pushup(long long o) { n     sum[o] = sum[(o << 1)] + sum[(o << 1) | 1]; n     col[o] = col[(o << 1)] == col[(o << 1) | 1] ? col[(o << 1)] : 0; n   } n   inline void pushdown(long long o) { n     if (tag[o]) { n       tag[(o << 1)] += tag[o]; n       tag[(o << 1) | 1] += tag[o]; n       sum[(o << 1)] += siz[(o << 1)] * tag[o]; n       sum[(o << 1) | 1] += siz[(o << 1) | 1] * tag[o]; n       col[(o << 1)] = col[(o << 1) | 1] = col[o]; n       tag[o] = 0; n     } n   } n   void build(long long o, long long l, long long r) { n     siz[o] = (r - l + 1); n     if (l >= r) { n       col[o] = l; n       return; n     } n     long long mid = (l + r) >> 1; n     build((o << 1), l, mid), build((o << 1) | 1, mid + 1, r); n     pushup(o); n   } n   void cover(long long o, long long l, long long r, long long ql, long long qr, n              long long c) { n     if (ql > r || qr < l) return; n     if ((ql <= l) && (r <= qr) && col[o]) { n       tag[o] += abs(col[o] - c); n       sum[o] += abs(col[o] - c) * siz[o]; n       col[o] = c; n       return; n     } n     pushdown(o); n     long long mid = (l + r) >> 1; n     cover((o << 1), l, mid, ql, qr, c), n         cover((o << 1) | 1, mid + 1, r, ql, qr, c); n     pushup(o); n   } n   long long ask(long long o, long long l, long long r, long long ql, n                 long long qr) { n     if (ql > r || qr < l) return 0; n     if ((ql <= l) && (r <= qr)) return sum[o]; n     pushdown(o); n     long long mid = (l + r) >> 1; n     return ask((o << 1), l, mid, ql, qr) + n            ask((o << 1) | 1, mid + 1, r, ql, qr); n   } n } st; n signed main() { n   scanf( %I64d%I64d , &n, &m); n   st.build(1, 1, n); n   for (long long i = 1; i <= m; i++) { n     long long opt, l, r, x; n     scanf( %I64d%I64d%I64d , &opt, &l, &r); n     if (opt == 1) n       scanf( %I64d , &x), st.cover(1, 1, n, l, r, x); n     else n       printf( %I64d n , st.ask(1, 1, n, l, r)); n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n template <typename Arg1> n void ZZ(const char* name, Arg1&& arg1) { n   std::cout << name <<   =   << arg1 << std::endl; n } n template <typename Arg1, typename... Args> n void ZZ(const char* names, Arg1&& arg1, Args&&... args) { n   const char* comma = strchr(names + 1,  , ); n   std::cout.write(names, comma - names) <<   =   << arg1; n   ZZ(comma, args...); n } n using namespace std; n long long int to_ll(string& s) { n   long long int i, ret = 0, p = 1; n   for (i = (long long int)s.length() - 1; i >= 0; i--) n     ret += (s[i] -  0 ) * p, p *= 10LL; n   return ret; n } n long long int gcd(long long int x, long long int y) { n   if (y == 0) return x; n   return gcd(y, x % y); n } n long long int pwr(long long int base, long long int expo, long long int m) { n   if (base == 0) return 0LL; n   if (expo == 0) return (1LL % m); n   if ((expo & 1) == 0) { n     long long int temp = pwr(base, expo >> 1, m); n     return (temp * temp) % m; n   } n   return ((base % m) * pwr(base, expo - 1, m)) % 1000000007; n } n vector<long long int> adj[200009]; n long long int dp_down[200009][5], dp_up[200009][5], sz_down[200009][5], n     sz_up[200009][5], p[200009], dp[200009][5], dp_sz[200009][5]; n bool v_dp_down[200009][5], v_dp_up[200009][5], v_sz_down[200009][5], n     v_sz_up[200009][5]; n long long int n, k; n void dfs(long long int node, long long int parent) { n   long long int i; n   p[node] = parent; n   for (i = 0; i < adj[node].size(); i++) { n     long long int nxt = adj[node][i]; n     if (nxt == parent) continue; n     dfs(nxt, node); n   } n } n void dfs_sz_down(long long int node, long long int parent, long long int m) { n   long long int i; n   if (v_sz_down[node][m] == 1) return; n   v_sz_down[node][m] = 1; n   for (i = 0; i < adj[node].size(); i++) { n     long long int nxt = adj[node][i]; n     long long int nxt_m = ((m - 1) % k + k) % k; n     if (nxt == parent) continue; n     dfs_sz_down(nxt, node, nxt_m); n     sz_down[node][m] += sz_down[nxt][nxt_m]; n     dp_sz[node][nxt_m] += sz_down[nxt][nxt_m]; n   } n   if (m == 0) sz_down[node][m]++; n } n void dfs_sz_up(long long int node, long long int parent, long long int m) { n   if (v_sz_up[node][m] == 1) return; n   v_sz_up[node][m] = 1; n   if (m == 0) sz_up[node][m]++; n   if (parent == -1) return; n   long long int nxt_m = ((m - 1) % k + k) % k, i; n   dfs_sz_up(parent, p[parent], nxt_m); n   sz_up[node][m] += sz_up[parent][nxt_m]; n   sz_up[node][m] += dp_sz[parent][((m - 2) % k + k) % k]; n   sz_up[node][m] -= sz_down[node][((m - 2) % k + k) % k]; n } n void dfs_up(long long int node, long long int parent, long long int m) { n   if (v_dp_up[node][m] == 1) return; n   v_dp_up[node][m] = 1; n   if (parent == -1) return; n   long long int nxt_m = ((m - 1) % k + k) % k, i; n   dfs_up(parent, p[parent], nxt_m); n   dp_up[node][m] += sz_up[parent][nxt_m] + dp_up[parent][nxt_m]; n   dp_up[node][m] += dp[parent][((m - 2) % k + k) % k]; n   dp_up[node][m] -= (2 * sz_down[node][((m - 2) % k + k) % k] + n                      dp_down[node][((m - 2) % k + k) % k]); n } n void dfs_down(long long int node, long long int parent, long long int m) { n   if (v_dp_down[node][m] == 1) return; n   v_dp_down[node][m] = 1; n   long long int i; n   for (i = 0; i < adj[node].size(); i++) { n     long long int nxt = adj[node][i]; n     long long int nxt_m = ((m - 1) % k + k) % k; n     if (nxt == parent) continue; n     dfs_down(nxt, node, nxt_m); n     dp_down[node][m] += sz_down[nxt][nxt_m] + dp_down[nxt][nxt_m]; n     dp[node][nxt_m] += (2 * sz_down[nxt][nxt_m] + dp_down[nxt][nxt_m]); n   } n } n int main() { n   ios::sync_with_stdio(false); n   cin.tie(0); n   cout.tie(0); n   ; n   long long int i, j, x, y, ans = 0; n   cin >> n >> k; n   for (i = 0; i < n - 1; i++) { n     cin >> x >> y; n     adj[x].push_back(y); n     adj[y].push_back(x); n   } n   dfs(1, -1); n   for (i = 1; i <= n; i++) n     for (j = 0; j < k; j++) dfs_sz_down(i, p[i], j); n   for (i = 1; i <= n; i++) n     for (j = 0; j < k; j++) dfs_sz_up(i, p[i], j); n   for (i = 1; i <= n; i++) n     for (j = 0; j < k; j++) dfs_down(i, p[i], j); n   for (i = 1; i <= n; i++) n     for (j = 0; j < k; j++) dfs_up(i, p[i], j); n   for (j = 0; j < k; j++) { n     for (i = 1; i <= n; i++) { n       long long int total = dp_up[i][j] + dp_down[i][j]; n       long long int total_sz = sz_down[i][j] + sz_up[i][j]; n       if (j == 0) total_sz--; n       long long int val = ((total - total_sz * j) / k); n       if (j != 0) val += total_sz; n       ans += val; n     } n   } n   cout << ans / 2 <<   n ; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int N = 1e6 + 4; n int n, m, a, b, ay[N], by[N], l[N], linkY[N << 1]; n void read() { n   cin >> n >> m >> a >> b; n   for (int i = 1; i <= n; ++i) { n     cin >> ay[i]; n   } n   for (int i = 1; i <= m; ++i) { n     cin >> by[i]; n   } n   for (int i = 1; i <= m; ++i) { n     cin >> l[i]; n   } n } n long double dist = 1e18; n int ida, idb, idTmp; n long double sqr(long double x) { return x * x; } n long double euc(long double xa, long double ya, long double xb, n                 long double yb) { n   return sqrt(sqr(xa - xb) + sqr(ya - yb)); n } n long double f(int ni, int mi) { n   return euc(0, 0, a, ay[ni]) + euc(a, ay[ni], b, by[mi]); n } n long double ternarySearch(int num) { n   int l = 1, r = n; n   while (l + 2 < r) { n     int dm = (r - l) / 3; n     int m1 = l + dm; n     int m2 = r - dm; n     long double d1 = f(m1, num); n     long double d2 = f(m2, num); n     if (fabs(d1 - d2) < 1e-9) { n       l = m1; n       r = m2; n     } else if (d1 < d2) { n       r = m2; n     } else { n       l = m1; n     } n   } n   idTmp = l; n   for (int i = l + 1; i <= r; ++i) { n     if (f(i, num) < f(idTmp, num)) { n       idTmp = i; n     } n   } n   return f(idTmp, num); n } n void calc() { n   for (int i = 1; i <= m; ++i) { n     long double distTmp = ternarySearch(i) + l[i]; n     if (distTmp < dist) { n       dist = distTmp; n       ida = idTmp; n       idb = i; n     } n   } n } n void sovle() { n   read(); n   calc(); n   cout << ida <<     << idb; n } n int main() { n   ios_base::sync_with_stdio(false); n   cout.tie(0); n   cin.tie(0); n   sovle(); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n #pragma GCC optimize( Ofast,unroll-loops ) n #pragma GCC target( avx,avx2,sse,sse2 ) n using namespace std; n using vi = vector<long long>; n mt19937 rnd(chrono::steady_clock::now().time_since_epoch().count()); n long long powmod(long long a, long long b, long long mod) { n   if (b == 0 || a == 1) { n     if (mod == 1) n       return 0; n     else n       return 1; n   } n   if (b % 2 == 0) { n     long long k = powmod(a, b / 2, mod); n     return (k * k) % mod; n   } else { n     long long k = powmod(a, b / 2, mod); n     return ((k * k) % mod * a) % mod; n   } n } n long long gcd(long long a, long long b) { n   if (a == 0) return b; n   if (b == 0) return a; n   if (a > b) n     return gcd(a % b, b); n   else n     return gcd(b % a, a); n } n long long prime(long long p) { n   if (p == 1) return 0; n   for (long long i = 2; i * i <= p; i++) { n     if (p % i == 0 && i < p) return i; n   } n   return 1; n } n long long inv(long long a, long long mod) { return powmod(a, mod - 2, mod); } n long long random_modul() { n   uniform_int_distribution<long long> u1(1e9, 2e9); n   long long pepega = u1(rnd); n   while (prime(pepega) != 1) pepega = u1(rnd); n   return pepega; n } n template <typename T1> n void ifmax(T1& max, T1 kek) { n   if (kek > max) max = kek; n   return; n } n template <typename T1> n void ifmin(T1& min, T1 kek) { n   if (kek < min) min = kek; n   return; n } n template <typename T1> n istream& operator>>(std::istream& in, pair<T1, T1>& a) { n   in >> a.first >> a.second; n   return in; n } n template <typename T1> n istream& operator>>(std::istream& in, vector<T1>& a) { n   for (long long i = 0; i < a.size(); i++) in >> a[i]; n   return in; n } n template <typename T1> n ostream& operator<<(std::ostream& out, vector<T1>& b) { n   for (long long i = 0; i < b.size(); i++) out << b[i]; n   return out; n } n template <typename T1> n void sort(vector<T1>& m) { n   sort(m.begin(), m.end()); n } n template <typename T1> n void reverse(vector<T1>& m) { n   reverse(m.begin(), m.end()); n } n long long mod = 1000000007; n long long fac[200005]; n long long inv_fac[200005]; n long long co(long long a, long long b) { n   long long ans = 1; n   ans *= fac[b]; n   ans *= inv_fac[b - a]; n   ans %= mod; n   ans *= inv_fac[a]; n   return ans % mod; n } n void solve() { n   string a, b; n   cin >> a >> b; n   long long s1 = a.size(); n   long long s2 = b.size(); n   string ans; n   for (long long i = 1; i <= s1; i++) { n     for (long long j = 1; j <= s2; j++) { n       string cur =   ; n       for (long long k = 0; k < i; k++) cur += a[k]; n       for (long long k = 0; k < j; k++) cur += b[k]; n       if (i == 1 && i == j) n         ans = cur; n       else n         ans = min(ans, cur); n     } n   } n   cout << ans; n   return; n } n signed main() { n   ios_base::sync_with_stdio(0); n   cin.tie(0); n   cout.tie(0); n   cout << fixed << setprecision(10); n   long long multitest = 0; n   long long tututu; n   tututu = 1; n   long long combinatorics = 0; n   if (combinatorics) { n     fac[1] = 1; n     fac[0] = 1; n     for (long long i = 2; i < 200005; i++) { n       fac[i] = fac[i - 1] * i; n       fac[i] %= mod; n     } n     for (long long i = 0; i < 200005; i++) { n       inv_fac[i] = inv(fac[i], mod); n     } n   } n   if (multitest) cin >> tututu; n   for (long long qwerty = 0; qwerty < tututu; qwerty++) solve(); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int main() { n   long double n; n   cin >> n; n   long long m = sqrt(n); n   if (m * m == n) { n     cout << 2 * m; n   } else if ((long long)m * (long long)(m + 1) >= n) { n     cout << (long long)m + (long long)(m + 1); n   } else n     cout << (long long)2 * (long long)(m + 1); n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int main() { n   long long int t, i, oo = 0, oz = 0, zo = 0, zz = 0; n   char s1[2000005], s2[2000005]; n   cin >> t; n   cin >> s1; n   cin >> s2; n   t = 2 * t; n   for (i = 0; i < t; i++) { n     if (s1[i] ==  1  && s2[i] ==  1 ) n       oo++; n     else if (s1[i] ==  1  && s2[i] ==  0 ) n       oz++; n     else if (s1[i] ==  0  && s2[i] ==  1 ) n       zo++; n     else n       zz++; n   } n   if (oo % 2 == 0) { n     if (oz > zo) n       cout <<  First ; n     else if (oz + 1 == zo || oz == zo) n       cout <<  Draw ; n     else n       cout <<  Second ; n   } else { n     if (oz >= zo) n       cout <<  First ; n     else if (oz + 1 == zo || oz + 2 == zo) n       cout <<  Draw ; n     else n       cout <<  Second ; n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int n, m, l, r, q; n map<pair<int, int>, int> vi; n int V[100005 << 2], ly[100005 << 2]; n void push_down(int o) { n   if (ly[o]) { n     ly[o << 1] |= ly[o]; n     ly[o << 1 | 1] |= ly[o]; n     V[o << 1] |= ly[o]; n     V[o << 1 | 1] |= ly[o]; n     ly[o] = 0; n   } n } n void push_up(int o) { V[o] = V[o << 1] & V[o << 1 | 1]; } n void ud(int o, int l, int r, int L, int R, int x) { n   int mid = (l + r) / 2; n   if (L <= l && r <= R) { n     V[o] |= x; n     ly[o] |= x; n     return; n   } n   push_down(o); n   if (L <= mid) ud(o << 1, l, mid, L, R, x); n   if (R > mid) ud(o << 1 | 1, mid + 1, r, L, R, x); n   push_up(o); n } n int qy(int o, int l, int r, int L, int R) { n   int mid = (l + r) / 2; n   if (L <= l && r <= R) return V[o]; n   push_down(o); n   int ans = (1 << 30) - 1; n   if (L <= mid) ans &= qy(o << 1, l, mid, L, R); n   if (R > mid) ans &= qy(o << 1 | 1, mid + 1, r, L, R); n   push_up(o); n   return ans; n } n int main() { n   cin >> n >> m; n   int ok = 1; n   for (int i = 0; i < m; i++) { n     scanf( %d%d%d , &l, &r, &q); n     int tp = qy(1, 1, n, l, r); n     if (vi[make_pair(l, r)]) { n       if (tp != q) { n         ok = 0; n       } n     } n     if (!ok) continue; n     vi[make_pair(l, r)] = 1; n     if ((tp & q) == tp) n       ud(1, 1, n, l, r, q); n     else n       ok = 0; n   } n   if (!ok) { n     puts( NO ); n     return 0; n   } n   printf( YES n ); n   for (int i = 1; i <= n; i++) printf( %d  , qy(1, 1, n, i, i)); n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int main() { n   int n, m; n   cin >> n >> m; n   if (n == 1) n     cout << m; n   else if (n - m > m - 1 && n - m != 0) n     cout << m + 1; n   else n     cout << m - 1; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int N = 1e5 + 10; n int main() { n   list<int> a; n   int n; n   scanf( %d , &n); n   for (int i = 1; i <= n; i++) { n     int x; n     scanf( %d , &x); n     a.push_back(x); n   } n   for (auto t = a.begin(); t != a.end(); t++) { n     auto s = t; n     s--; n     if (t == a.begin()) continue; n     while (true) { n       if (*t == *s) { n         *t = *t + 1; n         t = a.erase(s); n         if (t == a.begin()) break; n         s = t, s--; n       } else n         break; n     } n   } n   printf( %d n , a.size()); n   for (auto t : a) printf( %d  , t); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int n, m; n int dp[800][800][10]; n int main() { n   scanf( %d%d , &n, &m); n   for (int i = 1; i <= m; i++) { n     int x, y; n     scanf( %d%d , &x, &y); n     dp[x][y][1]++; n     dp[y][x][1]++; n   } n   for (int i = 1; i <= n; i++) n     for (int j = 1; j <= n; j++) n       if (i != j) n         for (int q = 1; q <= n; q++) n           if (q != i && q != j) { n             dp[i][j][2] += dp[i][q][1] * dp[j][q][1]; n           } n   for (int i = 1; i <= n; i++) n     for (int j = 1; j <= n; j++) n       if (i != j) { n         for (int q = 1; q <= n; q++) n           if (q != i && q != j) { n             dp[i][j][3] += dp[i][q][2] * dp[j][q][1] + n                            dp[i][q][1] * dp[j][q][2] - n                            dp[i][j][1] * dp[i][q][1] * dp[i][q][1] - n                            dp[i][j][1] * dp[j][q][1] * dp[j][q][1]; n           } n         dp[i][j][3] /= 2; n       } n   long long sum = 0; n   for (int i = 1; i <= n; i++) n     for (int j = 1; j <= n; j++) n       if (i != j && dp[i][j][3] != 0 && dp[i][j][2] != 0) { n         for (int q = 1; q <= n; q++) n           if (q != i && q != j && dp[i][q][1] != 0 && dp[j][q][1] != 0) { n             sum += dp[i][j][3]; n             sum -= dp[j][q][2] - dp[i][j][1] + dp[i][q][2] - dp[i][j][1]; n           } n       } n   printf( %lld , sum / 10); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const long long MOD = 1e9 + 7; n template <typename T> n void chmin(T &a, T b) { n   if (a > b) a = b; n } n template <typename T> n void chmax(T &a, T b) { n   if (a < b) a = b; n } n template <typename T> n void add(T &a, T b) { n   a += b; n   if (a < 0) a += MOD; n   if (a >= MOD) a -= MOD; n } n void FastIn(int &T) { n   char C; n   bool F = 0; n   for (; C = getchar(), C <  0  || C >  9 ;) n     if (C ==  - ) F = 1; n   for (T = C -  0 ; C = getchar(), C >=  0  && C <=  9 ; T = T * 10 + C -  0 ) n     ; n   F && (T = -T); n } n int in() { n   int x; n   scanf( %d , &x); n   return x; n } n long long lin() { n   long long x; n   scanf( %lld , &x); n   return x; n } n double din() { n   double x; n   scanf( %lf , &x); n   return x; n } n long long p2[63]; n void initP2() { n   p2[0] = 1; n   for (int i = (1); i <= (62); ++i) { n     p2[i] = p2[i - 1] * 2; n   } n } n int countBitsBaseB(long long n, long long b) { n   if (n == 0) return 1; n   int ret = 0; n   while (n) { n     ret++; n     n /= b; n   } n   return ret; n } n int count1(long long n) { n   int ret = 0; n   while (n) { n     ret += n & 1; n     n >>= 1; n   } n   return ret; n } n long long c[1024][1024] = {0}; n void initC() { n   for (int i = 0; i < (1024); ++i) { n     for (int j = 0; j < (i + 1); ++j) { n       if (j == 0 || j == i) { n         c[i][j] = 1; n       } else { n         c[i][j] = c[i - 1][j - 1]; n         add(c[i][j], c[i - 1][j]); n       } n     } n   } n } n bool IsPrime(int n) { n   if (n < 2) return false; n   for (int i = 2; i * i <= n; i++) { n     if (n % i == 0) return false; n   } n   return true; n } n void init() { n   initP2(); n   initC(); n } n const unsigned INVALID = 2000000001; n struct CMD { n   int cmd, x, y; n } q[(int)(2e5 + 10)]; n struct DSU { n   int f[(int)(2e5 + 10)]; n   int h[(int)(2e5 + 10)]; n   int *addr[(int)(2e5 + 10) << 2]; n   int val[(int)(2e5 + 10) << 2]; n   int stkSize = 0; n   void init(int n) { n     for (int i = (1); i <= (n); ++i) { n       f[i] = i; n       h[i] = 1; n     } n     stkSize = 0; n   } n   int find(int x) { return x == f[x] ? x : find(f[x]); } n   void merge(int x, int y) { n     x = find(x); n     y = find(y); n     if (x == y) { n       return; n     } n     if (h[x] > h[y]) swap(x, y); n     addr[stkSize] = &f[x]; n     val[stkSize++] = f[x]; n     f[x] = y; n     if (h[x] == h[y]) { n       addr[stkSize] = &h[y]; n       val[stkSize++] = h[y]; n       h[y]++; n     } n   } n   void mergeFast(int x, int y) { n     x = find(x); n     y = find(y); n     if (x == y) { n       return; n     } n     if (h[x] > h[y]) swap(x, y); n     f[x] = y; n     if (h[x] == h[y]) { n       h[y]++; n     } n   } n   void undo(int size) { n     while (stkSize > size) { n       stkSize--; n       *addr[stkSize] = val[stkSize]; n     } n   } n  n  private: n } dsu; n const int BLOCK = 5000; n int last[(int)(2e5 + 10)]; n pair<int, int> GetEdge(int x, int y, int der, int n) { n   x += der - 1; n   if (x >= n) x -= n; n   y += der - 1; n   if (y >= n) y -= n; n   if (x > y) swap(x, y); n   return make_pair(x + 1, y + 1); n } n void Switch(const pair<int, int> &edge, set<pair<int, int>> &edges) { n   if (edges.find(edge) != edges.end()) { n     edges.erase(edge); n   } else { n     edges.insert(edge); n   } n } n int main() { n   init(); n   int n = in(), m = in(); n   for (int i = (1); i <= (m); ++i) { n     q[i].cmd = in(); n     q[i].x = in(); n     q[i].y = in(); n   } n   last[0] = 0; n   for (int start = 1; start <= m; start += BLOCK) { n     int end = start + BLOCK - 1; n     if (end > m) { n       end = m; n     } n     set<pair<int, int>> nowEdges; n     nowEdges.clear(); n     for (int i0 = (start); i0 <= (end); ++i0) { n       nowEdges.insert(GetEdge(q[i0].x, q[i0].y, 0, n)); n       nowEdges.insert(GetEdge(q[i0].x, q[i0].y, 1, n)); n     } n     set<pair<int, int>> possible; n     possible.clear(); n     set<pair<int, int>> impossible; n     impossible.clear(); n     for (int i1 = (1); i1 <= (start - 1); ++i1) { n       if (q[i1].cmd == 2) { n         continue; n       } n       auto edge0 = GetEdge(q[i1].x, q[i1].y, last[i1 - 1], n); n       if (nowEdges.find(edge0) == nowEdges.end()) { n         Switch(edge0, impossible); n       } else { n         Switch(edge0, possible); n       } n     } n     dsu.init(n); n     for (auto edge1 : impossible) { n       dsu.mergeFast(edge1.first, edge1.second); n     } n     for (int i2 = (start); i2 <= (end); ++i2) { n       if (q[i2].cmd == 1) { n         last[i2] = last[i2 - 1]; n         Switch(GetEdge(q[i2].x, q[i2].y, last[i2 - 1], n), possible); n         continue; n       } else { n         const int top = dsu.stkSize; n         for (auto edge1 : possible) { n           dsu.merge(edge1.first, edge1.second); n         } n         auto queryEdge = GetEdge(q[i2].x, q[i2].y, last[i2 - 1], n); n         last[i2] = dsu.find(queryEdge.first) == dsu.find(queryEdge.second); n         putchar( 0  + last[i2]); n         dsu.undo(top); n       } n     } n   } n   cout << endl; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n const bool debug = false; n int triple[1 << 12][3]; n int use[1 << 12]; n int cost[1 << 12]; n std::vector<int> gen_masks(int L) { n   std::vector<int> masks; n   masks.push_back(0); n   for (int i = 0; i < L; i++) { n     for (int j = 1; j < L; j++) { n       if (i + j * 2 >= L) continue; n       masks.push_back((1 << i) | (1 << (i + j)) | (1 << (i + 2 * j))); n     } n   } n   return masks; n } n int as[100005]; n int main() { n   std::vector<int> masks = gen_masks(12); n   for (int u : masks) { n     for (int v : masks) { n       for (int w : masks) { n         int res = (u ^ v ^ w) & ((1 << 9) - 1); n         triple[res][0] = u; n         triple[res][1] = v; n         triple[res][2] = w; n       } n     } n   } n   std::vector<std::array<int, 3> > moves; n   int NN; n   scanf( %d , &NN); n   int N = NN; n   for (int i = 1; i <= N; i++) { n     scanf( %d , &as[i]); n   } n   while (N >= 12) { n     int M = 0; n     for (int i = 0; i < 9; i++) { n       M |= (as[N - i] << i); n     } n     for (int t = 0; t < 3; t++) { n       std::array<int, 3> move; n       int index = 0; n       for (int i = 0; i < 12; i++) { n         if (triple[M][t] & (1 << i)) { n           as[N - i] ^= 1; n           move[index++] = N - i; n         } n       } n       if (index) { n         assert(index == 3); n         moves.push_back(move); n       } n     } n     N -= 9; n   } n   N = std::min(NN, 12); n   masks = gen_masks(N); n   for (int i = 1; i < (1 << N); i++) { n     cost[i] = 1e9; n   } n   for (int mask : masks) { n     for (int i = 0; i < (1 << N); i++) { n       if (cost[i ^ mask] > cost[i] + 1) { n         cost[i ^ mask] = cost[i] + 1; n         use[i ^ mask] = mask; n       } n     } n   } n   if (debug) { n     int worst = 0; n     for (int i = 0; i < (1 << N); i++) { n       if (cost[i] < 1e9) worst = std::max(worst, cost[i]); n       printf( %d:  , i); n       for (int k = 0; k < N; k++) { n         printf( %d , (use[i] >> k) & 1); n       } n       printf(  n ); n     } n     printf( WORST: %d n , worst); n   } n   while (true) { n     int M = 0; n     for (int i = 0; i < N; i++) { n       M |= (as[N - i] << i); n     } n     if (M == 0) break; n     std::array<int, 3> move; n     int index = 0; n     for (int i = 0; i < 12; i++) { n       if (use[M] & (1 << i)) { n         as[N - i] ^= 1; n         move[index++] = N - i; n       } n     } n     if (index == 0) { n       printf( NO n ); n       return 0; n     } n     assert(index == 3); n     moves.push_back(move); n   } n   for (int i = 0; i < N; i++) { n     assert(as[i] == 0); n   } n   printf( YES n ); n   printf( %d n , (int)moves.size()); n   for (auto move : moves) { n     printf( %d %d %d n , move[0], move[1], move[2]); n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int n, k, a[100010], b[100010], c[100010]; n void nhap() { n   scanf( %d%d , &n, &k); n   for (int i = 1; i <= n; i++) scanf( %d , &c[i]); n   int dem = 1; n   a[1] = c[1]; n   for (int i = 2; i <= n; i++) n     if (c[i] != a[dem]) { n       dem++; n       a[dem] = c[i]; n     } n   n = dem; n } n void xuli() { n   a[0] = 0; n   a[n + 1] = 0; n   memset(b, 0, sizeof b); n   for (int i = 1; i <= n; i++) n     if (a[i - 1] == a[i + 1]) n       b[a[i]] += 2; n     else n       b[a[i]]++; n   int dem = 0, kq; n   for (int i = 1; i <= k; i++) n     if (dem < b[i]) dem = b[i], kq = i; n   cout << kq; n } n int main() { n   if (0) { n     freopen( input.txt ,  r , stdin); n     freopen( output.txt ,  w , stdout); n   }; n   nhap(); n   xuli(); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int main(void) { n   long n, m, l, r; n   vector<long> a(100005); n   map<long, vector<long> >::iterator mi; n   vector<long>::iterator vi1, vi2; n   map<long, vector<long> > hash; n   scanf( %ld %ld , &n, &m); n   for (long i = 0; i < n; i++) { n     scanf( %ld , &a[i]); n     if (hash.find(a[i]) != hash.end()) n       hash[a[i]].push_back(i); n     else { n       vector<long> v; n       v.push_back(i); n       hash[a[i]] = v; n     } n   } n   mi = hash.begin(); n   while (mi != hash.end()) { n     if (mi->first > mi->second.size()) { n       long temp = mi->first; n       mi++; n       hash.erase(hash.find(temp)); n     } else n       mi++; n   } n   long diff = r - l + 1, count = 0; n   long first, last; n   for (long i = 0; i < m; i++) { n     scanf( %ld %ld , &l, &r); n     diff = r - l + 1, count = 0; n     mi = hash.begin(); n     while (mi->first <= diff && mi != hash.end()) { n       vi1 = upper_bound(mi->second.begin(), mi->second.end(), r - 1); n       vi2 = lower_bound( n           mi->second.begin(), n           mi->second.end() - ((mi->first - 3 > 0) ? (mi->first - 3) : 0), n           l - 1); n       last = vi1 - mi->second.begin(), first = vi2 - mi->second.begin(); n       if (last - first == mi->first) count++; n       mi++; n     } n     printf( %ld n , count); n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int __SIZE = 1 << 18; n char ibuf[__SIZE], *iS, *iT; n template <typename T> n inline void read(T &x) { n   char ch, t = 0; n   x = 0; n   while (!isdigit(ch = (iS == iT n                             ? (iT = (iS = ibuf) + fread(ibuf, 1, __SIZE, stdin), n                                (iS == iT ? EOF : *iS++)) n                             : *iS++))) n     t |= ch ==  - ; n   while (isdigit(ch)) n     x = x * 10 + (ch ^ 48), n     ch = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, __SIZE, stdin), n                       (iS == iT ? EOF : *iS++)) n                    : *iS++); n   x = t ? -x : x; n } n inline int read_int() { n   int x; n   return read(x), x; n } n inline long long read_ll() { n   long long x; n   return read(x), x; n } n template <typename T> n inline void chkmin(T &a, T b) { n   a = a < b ? a : b; n } n template <typename T> n inline void chkmax(T &a, T b) { n   a = a > b ? a : b; n } n const int MAXN = 150010; n const int mod = 998244353; n inline void Add(int &x, int y) { x += y, x -= x >= mod ? mod : 0; } n inline int Mod(int x) { return x >= mod ? x - mod : x; } n inline int fsp(int x, int k = mod - 2) { n   int s = 1; n   while (k) { n     if (k & 1) s = 1LL * s * x % mod; n     x = 1LL * x * x % mod, k >>= 1; n   } n   return s; n } n inline long long S(long long x, long long k) { return (x + x + k - 1) * k / 2; } n inline long long find(long long x, long long k) { n   if (!x) return k * (k + 1) >> 1; n   long long p = find(x / k, k), rest = x % k; n   long long st = (x / k) * (k * k + 1) + rest * k + 1; n   if (st + k <= p) n     return S(st, k); n   else n     return S(st, k) + min(k, st + k - p); n } n inline void Solve() { n   long long n = read_ll(), k = read_int(), bel = (n - 1) / (k * k + 1); n   long long p = find(bel, k); n   if (p == n) n     cout << (bel + 1) * (k + 1) << endl; n   else { n     long long pos = n - bel - 1 + (n < p); n     long long t = (n - 1) % (k * k + 1) + 1; n     long long cnt = bel * k + (t - 1 - (n >= p)) / k; n     cout << pos + cnt << endl; n   } n } n int main() { n   int Case = read_int(); n   while (Case--) Solve(); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int main() { n   int n, x, y; n   cin >> n; n   int mx = 0; n   for (int i = 0; i < n; i++) { n     cin >> x >> y; n     mx = max(mx, (x + y)); n   } n   cout << mx << endl; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int main() { n   int n; n   scanf( %d , &n); n   int arr[n]; n   int unos = 0; n   for (int i = 0; i < n; i++) { n     scanf( %d , &arr[i]); n     if (arr[i]) unos++; n   } n   int fin = 0; n   for (int i = 0; i < n; i++) { n     int total = unos; n     for (int j = i; j < n; j++) { n       if (arr[j]) n         total--; n       else n         total++; n       fin = max(fin, total); n     } n   } n   printf( %d , fin); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n unsigned int n, i, f, p, s, rez; n int main() { n   cin >> n; n   f = 1; n   for (i = 1; i <= n; i++) f = ((unsigned long long)f * i) % 998244353; n   f = ((unsigned long long)f * n) % 998244353; n   p = 1; n   s = 0; n   for (i = n; i >= 2; i--) { n     p = ((unsigned long long)p * i) % 998244353; n     s = (s + p) % 998244353; n   } n   rez = (f - s + 998244353) % 998244353; n   cout << rez; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n long long calc_2(int s) { n   if (s < 0) return 0; n   return 1LL * (s + 1) * (s + 2) / 2; n } n long long calc_3(int s) { n   if (s < 0) return 0; n   long long ans = 0; n   for (int i = 0; i <= s; i++) ans += calc_2(s - i); n   return ans; n } n int val[5]; n int main() { n   int a, b, c, L; n   scanf( %d%d%d%d , &a, &b, &c, &L); n   val[1] = a - b - c, val[2] = b - a - c, val[3] = c - a - b; n   long long ans = calc_3(L); n   for (int i = 1; i <= 3; i++) { n     for (int z = 0; z <= L; z++) { n       int ed = min(L - z, val[i] + z); n       ans -= calc_2(ed); n     } n   } n   printf( %I64d n , ans); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int nmax = 26; n int cost[nmax][3]; n const int l = 0, m = 1, w = 2; n map<pair<int, int>, pair<string, int> > myMap; n pair<string, long long> global; n bool ok = 0; n void firstHalf(int a, int b, int c, string s) { n   if (myMap.count({a - b, b - c}) == 0 || myMap[{a - b, b - c}].second < a) { n     myMap[{a - b, b - c}] = {s, a}; n   } n } n void findMatch(int a, int b, int c, string s) { n   if (myMap.count({b - a, c - b}) != 0) { n     int ans = myMap[{b - a, c - b}].second + a; n     string fin = myMap[{b - a, c - b}].first + s; n     if (ans > global.second) { n       ok = 1; n       global = {fin, ans}; n     } n   } n } n void solve(int i, const int stop, void (*op)(int, int, int, string), int a, n            int b, int c, string s) { n   if (i == stop + 1) { n     op(a, b, c, s); n     return; n   } n   solve(i + 1, stop, op, a + cost[i][l], b + cost[i][m], c, s +  LM n ); n   solve(i + 1, stop, op, a + cost[i][l], b, c + cost[i][w], s +  LW n ); n   solve(i + 1, stop, op, a, b + cost[i][m], c + cost[i][w], s +  MW n ); n } n int main() { n   int n; n   cin >> n; n   for (int i = 1; i <= n; ++i) cin >> cost[i][l] >> cost[i][m] >> cost[i][w]; n   global.second = -26 * 10e7; n   string pl; n   solve(1, n / 2, &firstHalf, 0, 0, 0, pl); n   solve(n / 2 + 1, n, &findMatch, 0, 0, 0, pl); n   if (ok) n     cout << global.first; n   else n     cout <<  Impossible ; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int a[10]; n int main() { n   int ans = 0; n   for (int i = 0; i < 6; i++) scanf( %d , &a[i]); n   if (a[2] == a[4]) { n     swap(a[0], a[3]); n     swap(a[1], a[2]); n     swap(a[4], a[5]); n   } n   for (int i = a[0] + a[0] - 1 + 2, j = 0; j < max(a[1], a[5]); i += 2, j++) { n     if (j == min(a[1], a[5])) n       i--; n     else if (j > min(a[1], a[5])) n       i -= 2; n     ans += i; n   } n   for (int i = a[3] + a[3] - 1 + 2, j = 0; j < min(a[2], a[4]); i += 2, j++) { n     ans += i; n   } n   printf( %d n , ans); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int main() { n   ios::sync_with_stdio(false); n   cin.tie(NULL); n   cout.tie(NULL); n   int t; n   cin >> t; n   for (int i = 0; i < t; i++) { n     int n; n     cin >> n; n     long long mn = 1e9, mx = -1e9; n     long long a[n]; n     for (int j = 0; j < n; j++) { n       cin >> a[j]; n       mn = min(a[j], mn); n       mx = max(a[j], mx); n     } n     long long x = mn * mx; n     int ans = 1; n     set<long long> s; n     for (int j = 2; j <= sqrt(x); j++) { n       if (x % j == 0) { n         s.insert(j); n         s.insert(x / j); n       } n     } n     int cnt = 0; n     for (int j = 0; j < n; j++) { n       if (x % a[j] == 0) { n         cnt++; n       } else { n         cnt = -1; n         break; n       } n     } n     if (cnt != s.size()) { n       cout << -1 << endl; n     } else n       cout << x << endl; n   } n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n class IntTree { n  public: n   IntTree(int size) : nodes_(4 * size + 10, 0), size_(size) {} n   void Set(int pos, char ch) { Set(0, 1, size_, pos, ch); } n   int Count(int left, int right) { n     int mask = Mask(0, 1, size_, left, right); n     return CountBits(mask); n   } n  n  private: n   static int Left(int node) { return 2 * node + 1; } n   static int Right(int node) { return 2 * node + 2; } n   static int CountBits(int num); n   void Set(int node, int left, int right, int pos, char ch); n   int Mask(int node, int left, int right, int x, int y); n   vector<int> nodes_; n   int size_; n }; n int IntTree::CountBits(int num) { n   int count = 0; n   while (num > 0) { n     count += 1; n     num -= (num & -num); n   } n   return count; n } n void IntTree::Set(int node, int left, int right, int pos, char ch) { n   if (left == right) { n     nodes_[node] = (1 << (ch -  a )); n     return; n   } n   int mid = left + (right - left) / 2; n   if (pos <= mid) { n     Set(Left(node), left, mid, pos, ch); n   } else { n     Set(Right(node), mid + 1, right, pos, ch); n   } n   nodes_[node] = (nodes_[Left(node)] | nodes_[Right(node)]); n } n int IntTree::Mask(int node, int left, int right, int x, int y) { n   if (x <= left && right <= y) { n     return nodes_[node]; n   } n   int mask = 0; n   int mid = left + (right - left) / 2; n   if (x <= mid) { n     mask |= Mask(Left(node), left, mid, x, y); n   } n   if (mid < y) { n     mask |= Mask(Right(node), mid + 1, right, x, y); n   } n   return mask; n } n int main() { n   string str; n   getline(cin, str); n   IntTree tree(str.size()); n   for (size_t i = 0; i < str.size(); i += 1) { n     tree.Set(i + 1, str[i]); n   } n   int queries; n   cin >> queries; n   for (int i = 0; i < queries; i += 1) { n     int type, x, y; n     char ch; n     cin >> type; n     if (type == 1) { n       cin >> x >> ch; n       tree.Set(x, ch); n     } else { n       cin >> x >> y; n       cout << tree.Count(x, y) <<   n ; n     } n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n using LL = long long; n constexpr int N = 155; n int in[N][N]; n int main() { n   ios::sync_with_stdio(false); n   cin.tie(nullptr); n   int n; n   cin >> n; n   for (int i = 1; i <= n; i++) { n     for (int j = 1; j <= n; j++) { n       cin >> in[i][j]; n     } n   } n   vector<int> ans(N); n   for (int v = 1; v < n; v++) { n     for (int i = 1; i <= n; i++) { n       bool f1 = false; n       bool f2 = true; n       for (int j = 1; j <= n; j++) { n         if (in[i][j] == v) n           f1 = true; n         else { n           if (in[i][j] != -1 and in[i][j] != 0) f2 = false; n         } n       } n       if (f1 && f2) { n         ans[i] = v; n         for (int j = 1; j <= n; j++) in[i][j] = in[j][i] = -1; n         break; n       } n     } n   } n   for (int i = 1; i <= n; i++) cout << (ans[i] == 0 ? n : ans[i]) <<    ; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int inf = 1e5 + 9; n int n; n int mp[9]; n bool done[109]; n vector<pair<long long, pair<long long, long long> > > v[109]; n void dfs(int node) { n   done[node] = 1; n   for (int i = 0; i < v[node].size(); i++) { n     int u = v[node][i].first; n     int e = v[node][i].second.first; n     int f = v[node][i].second.second; n     if (done[u]) continue; n     mp[f] += e, dfs(u); n   } n } n int main() { n   ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0), cin >> n; n   for (int i = 0; i < n; i++) { n     int a, b, c; n     cin >> a >> b >> c; n     a--; n     b--; n     v[a].push_back({b, {c, 1}}); n     v[b].push_back({a, {c, 0}}); n   } n   dfs(0); n   mp[1 - v[0][1].second.second] += v[0][1].second.first; n   cout << min(mp[1], mp[0]) << endl; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int N = 200000 + 10; n const long long INF = 1e18; n int n, q; n struct Edge { n   int u, v; n   long long w; n   Edge(int _u = 0, int _v = 0, long long _w = 0) : u(_u), v(_v), w(_w) {} n }; n vector<Edge> E; n int E_size; n vector<int> G[N]; n int ptr[2 * N]; n void adjListInit(int l, int r) { n   E.clear(); n   E_size = 0; n   for (int i = l; i <= r; i++) G[i].clear(); n } n void addEdge(int u, int v, long long w, int i) { n   E.push_back(Edge(u, v, w)); n   E_size++; n   ptr[i] = E_size - 1; n   G[u].push_back(E_size - 1); n } n vector<Edge> Eback; n int Gback[N]; n int Eback_size; n long long dist[N]; n int in[N], out[N]; n int peg[N]; n int dfs_clock; n inline void dfsInit() { n   dist[1] = 0; n   dfs_clock = 0; n } n void dfs(int u, int pre) { n   in[u] = ++dfs_clock; n   peg[in[u]] = u; n   for (int i = 0; i < G[u].size(); i++) { n     Edge e = E[G[u][i]]; n     int v = e.v; n     if (v == pre) continue; n     dist[v] = dist[u] + e.w; n     dfs(v, u); n   } n   out[u] = dfs_clock; n } n struct Node { n   int l, r; n   long long val, lazy; n   void update(long long x) { val += x, lazy += x; } n } node[N << 2]; n inline void pushdown(int rt) { n   if (node[rt].lazy) { n     node[rt << 1].update(node[rt].lazy); n     node[rt << 1 | 1].update(node[rt].lazy); n     node[rt].lazy = 0; n   } n } n inline void pushup(int rt) { n   node[rt].val = min(node[rt << 1].val, node[rt << 1 | 1].val); n } n void build(int root, int l, int r) { n   node[root].l = l; n   node[root].r = r; n   node[root].val = 0; n   node[root].lazy = 0; n   if (l == r) { n     int p = peg[l]; n     node[root].val = dist[p] + Eback[Gback[p]].w; n   } else { n     int mid = l + (r - l) / 2; n     build(root * 2, l, mid); n     build(root * 2 + 1, mid + 1, r); n     pushup(root); n   } n } n void update(int root, int st, int ed, int val) { n   if (st > node[root].r || ed < node[root].l) return; n   if (st <= node[root].l && node[root].r <= ed) n     node[root].update(val); n   else { n     pushdown(root); n     update(root * 2, st, ed, val); n     update(root * 2 + 1, st, ed, val); n     pushup(root); n   } n } n long long query(int root, int st, int ed) { n   if (ed < node[root].l || node[root].r < st) return INF; n   if (st <= node[root].l && node[root].r <= ed) n     return node[root].val; n   else { n     pushdown(root); n     long long lson = query(root * 2, st, ed); n     long long rson = query(root * 2 + 1, st, ed); n     pushup(root); n     return min(lson, rson); n   } n } n int main() { n   cin >> n >> q; n   adjListInit(1, n); n   for (int i = 1; i <= n - 1; i++) { n     int a, b; n     long long c; n     scanf( %d%d%I64d , &a, &b, &c); n     addEdge(a, b, c, i); n   } n   dfsInit(); n   dfs(1, -1); n   Eback.clear(); n   Eback_size = 0; n   for (int i = n, a, b, c; i <= 2 * n - 2; i++) { n     scanf( %d%d%d , &a, &b, &c); n     Eback.push_back(Edge(a, b, c)); n     Eback_size++; n     ptr[i] = Eback_size - 1; n     Gback[a] = Eback_size - 1; n   } n   Eback.push_back(Edge(1, 1, 0)); n   Eback_size++; n   Gback[1] = Eback_size - 1; n   build(1, 1, n); n   for (int i = 1, type; i <= q; i++) { n     scanf( %d , &type); n     if (type == 1) { n       int id; n       long long w; n       scanf( %d%I64d , &id, &w); n       if (id < n) { n         Edge &e = E[ptr[id]]; n         update(1, in[e.v], out[e.v], w - e.w); n         e.w = w; n       } else { n         Edge &e = Eback[ptr[id]]; n         update(1, in[e.u], in[e.u], w - e.w); n         e.w = w; n       } n     } n     if (type == 2) { n       int u, v; n       scanf( %d%d , &u, &v); n       if (in[u] <= in[v] && in[v] <= out[u]) { n         long long du = query(1, in[u], in[u]) - Eback[Gback[u]].w; n         long long dv = query(1, in[v], in[v]) - Eback[Gback[v]].w; n         printf( %I64d n , dv - du); n       } else { n         long long ans = query(1, in[u], out[u]); n         long long du = query(1, in[u], in[u]) - Eback[Gback[u]].w; n         long long dv = query(1, in[v], in[v]) - Eback[Gback[v]].w; n         ans -= du; n         ans += dv; n         printf( %I64d n , ans); n       } n     } n   } n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n vector<long long int> a[100004]; n int p[100004]; n int v[100004]; n long long int c[100004]; n struct sajal { n   long long int add, sub, d; n }; n sajal d[100004]; n int main() { n   long n; n   cin >> n; n   long x, y; n   for (long i = 1; i < n; i++) { n     cin >> x >> y; n     a[x].push_back(y); n     a[y].push_back(x); n   } n   queue<long> q; n   q.push(1); n   p[1] = 1; n   while (!q.empty()) { n     long f = q.front(); n     q.pop(); n     v[f] = 1; n     for (long i = 0; i < a[f].size(); i++) { n       if (v[a[f][i]] == 0) { n         v[a[f][i]] = 1; n         q.push(a[f][i]); n         p[a[f][i]] = f; n       } n     } n   } n   for (long i = 1; i <= n; i++) { n     cin >> c[i]; n     d[i].add = 0; n     d[i].sub = 0; n     d[i].d = a[i].size(); n     if (a[i].size() == 1 && i != 1) { n       q.push(i); n     } n   } n   long long int add = 0; n   long long int sub = 0; n   long cur = 1; n   while (!q.empty()) { n     long f = q.front(); n     q.pop(); n     long long int e = d[f].add - d[f].sub; n     long long int h = -c[f] - e; n     long long int w = p[f]; n     if (h >= 0) { n       d[f].add = d[f].add + h; n     } else { n       h = -h; n       d[f].sub = h + d[f].sub; n     } n     if (d[f].sub > sub) sub = d[f].sub; n     if (d[f].add > add) add = d[f].add; n     if (d[w].sub < d[f].sub) d[w].sub = d[f].sub; n     if (d[w].add < d[f].add) d[w].add = d[f].add; n     d[w].d--; n     if (d[w].d == 1 && w != 1) { n       q.push(w); n     } n   } n   c[1] = c[1] + d[1].add - d[1].sub; n   c[1] = -c[1]; n   if (c[1] >= 0) { n     d[1].add = d[1].add + c[1]; n   } else { n     c[1] = -c[1]; n     d[1].sub = d[1].sub + c[1]; n   } n   if (add < d[1].add) add = d[1].add; n   if (sub < d[1].sub) sub = d[1].sub; n   cout << add + sub << endl; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int n, m, l, r, x; n string s; n int main() { n   cin >> n >> m; n   r = 0; n   l = n + 1; n   for (int i = 0; i < m; ++i) { n     cin >> s; n     cin >> s; n     cin >> s; n     if (s ==  left ) { n       cin >> s >> x; n       l = min(l, x); n     } else { n       cin >> s >> x; n       r = max(r, x); n     } n   } n   if (l - r - 1 <= 0) n     cout << -1 << endl; n   else n     cout << l - r - 1 << endl; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int main() { n   int n; n   cin >> n; n   string intial, code; n   cin >> intial >> code; n   int res = 0; n   for (int i = 0; i < n; i++) { n     int a = (((intial[i] -  0 ) - (code[i] -  0 )) + 10) % 10; n     int b = (((code[i] -  0 ) - (intial[i] -  0 )) + 10) % 10; n     res += min(a, b); n   } n   cout << res; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int e[100010]; n int main() { n   int n, u, i, j = 3; n   double ans = 0; n   scanf( %d%d , &n, &u); n   for (i = 1; i <= n; i++) scanf( %d , &e[i]); n   for (i = 1; i <= n; i++) { n     while (j <= n && e[j] - e[i] <= u) j++; n     j--; n     if (j > i + 1) ans = max(ans, (e[j] - e[i + 1] + 0.0) / (e[j] - e[i])); n   } n   if (ans == 0) n     cout << -1 << endl; n   else { n     cout.precision(19); n     cout << ans << endl; n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int main() { n   long long int t; n   cin >> t; n   while (t--) { n     long long int temperature; n     long long int a12, b11; n     long long int solution; n     cin >> a12 >> b11; n     if (b11 == a12) { n       solution = 0; n     } else if (b11 > a12) { n       temperature = b11 - a12; n       if (temperature & 1) { n         solution = 1; n       } else { n         solution = 2; n       } n     } else { n       temperature = a12 - b11; n       if (temperature & 1) { n         solution = 2; n       } else { n         solution = 1; n       } n     } n     cout << solution <<   n ; n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n int a[26]; n int w[256]; n int n; n int LIMIT = 1; n int su[26], sv[26], sk[26]; n int go(int lev) { n   if (a[lev] == n) { n     printf( %d n , lev); n     for (int i = 0; i < lev; i++) n       if (su[i] == -1) { n         printf( lea e%cx, [%d*e%cx] n ,  a  + i + 1, 1 << sk[i],  a  + sv[i]); n       } else if (sk[i] == 0) n         printf( lea e%cx, [e%cx + e%cx] n ,  a  + i + 1,  a  + su[i], n                 a  + sv[i]); n       else n         printf( lea e%cx, [e%cx + %d*e%cx] n ,  a  + i + 1,  a  + su[i], n                1 << sk[i],  a  + sv[i]); n     return 1; n   } n   if (lev >= LIMIT) return 0; n   int &i = su[lev], &j = sv[lev], &k = sk[lev]; n   i = -1; n   for (j = 0; j <= lev; j++) n     for (k = 0; k <= 3; k++) { n       int v = (a[j] << k); n       if (v > a[lev] && v <= n) { n         a[lev + 1] = v; n         if (go(lev + 1)) return 1; n         a[lev + 1] = 0; n       } n     } n   for (i = 0; i <= lev; i++) n     for (j = 0; j <= lev; j++) { n       for (k = 0; k <= 3; k++) { n         int v = a[i] + (a[j] << k); n         if (v > a[lev] && v <= n) { n           a[lev + 1] = v; n           if (go(lev + 1)) return 1; n           a[lev + 1] = 0; n         } n       } n     } n   return 0; n } n int main(void) { n   scanf( %d , &n); n   if (n == 1) { n     printf( 0 n ); n     return 0; n   } n   a[0] = 1; n   w[1] = 1; n   for (LIMIT = 1;; LIMIT++) { n     if (go(0)) { n       break; n     } n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int n; n int main() { n   ios_base::sync_with_stdio(0); n   cin.tie(0); n   cin >> n; n   long long ans = 0; n   for (int i = 2; i <= n; i++) n     for (int j = i + i; j <= n; j += i) ans += j / i; n   cout << ans * 4 << endl; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int64_t INF = INT64_MAX / 4; n const int64_t NINF = -INF; n map<pair<int64_t, uint32_t>, int64_t> dp; n int64_t grundy(int64_t pile, uint32_t pattern) { n   if (pile == 0) { n     return 0; n   } n   pair<int64_t, uint32_t> key = {pile, pattern}; n   auto fd = dp.find(key); n   if (fd != dp.end()) { n     return fd->second; n   } n   bitset<32> bs(pattern); n   set<int64_t> res; n   for (int64_t i = 0; i < pile; i++) { n     if (!bs[i]) { n       bs[i] = true; n       res.insert(grundy(pile - (i + 1), bs.to_ulong())); n       bs[i] = false; n     } n   } n   int64_t ans = 0; n   while (res.find(ans) != res.end()) { n     ans++; n   } n   dp.insert({key, ans}); n   return ans; n } n int main() { n   ios::sync_with_stdio(0); n   cin.tie(0); n   cout.tie(0); n   int64_t n; n   cin >> n; n   int64_t ans = 0; n   for (int64_t i = 0; i < n; i++) { n     int64_t pile; n     cin >> pile; n     ans ^= grundy(pile, 0); n   }; n   if (ans == 0) { n     cout <<  YES ; n   } else { n     cout <<  NO ; n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n long long p, q, b, t, g; n long long gcd(long long a, long long b) { n   if (a < b) swap(a, b); n   while (b != 0) { n     a %= b; n     swap(a, b); n   } n   return a; n } n int main() { n   ios::sync_with_stdio(0); n   cin.tie(0); n   cin >> t; n   while (t--) { n     cin >> p >> q >> b; n     g = gcd(p, q); n     q /= g; n     while (true) { n       g = gcd(b, q); n       if (g == 1) break; n       while (q % g == 0) q /= g; n     } n     if (q == 1) n       cout <<  Finite ; n     else n       cout <<  Infinite ; n     cout <<   n ; n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n #pragma GCC target( avx ) n #pragma GCC optimize( O3 ) n #pragma GCC optimize( unroll-loops ) n using namespace std; n int dx[4] = {1, 0, -1, 0}; n int dy[4] = {0, 1, 0, -1}; n int main() { n   long long A, B, C, D, E, F, N, K, M, Z, sum = 0, num = 0, flag = 0; n   string S, T; n   cin >> Z; n   queue<long long> que; n   while (Z--) { n     cin >> S; n     vector<long long> P(0, 0); n     num = 0; n     S +=  0 ; n     for (long long int i = 0; i < S.size(); i++) { n       if (S[i] ==  1 ) n         num++; n       else { n         P.push_back(num); n         num = 0; n       } n     } n     sort(P.begin(), P.end()); n     reverse(P.begin(), P.end()); n     sum = 0; n     for (long long int i = 0; i < P.size(); i++) { n       sum += P[i]; n       i++; n     } n     que.push(sum); n   } n   while (!que.empty()) { n     cout << que.front() << endl; n     que.pop(); n   } n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int main() { n   ios_base::sync_with_stdio(false); n   cin.tie(0); n   int k, n; n   cin >> n >> k; n   int x[n]; n   for (int i = 0; i < n; i++) { n     cin >> x[i]; n   } n   double m = -1, sum = 0; n   int c = 0; n   for (int i = 0; i < n; i++) { n     for (int j = i; j < n; j++) { n       c++; n       sum += x[j]; n       if (c >= k && (sum / c) > m) { n         m = sum / c; n       } n     } n     c = 0; n     sum = 0; n   } n   cout << setprecision(15) << fixed << m << endl; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n long long powm(long long base, long long exp, long long mod = 1000000009) { n   long long ans = 1; n   while (exp) { n     if (exp & 1) ans = (ans * base) % mod; n     exp >>= 1, base = (base * base) % mod; n   } n   return ans; n } n long long ctl(char x, char an =  a ) { return (long long)(x - an); } n char ltc(long long x, char an =  a ) { return (char)(x + an); } n long long first[300005], pref[300005], pref_fib[300005], a[300005]; n long long get_fibo_sum(long long l, long long r) { n   return (pref_fib[r] - (l ? pref_fib[l - 1] : 0) + 1000000009) % 1000000009; n } n long long get_fibo(long long st1, long long st2, long long i) { n   if (i == 0) n     return st1; n   else if (i == 1) n     return st2; n   else { n     long long ret = ((first[i - 1] * st2) % 1000000009 + n                      (first[i - 2] * st1) % 1000000009) % n                     1000000009; n     return ret; n   } n } n long long get_fibo_sum(long long st1, long long st2, long long i) { n   if (i == 0) n     return st1; n   else if (i == 1) n     return (st1 + st2) % 1000000009; n   else { n     long long ans = (st2 * get_fibo_sum(1, i - 1)) % 1000000009; n     ans = (ans + (st1 * get_fibo_sum(0, i - 2)) % 1000000009) % 1000000009; n     ans = (ans + st1) % 1000000009; n     ans = (ans + st2) % 1000000009; n     return ans; n   } n } n const pair<long long, long long> khali = make_pair(0LL, 0LL); n struct lazySegTree { n   long long tree[4 * 300005], x, y, val; n   pair<long long, long long> lazy[4 * 300005]; n   void push(long long low, long long high, long long pos) { n     if (lazy[pos] != khali) { n       tree[pos] += n           get_fibo_sum(lazy[pos].first, lazy[pos].second, (high - low)); n       if (low != high) { n         pair<long long, long long> tmp; n         tmp = lazy[pos]; n         lazy[2 * pos + 1].first = n             (lazy[2 * pos + 1].first + tmp.first) % 1000000009; n         lazy[2 * pos + 1].second = n             (lazy[2 * pos + 1].second + tmp.second) % 1000000009; n         tmp.first = get_fibo(lazy[pos].first, lazy[pos].second, n                              (low + high) / 2 - low + 1); n         tmp.second = get_fibo(lazy[pos].first, lazy[pos].second, n                               (low + high) / 2 - low + 2); n         lazy[2 * pos + 2].first = n             (lazy[2 * pos + 2].first + tmp.first) % 1000000009; n         lazy[2 * pos + 2].second = n             (lazy[2 * pos + 2].second + tmp.second) % 1000000009; n       } n       lazy[pos] = khali; n     } n   } n   long long query(long long low, long long high, long long pos) { n     push(low, high, pos); n     if (x <= low and y >= high) return tree[pos]; n     if (x > high || y < low) return 0; n     long long mid = (high + low) / 2; n     return (query(low, mid, 2 * pos + 1) + query(mid + 1, high, 2 * pos + 2)) % n            1000000009; n   } n   void update(long long low, long long high, long long pos) { n     push(low, high, pos); n     if (x > high || y < low) return; n     if (x <= low and y >= high) { n       lazy[pos].first = first[low - x]; n       lazy[pos].second = first[low - x + 1]; n       push(low, high, pos); n       return; n     } n     long long mid = (low + high) / 2; n     update(low, mid, 2 * pos + 1), update(mid + 1, high, 2 * pos + 2); n     tree[pos] = (tree[2 * pos + 1] + tree[2 * pos + 2]) % 1000000009; n   } n } lst; n int main() { n   first[0] = 1, first[1] = 1; n   for (long long i = 2; i < 300005; i++) n     first[i] = (first[i - 1] + first[i - 2]) % 1000000009; n   for (long long i = 0; i < 4 * 300005; i++) lst.lazy[i] = khali; n   long long type, l, r, n, q; n   cin >> n >> q; n   for (long long i = 1; i < n + 1; i++) cin >> a[i]; n   pref_fib[0] = 1; n   for (long long i = 1; i < 300005; i++) n     pref_fib[i] = (pref_fib[i - 1] + first[i]) % 1000000009; n   pref[1] = a[1]; n   for (long long i = 1; i < 300005; i++) n     pref[i] = (pref[i - 1] + a[i]) % 1000000009; n   while (q--) { n     cin >> type >> l >> r; n     lst.x = l, lst.y = r; n     if (type == 1) { n       lst.update(1, n, 0); n     } else { n       long long ans = lst.query(1, n, 0); n       ans = (ans + pref[r]) % 1000000009; n       ans = (ans - pref[l - 1] + 1000000009) % 1000000009; n       cout << ans <<   n ; n     } n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n void solve() { n   int n; n   std::cin >> n; n   std::stack<int> q; n   int a = 0; n   int cur = 1; n   n += n; n   while (n--) { n     std::string s; n     std::cin >> s; n     if (s[0] ==  r ) { n       if (!q.empty() && q.top() != cur) { n         while (!q.empty()) q.pop(); n         ++a; n       } n       if (!q.empty()) q.pop(); n       ++cur; n     } else { n       int x; n       std::cin >> x; n       q.push(x); n     } n   } n   std::cout << a; n } n int main() { n   std::ios_base::sync_with_stdio(false); n   std::cin.tie(nullptr); n   solve(); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n template <typename T> n inline bool smin(T &a, const T &b) { n   return b < a ? a = b, 1 : 0; n } n template <typename T> n inline bool smax(T &a, const T &b) { n   return a < b ? a = b, 1 : 0; n } n const long long N = 1e5 + 100, lg = 22; n long long n, k, add[N], h[N]; n vector<pair<long long, long long> > adj[N]; n long long par[N][lg]; n void dfs(long long v = 1, long long p = -1, long long dep = 0) { n   if (v != 1) { n     par[v][0] = p; n     for (long long i = 1; i < lg; i++) par[v][i] = par[par[v][i - 1]][i - 1]; n   } else { n     for (long long i = 0; i < lg; i++) par[v][i] = v; n   } n   h[v] = dep; n   for (auto u : adj[v]) n     if (u.first != p) dfs(u.first, v, dep + 1); n } n long long getPar(long long v, long long k) { n   for (long long i = lg - 1; i >= 0; i--) n     if (k >> i & 1) v = par[v][i]; n   return v; n } n long long lca(long long u, long long v) { n   if (h[u] > h[v]) swap(u, v); n   v = getPar(v, h[v] - h[u]); n   if (u == v) return v; n   for (long long i = lg - 1; i >= 0; i--) { n     if (par[u][i] != par[v][i]) u = par[u][i], v = par[v][i]; n   } n   return par[v][0]; n } n long long ans[N]; n long long calc(long long v = 1, long long p = -1, long long want = -1) { n   long long res = add[v]; n   for (auto u : adj[v]) { n     if (u.first == p) continue; n     res += calc(u.first, v, u.second); n   } n   if (want != -1) ans[want] = res; n   return res; n } n int32_t main() { n   cin >> n; n   for (long long i = 0; i < n - 1; i++) { n     long long u, v; n     cin >> u >> v; n     adj[v].push_back({u, i}), adj[u].push_back({v, i}); n   } n   dfs(); n   cin >> k; n   while (k--) { n     long long u, v; n     cin >> u >> v; n     long long l = lca(u, v); n     add[u]++, add[v]++, add[l] -= 2; n   }; n   calc(); n   for (long long i = 0; i < n - 1; i++) cout << ans[i] <<    ; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int main() { n   ios_base::sync_with_stdio(0); n   cin.tie(0); n   cout.tie(0); n   int n; n   cin >> n; n   int arr[n][4]; n   multiset<int> s[4]; n   for (int i = 0; i < n; i++) { n     for (int j = 0; j < 4; j++) { n       cin >> arr[i][j]; n       s[j].insert(arr[i][j]); n     } n   } n   for (int i = 0; i < n; i++) { n     for (int j = 0; j < 4; j++) { n       auto temp = s[j].find(arr[i][j]); n       s[j].erase(temp); n     } n     if (*s[0].rbegin() <= *s[2].begin() && *s[1].rbegin() <= *s[3].begin()) { n       cout << *s[0].rbegin() <<     << *s[1].rbegin() << endl; n       break; n     } n     for (int j = 0; j < 4; j++) s[j].insert(arr[i][j]); n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n void solve() { n   long long n, m, k; n   cin >> n >> m >> k; n   long long p[m]; n   for (long long int i = 0; i < m; i++) cin >> p[i]; n   sort(p, p + m); n   long long an = 0, x = 0, c = 0, cp = 1; n   while (1) { n     long long y = x, pg = ceil((long double)(p[x] - x) / (k)); n     while (y < m && ceil((long double)(p[y] - x) / (k)) == pg) y++; n     if (y == m) { n       cout << an + 1; n       return; n     } n     an++; n     x = y; n   } n } n int main() { n   ios_base::sync_with_stdio(false); n   cin.tie(0); n   cout.tie(0); n   long long TESTS = 1; n   while (TESTS--) { n     solve(); n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int main() { n   int requestNum; n   cin >> requestNum; n   vector<pair<int, pair<int, int>>> vect(requestNum); n   for (int i = 0; i < requestNum; i++) { n     int num, money; n     cin >> num >> money; n     vect.push_back(make_pair(money, make_pair(num, i + 1))); n   } n   sort(vect.rbegin(), vect.rend()); n   int tablesNum; n   cin >> tablesNum; n   vector<pair<int, int>> maxPeople(tablesNum); n   for (int i = 0; i < tablesNum; i++) { n     cin >> maxPeople[i].first; n     maxPeople[i].second = i + 1; n   } n   sort(maxPeople.begin(), maxPeople.end()); n   vector<bool> tablesFull(tablesNum, false); n   long long int totalMoney = 0; n   vector<pair<long, long>> result; n   for (int i = 0; i < requestNum; i++) { n     for (int j = 0; j < tablesNum; j++) { n       if (vect[i].second.first <= maxPeople[j].first && !tablesFull[j]) { n         result.push_back(make_pair(vect[i].second.second, maxPeople[j].second)); n         totalMoney += vect[i].first; n         tablesFull[j] = true; n         break; n       } n     } n   } n   cout << result.size() <<     << totalMoney << endl; n   for (int i = 0; i < result.size(); i++) { n     cout << result[i].first <<     << result[i].second << endl; n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const long long N = 2e5 + 5, inf = 1e18, mod = 1e9 + 7; n const double PI = 3.1415926536; n int days[13] = {0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}; n bool is_prime(long long n) { n   for (long long i = 2; i * i <= n; ++i) { n     if (n % i == 0) { n       return false; n     } n   } n   return true; n } n inline long long getPow(long long a, long long b) { n   long long res = 1ll, tp = a; n   while (b) { n     if (b & 1ll) { n       res *= tp; n     } n     tp *= tp; n     b >>= 1ll; n   } n   return res; n } n long long vec_mult(const pair<long long, long long> &t1, n                    const pair<long long, long long> &t2, n                    const pair<long long, long long> &t3) { n   const long long &x1 = t1.first, y1 = t1.second; n   const long long &x2 = t2.first, y2 = t2.second; n   const long long &x3 = t3.first, y3 = t3.second; n   return ((x2 - x1) * (y3 - y1) - (y2 - y1) * (x3 - x1)); n } n void ok() { n   cout <<  YES  << endl; n   exit(0); n } n void no() { n   cout <<  NO  << endl; n   exit(0); n } n inline long long nxt() { n   long long x; n   cin >> x; n   return x; n } n long long otr(long long num) { n   long long cur = 0; n   long long ct = 1; n   while (num) { n     cur += ct * (9 - num % 10); n     num /= 10; n     ct *= 10; n   } n   return cur; n } n int main() { n   ios_base::sync_with_stdio(false); n   cin.tie(0), cout.tie(0); n   long long l = nxt(), r = nxt(); n   long long t = 1ll; n   long long ans = -1; n   while (t <= r) { n     long long left = max(l, t); n     long long right = min(r, 10ll * t - 1); n     while (right - left > 2) { n       long long len = (right - left + 1) / 3; n       long long t1 = left + len; n       long long t2 = right - len; n       if (t1 * otr(t1) >= t2 * otr(t2)) { n         right = t2; n       } else { n         left = t1; n       } n     } n     while (left <= right) { n       ans = max(ans, left * otr(left)); n       left++; n     } n     t *= 10ll; n   } n   cout << ans; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n void faster() { n   ios_base::sync_with_stdio(false); n   cin.tie(NULL); n   cout.tie(NULL); n } n string s, x, t, ans; n long long q, n, a[456789], b[456789], sum, prefa[456789], prefb[456789], k, l, n     r, mx; n bool ok; n void dii() { n   cin >> n; n   for (int i = 1; i <= n; i++) { n     cin >> a[i]; n   } n   k = 1; n   for (int i = 1; i <= n; i++) { n     if (a[i] <= 2 * a[i - 1]) { n       k++; n     } else { n       k = 1; n     } n     if (k > mx) { n       mx = k; n     } n   } n   cout << mx; n } n int main() { n   faster(); n   q = 1; n   while (q--) { n     dii(); n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n const int INF = 1 << 29; n int main() { n   std::ios_base::sync_with_stdio(false); n   std::cin.tie(NULL); n   ; n   int n; n   std::cin >> n; n   std::vector<int> v(n); n   for (int &it : v) std::cin >> it; n   int alice = v[0]; n   int sum = std::accumulate(v.begin(), v.end(), 0); n   int target = sum / 2 + 1; n   std::vector<int> ans; n   ans.push_back(1); n   int cur = alice; n   for (int i = 0; i < n; i++) { n     if (alice < v[i] * 2) continue; n     cur += v[i]; n     ans.push_back(i + 1); n     if (cur >= target) break; n   } n   if (cur < target) { n     std::cout << 0; n     exit(0); n   } else { n     std::cout << ans.size() <<   n ; n     for (int it : ans) std::cout << it <<    ; n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n void dfs(int64_t node, int64_t from, n          const std::vector<std::vector<int64_t> > &g, n          std::vector<bool> &visited, int64_t &count, bool &cycle, bool &self) { n   if (visited[node]) { n     return; n   } n   visited[node] = 1; n   ++count; n   for (int64_t p = 0; p < g[node].size(); p++) { n     int64_t u = g[node][p]; n     if (u == from) { n       continue; n     } else if (u == node) { n       self = true; n     } else if (visited[u]) { n       cycle = true; n     } else { n       dfs(u, node, g, visited, count, cycle, self); n     } n   } n   return; n } n int main() { n   const int64_t MOD = 1000000007; n   int64_t n; n   scanf( %lld , &n); n   std::vector<std::vector<int64_t> > g(2 * n); n   for (int64_t p = 0; p < n; p++) { n     int64_t x, y; n     scanf( %lld %lld , &x, &y); n     --x; n     --y; n     g[x].push_back(y); n     g[y].push_back(x); n   } n   std::vector<bool> visited(2 * n, false); n   int64_t total(1); n   for (int64_t p = 0; p < 2 * n; p++) { n     if (visited[p]) { n       continue; n     } n     int64_t count(0); n     bool cycle(false), self(false); n     dfs(p, -1, g, visited, count, cycle, self); n     if (self) { n       count = 1; n     } else if (cycle) { n       count = 2; n     } n     total *= count; n     total %= MOD; n   } n   printf( %lld n , total); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n const int N = 1010, M = 2010; n int las[M], nxt[M], to[M], cnt; n int l[M], r[M], siz[M], mx[N][N], f[N]; n inline void add(int u, int v) { n   cnt++; n   to[cnt] = v; n   nxt[cnt] = las[u]; n   las[u] = cnt; n } n int n, m; n inline void fmin(int &a, int b) { n   if (a > b) a = b; n } n inline void fmax(int &a, int b) { n   if (a < b) a = b; n } n void dfs(int now) { n   int i; n   siz[now] = now != 1; n   if (las[now]) l[now] = n, r[now] = 0; n   for (i = las[now]; i; i = nxt[i]) n     dfs(to[i]), siz[now] += siz[to[i]], fmin(l[now], l[to[i]]), n         fmax(r[now], r[to[i]]); n   fmax(mx[l[now]][r[now]], siz[now]); n } n int main() { n   int i, j, x; n   scanf( %d , &n); n   scanf( %d , &m); n   for (i = 2; i <= m; i++) scanf( %d , &x), add(x, i); n   for (i = 1; i <= n; i++) scanf( %d , &x), l[x] = r[x] = i; n   dfs(1); n   cnt = 0; n   memset(las, 0, sizeof las); n   scanf( %d , &m); n   for (i = 2; i <= m; i++) scanf( %d , &x), add(x, i); n   for (i = 1; i <= n; i++) scanf( %d , &x), l[x] = r[x] = i; n   dfs(1); n   for (i = 1; i <= n; i++) n     for (j = 1; j <= i; j++) n       if (mx[j][i]) fmax(f[i], f[j - 1] + mx[j][i]); n   printf( %d n , f[n]); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int N = 100010; n int n, ans[N], an; n struct edge { n   int to, nx, id, dl; n } ee[N]; n int eq[N], en = 1; n void dfs(int d) { n   for (int j = eq[d], k; k = ee[j].to, j; j = ee[j].nx) n     if (!ee[j].dl) { n       ee[j].dl = 1; n       dfs(k); n       ans[--an] = ee[j].id; n     } n } n int main() { n   scanf( %d , &n); n   if (n & 1) { n     printf( -1 n ); n     return 0; n   } n   for (int x = 0, t1, t2; x < n; x++) { n     t1 = (x * 2 + 0) % n; n     t2 = (x * 2 + 1) % n; n     ee[++en] = (edge){((t1) / 2 + 1), eq[((x) / 2 + 1)], x, 0}, n     eq[((x) / 2 + 1)] = en; n   } n   an = n; n   dfs(1); n   for (int s = 0; s < n; s++) n     if (ans[s] == 0) { n       for (int i = 0; i < n; i++) printf( %d  , ans[(s + i) % n]); n       printf( 0 n ); n       return 0; n     } n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n void _print(long long t) { cerr << t; } n void _print(int t) { cerr << t; } n void _print(string t) { cerr << t; } n void _print(char t) { cerr << t; } n void _print(long double t) { cerr << t; } n void _print(double t) { cerr << t; } n void _print(unsigned long long t) { cerr << t; } n template <class T, class V> n void _print(pair<T, V> p); n template <class T> n void _print(vector<T> v); n template <class T> n void _print(set<T> v); n template <class T, class V> n void _print(map<T, V> v); n template <class T> n void _print(multiset<T> v); n template <class T, class V> n void _print(pair<T, V> p) { n   cerr <<  { ; n   _print(p.first); n   cerr <<  , ; n   _print(p.second); n   cerr <<  } ; n } n template <class T> n void _print(vector<T> v) { n   cerr <<  [  ; n   for (T i : v) { n     _print(i); n     cerr <<    ; n   } n   cerr <<  ] ; n } n template <class T> n void _print(set<T> v) { n   cerr <<  [  ; n   for (T i : v) { n     _print(i); n     cerr <<    ; n   } n   cerr <<  ] ; n } n template <class T> n void _print(multiset<T> v) { n   cerr <<  [  ; n   for (T i : v) { n     _print(i); n     cerr <<    ; n   } n   cerr <<  ] ; n } n template <class T, class V> n void _print(map<T, V> v) { n   cerr <<  [  ; n   for (auto i : v) { n     _print(i); n     cerr <<    ; n   } n   cerr <<  ] ; n } n template <class T, class V> n void _print(unordered_map<T, V> v) { n   cerr <<  [  ; n   for (auto i : v) { n     _print(i); n     cerr <<    ; n   } n   cerr <<  ] ; n } n template <class T> n void _print(list<T> v) { n   cerr <<  [  ; n   for (T i : v) { n     _print(i); n     cerr <<    ; n   } n   cerr <<  ] ; n } n int main() { n   ios_base::sync_with_stdio(false); n   cin.tie(NULL); n   cout.tie(NULL); n   int tc = 0, T; n   cin >> T; n   while (++tc <= T) { n     int N; n     cin >> N; n     cout << (int)sqrt(N) + (int)cbrt(N) - (int)sqrt((int)cbrt(N)) << endl; n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int MOD = 1e9 + 7; n const double pi = acos(-1); n const double EPS = 1e-9; n long long binpowmod(long long a, long long b) { n   a %= MOD; n   long long ret = 1; n   while (b) { n     if (b & 1) ret = ret * a % MOD; n     a = a * a % MOD; n     b >>= 1; n   } n   return ret % MOD; n } n long long gcd(long long a, long long b) { n   if (!b) return a; n   return gcd(b, a % b); n } n const int N = 1 << 18; n const int E = N * 2; n bool good(long long n) { n   long long t = n; n   int sumofdigits = 0; n   while (n) { n     sumofdigits += n % 10; n     n /= 10; n   } n   return (gcd(t, sumofdigits) > 1); n } n int n, m, ans; n vector<vector<int> > a; n bool good(int i, int j) { n   for (int k = 0; k < m; ++k) { n     if (a[i][k] != a[j][k]) return false; n   } n   return true; n } n void solveit(int l = 0, int r = n - 1, int c = 1) { n   int len = r - l + 1; n   if (len % 2) return; n   int i = l, j = r; n   while (i < j) { n     if (!good(i, j)) return; n     i++; n     j--; n   } n   ans = min(ans, n / (1 << c)); n   int mid = (l + r) / 2; n   solveit(l, mid, c + 1); n   solveit(mid + 1, r, c + 1); n } n void solve() { n   cin >> n >> m; n   ans = n; n   a.assign(n, vector<int>(m)); n   for (int i = 0; i < n; ++i) n     for (int j = 0; j < m; ++j) cin >> a[i][j]; n   solveit(); n   cout << ans <<   n ; n } n int main(void) { n   ios::sync_with_stdio(false); n   cin.tie(NULL); n   cout.tie(NULL); n   int tc = 1; n   while (tc--) { n     solve(); n   } n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int main() { n   int n, k; n   scanf( %d%d , &n, &k); n   long long ans1 = 1, ans2 = 1; n   for (int i = 1; i <= k - 1; i++) ans1 = ans1 * k % 1000000007; n   for (int i = 1; i <= n - k; i++) ans2 = ans2 * (n - k) % 1000000007; n   printf( %I64d n , ans1 * ans2 % 1000000007); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int N = 25, mod = 1e9 + 7; n int a[N][N], used[N][N], cur, first, n, m, k; n long long ans; n int count(int x) { n   int ans = 0; n   for (; x; x -= x & -x) ans++; n   return ans; n } n void dfs(int x, int y) { n   if (x == n) { n     int p = count(cur & ~first), q = count(((1 << k) - 1) & ~first); n     long long curans = 1; n     while (p--) { n       curans = (curans * q) % mod; n       q--; n     } n     ans = (ans + curans) % mod; n     return; n   } n   int nx = x, ny = y + 1; n   if (ny == m) { n     nx++; n     ny = 0; n   } n   if (a[x][y]) { n     dfs(nx, ny); n     return; n   } else { n     bool flag = true; n     int can = (1 << k) - 1; n     can &= ~used[x][y]; n     for (int i = 0; (1 << i) <= can; i++) { n       if (!((can >> i) & 1)) continue; n       bool preused[N][N], preusedcur; n       preusedcur = true; n       memset(preused, false, sizeof(preused)); n       if (!((cur >> i) & 1)) { n         if (flag) n           flag = false; n         else n           continue; n         preusedcur = false; n       } n       cur |= 1 << i; n       for (int px = x; px < n; px++) n         for (int py = y; py < m; py++) { n           if ((used[px][py] >> i) & 1) n             preused[px][py] = true; n           else n             used[px][py] |= 1 << i; n         } n       dfs(nx, ny); n       if (!preusedcur) cur &= ~(1 << i); n       for (int px = x; px < n; px++) n         for (int py = y; py < m; py++) { n           if (!preused[px][py]) used[px][py] &= ~(1 << i); n         } n     } n   } n } n int main() { n   scanf( %d%d%d , &n, &m, &k); n   if (n + m - 1 > k) { n     printf( 0 n ); n     return 0; n   } n   for (int i = 0; i < n; i++) n     for (int j = 0; j < m; j++) { n       scanf( %d , &a[i][j]); n       if (a[i][j]) { n         first |= 1 << a[i][j] - 1; n         if ((used[i][j] >> a[i][j] - 1) & 1) { n           printf( 0 n ); n           return 0; n         } n         for (int r = 0; r < n; r++) n           for (int c = 0; c < m; c++) { n             if (r <= i && c <= j || r >= i && c >= j) n               used[r][c] |= 1 << a[i][j] - 1; n           } n       } n     } n   cur = first; n   dfs(0, 0); n   printf( %d n , ans); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int main() { n   int p1, p2, p3, p4, a, b; n   cin >> p1 >> p2 >> p3 >> p4 >> a >> b; n   int m = min(min(min(p1, p2), p3), p4); n   cout << max(0, min(b + 1, m) - a) << endl; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n const int inf = (1 << 30) - 1; n const double eps = 1e-9; n using namespace std; n int a[111111], n, k, mx = 0, aa; n long long s[111111]; n int main() { n   scanf( %d%d , &n, &k); n   for (int i = 1; i <= n; i++) scanf( %d , &a[i]); n   sort(a + 1, a + n + 1); n   for (int i = 1; i <= n; i++) s[i] = s[i - 1] + a[i]; n   for (int i = 1; i <= n; i++) { n     int l = 1, r = i; n     while (r > l) { n       int m = (l + r) / 2; n       long long ss = s[i] - s[m - 1]; n       if (1ll * a[i] * (i - m + 1) - ss > k) n         l = m + 1; n       else n         r = m; n     } n     if (i - r + 1 > mx) { n       mx = i - r + 1; n       aa = a[i]; n     } n   } n   cout << (mx) <<    ; n   cout << (aa) << endl; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int n; n double dp[(1 << 20)]; n double a[20][20]; n int main() { n   cin >> n; n   for (int i = 0; i < n; i++) { n     for (int j = 0; j < n; j++) { n       cin >> a[i][j]; n     } n   } n   dp[(1 << n) - 1] = 1.0; n   for (int st = (1 << n) - 1; st >= 0; st--) { n     for (int i = 0; i < n; i++) { n       if (st & (1 << i)) { n         for (int j = 0; j < n; j++) { n           if ((st & (1 << j)) && (i != j)) { n             int q = __builtin_popcount(st); n             dp[st ^ (1 << j)] += dp[st] * a[i][j] * (1.0 / (q * (q - 1) / 2)); n           } n         } n       } n     } n   } n   for (int i = 1; i < (1 << n); i = (i << 1)) { n     printf( %.6f  , dp[i]); n   } n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int pr[] = {2, 3, 5, 7, 11, 13, 17, 19}; n int big[50000005]; n int c[10]; n int ans[10100]; n int main() { n   int k; n   scanf( %d , &k); n   big[1] = 0; n   for (int i = 0; i < 7; i++) big[pr[i]] = i + 1; n   for (int i = 2; i <= 2 * k * k; i++) { n     if (big[i] == 0) continue; n     for (int j = 0; j < 7; j++) { n       if (i * pr[j] <= 2 * k * k) { n         big[i * pr[j]] = max(big[i], j + 1); n       } n     } n     for (int j = big[i] - 1; j < 7; j++) c[j]++; n   } n   for (int j = 0; j < 7; j++) n     if (c[j] >= k) { n       int sz = 0; n       for (int i = 2 * k * k; i >= 0; i--) n         if (big[i] != 0 && big[i] - 1 <= j && n             big[i / pr[big[i] - 1]] - 1 < big[i] - 1) { n           ans[sz++] = i; n           if (sz == k) break; n         } n       if (sz < k) continue; n       for (int i = sz - 1; i >= 0; i--) printf( %d  , ans[i]); n       printf(  n ); n       return 0; n     } n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int maxn = 1e7 + 5; n int s[maxn]; n int a[maxn]; n int main() { n   int n; n   scanf( %d , &n); n   long long ans = 0; n   for (int i = 1; i <= n; i++) { n     scanf( %d , &s[i]); n   } n   sort(s + 1, s + n + 1); n   for (int i = 1; i <= n / 2; i++) { n     a[i] = s[i] + s[n + 1 - i]; n     ans += a[i] * a[i]; n   } n   printf( %lld n , ans); n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const long double EPS = 1e-9; n long long Power(long long a, long long b) { n   if (b == 0) return 1; n   long long p = Power(a, b / 2); n   p = (p * p); n   if (b & 1) { n     p = (p * a); n   } n   return p; n } n long long Gcd(long long a, long long b) { n   if (b == 0) return a; n   if (a < b) return Gcd(b, a); n   return Gcd(b, a % b); n } n void Solve() { n   int n, m; n   long long l; n   cin >> n >> m >> l; n   vector<long long> arr(n), seg(n, -1); n   for (int i = 0; i < n; i++) cin >> arr[i]; n   int curr = 0, prev = -1; n   for (int i = 0; i < n; i++) { n     if (arr[i] > l) { n       seg[i] = 0; n       if (prev == -1) { n         curr++; n       } n       prev = 0; n     } else { n       prev = -1; n       seg[i] = -1; n     } n   } n   while (m--) { n     int t; n     cin >> t; n     if (t == 0) { n       cout << curr <<   n ; n     } else { n       int p; n       long long d; n       cin >> p >> d; n       p--; n       arr[p] += d; n       if (seg[p] == -1 && arr[p] > l) { n         seg[p] = 0; n         if (p == 0) { n           if (p + 1 < n && seg[p + 1] == -1) { n             curr++; n           } else if (n == 1) { n             curr++; n           } n         } else if (p == n - 1) { n           if (p - 1 >= 0 && seg[p - 1] == -1) { n             curr++; n           } else if (n == 1) { n             curr++; n           } n         } else { n           if (seg[p - 1] == 0 && seg[p + 1] == 0) { n             curr--; n           } else if (seg[p - 1] == -1 && seg[p + 1] == -1) { n             curr++; n           } n         } n       } n     } n   } n } n int main() { n   int t = 1; n   while (t--) { n     Solve(); n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int N = 2e4 + 5; n char s[N]; n int dp[10][N]; n int ans[N]; n int len; n int dfs(int num, int idx) { n   if (~dp[num][idx]) return dp[num][idx]; n   if (idx == len) n     return 1; n   else if (idx > len) n     return 0; n   int &ret = dp[num][idx]; n   ret = dfs(num ^ 1, idx + num); n   bool flag = false; n   for (int i = idx; i < idx + num; ++i) { n     if (s[i] != s[i + num]) { n       flag = true; n       break; n     } n   } n   if (flag) { n     ret = max(ret, dfs(num, idx + num)); n   } n   return ret; n } n const int B = 333; n int cal(char a, char b, char c) { return a * B * B + b * B + c; } n int cal(char a, char b) { return a * B * B + b * B; } n void prt(int x) { n   printf( %c , x / (B * B)); n   printf( %c , x % (B * B) / B); n   if (x % B) { n     printf( %c , x % B); n   } n   puts(  ); n } n int main() { n   while (~scanf( %s , s)) { n     memset(dp, -1, sizeof(dp)); n     int cnt = 0; n     len = strlen(s); n     for (int i = len - 2; i >= 5; --i) { n       if (dfs(2, i) == 1) { n         ans[cnt++] = (cal(s[i], s[i + 1])); n       } n       if (dfs(3, i) == 1) { n         ans[cnt++] = (cal(s[i], s[i + 1], s[i + 2])); n       } n     } n     sort(ans, ans + cnt); n     cnt = unique(ans, ans + cnt) - ans; n     printf( %d n , cnt); n     for (int i = 0; i < cnt; ++i) { n       prt(ans[i]); n     } n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n long long jc[210000], ny[210000]; n char s[210000]; n int n, f[210000], g[210000], ans; n int C(int n, int m) { n   if (m > n) return 0; n   return jc[n] * ny[m] % 1000000007 * ny[n - m] % 1000000007; n } n int main() { n   scanf( %s , s + 1); n   n = strlen(s + 1); n   for (int i = 1; i <= n; i++) { n     f[i] = f[i - 1]; n     if (s[i] ==  ( ) f[i]++; n   } n   for (int i = n; i >= 1; i--) { n     g[i] = g[i + 1]; n     if (s[i] ==  ) ) g[i]++; n   } n   jc[0] = jc[1] = ny[0] = ny[1] = 1; n   for (int i = 2; i <= n; i++) n     jc[i] = jc[i - 1] * i % 1000000007, n     ny[i] = (long long)(-1000000007 / i) * ny[1000000007 % i] % 1000000007; n   for (int i = 2; i <= n; i++) ny[i] = ny[i] * ny[i - 1] % 1000000007; n   for (int i = 1; i <= n; i++) n     if (s[i] ==  ( ) ans = (ans + C(f[i] + g[i] - 1, f[i])) % 1000000007; n   ans = (ans + 1000000007) % 1000000007; n   printf( %d n , ans); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const long long INF = 1e18; n const int mod = 1e9 + 7; n const int N = 100 + 10; n inline int add(int x, int y) { n   x += y; n   if (x >= mod) x -= mod; n   return x; n } n inline int mul(int x, int y) { n   x = (1LL * x * y) % mod; n   return x; n } n vector<pair<int, int> > G[N]; n int dp[N][N][30][2]; n int f(int i, int j, int last, int turn) { n   int &ret = dp[i][j][last][turn]; n   if (~ret) return ret; n   ret = 0; n   if (turn == 1) { n     for (auto it : G[i]) { n       int nxt = it.first; n       int ed = it.second; n       if (ed >= last) { n         int x = f(nxt, j, ed, 0); n         if (x == 0) return ret = 1; n       } n     } n   } else { n     for (auto it : G[j]) { n       int nxt = it.first; n       int ed = it.second; n       if (ed >= last) { n         int x = f(i, nxt, ed, 1); n         if (x == 0) return ret = 1; n       } n     } n   } n   return ret; n } n int main() { n   ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0); n   memset(dp, -1, sizeof(dp)); n   int n, m; n   cin >> n >> m; n   for (int i = 0; i <= m - 1; ++i) { n     int u, v; n     cin >> u >> v; n     char c; n     cin >> c; n     int x = c -  a ; n     G[u].push_back({v, x}); n   } n   for (int i = 1; i <= n; ++i) { n     for (int j = 1; j <= n; ++j) { n       int curr = f(i, j, 0, 1); n       if (curr == 0) n         cout <<  B ; n       else n         cout <<  A ; n     } n     cout <<   n ; n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n  n const int N = 1e5 + 5; n  n struct query { n  int i, type, l, r, k, p, x; n }; n  n int n, m; n vector<int> a, _a; n query q[N]; n int queryCnt; n int block_size; n int ans[N]; n int freqA[N]; n int freqL[N], freqR[N], freqV[N]; n  n void increaseFreq(int f) { n  freqR[f]++, freqL[f - 1]++, freqV[freqR[f] - 1] = f; n } n  n void decreaseFreq(int f) { n  freqR[f]--, freqL[f - 1]--, freqV[freqR[f]] = f - 1; n } n  n void include(int i) { n  increaseFreq(++freqA[a[i]]); n } n  n void remove(int i) { n  decreaseFreq(freqA[a[i]]--); n } n  n void go(int& fromL, int& fromR, int toL, int toR) { n  // debug() << name(fromL) name(fromR) name(toL) name(toR); n  while (fromL > toL) include(--fromL); n  while (fromR < toR) include(fromR++); n  while (fromL < toL) remove(fromL++); n  while (fromR > toR) remove(--fromR); n } n  n void update(int qi, int L, int R) { n  if (L <= q[qi].p && q[qi].p < R) remove(q[qi].p); n  a[q[qi].p] = q[qi].x; n  if (L <= q[qi].p && q[qi].p < R) include(q[qi].p); n } n  n int answer(int k) { n  vector<pair<int, int>> v; n  for (int at = freqV[1]; at != 0; ) { n   v.push_back({at, freqR[at] - freqL[at]}); n   at = freqV[freqR[at]]; n  } n  reverse(v.begin(), v.end()); n   n  int ret = -1; n  for (int l = 0, r = 0, cnt = 0; l < v.size(); cnt -= v[l++].second) { n   r = max(l, r); n   while (r < v.size() && cnt < k) cnt += v[r++].second; n   if (cnt >= k) { n    int _ret = v[r - 1].first - v[l].first; n    ret = ret == -1 ? _ret : min(ret, _ret); n   } n  } n     // debug() << name(k) name(v) name(ret); n   n  return ret; n } n  n int main() { n  scanf( %d %d , &n, &m); n  _a.resize(n + 1); n  for (int i = 1; i <= n; i++) scanf( %d , &_a[i]); a = _a; n  for (int i = 1; i <= m; i++) { n   q[i].i = i; n   scanf( %d , &q[i].type); n   if (q[i].type == 1) scanf( %d %d %d , &q[i].l, &q[i].r, &q[i].k); n   else scanf( %d %d , &q[i].p, &q[i].x); n   queryCnt += q[i].type == 1; n  } n   n  block_size = ceil(cbrt((long double)2 * n * n)); n   n  sort(q + 1, q + m + 1, [](const query& q1,const query& q2) { n   int l1 = (q1.l - 1) / block_size, r1 = (q1.r - 1) / block_size; n   int l2 = (q2.l - 1) / block_size, r2 = (q2.r - 1) / block_size; n   auto p1 = make_pair(l1, r1); n   auto p2 = make_pair(l2, r2); n    n   if (q1.type == 1) { n    if (q2.type == 1) return make_pair(p1, q1.i) < make_pair(p2, q2.i); n    else return true; n   } else { n    if (q2.type == 1) return false; n    else return q1.i < q2.i; n   } n  }); n   n  // for (int i = 1; i <= m; i++) debug() << name(i) name(q[i].type) name(q[i].i); n   n  fill(ans, ans + N, -2); n  fill(freqL, freqL + N, 1); n  fill(freqR, freqR + N, 1); n  freqR[0] = N; n   n  pair<int, int> qp = {-1, -1}; n  int qAt; n  int L = 1, R = 1; n  for (int i = 1; i <= m && q[i].type == 1; i++) { n   int ql = (q[i].l - 1) / block_size, qr = (q[i].r - 1) / block_size; n   pair<int, int> _qp = {ql, qr}; n   if (qp != _qp) { n    go(L, R, block_size * ql + 1, block_size * ql + 1); n    a = _a; n    qAt = queryCnt + 1; n    qp = _qp; n   } n    n   while (qAt <= m && q[qAt].i < q[i].i) { n    update(qAt, L, R); n    qAt++; n   } n    n   go(L, R, q[i].l, q[i].r + 1); n    n   // debug() << name(q[i].i); n   ans[q[i].i] = answer(q[i].k); n  } n   n  for (int i = 1; i <= m; i++) if (ans[i] >= -1) printf( %d n , ans[i]); n   n  return 0; n }"}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n pair<long long, pair<long long, long long> > stree[4000005]; n char sa[1000005]; n void build(long long node, long long start, long long end) { n   if (start == end) { n     stree[node].first = 0; n     stree[node].second.first = 0; n     stree[node].second.second = 0; n     if (sa[start] ==  ( ) n       stree[node].second.first = 1; n     else if (sa[start] ==  ) ) n       stree[node].second.second = 1; n   } else { n     long long mid = (start + end) / 2; n     build(2 * node, start, mid); n     build(2 * node + 1, mid + 1, end); n     long long com = n         min(stree[2 * node].second.first, stree[2 * node + 1].second.second); n     long long left = n         stree[2 * node].second.first + stree[2 * node + 1].second.first - com; n     long long right = n         stree[2 * node].second.second + stree[2 * node + 1].second.second - com; n     stree[node].first = stree[2 * node].first + stree[2 * node + 1].first + com; n     stree[node].second.first = left; n     stree[node].second.second = right; n   } n } n pair<long long, pair<long long, long long> > query(long long node, n                                                    long long start, n                                                    long long end, long long l, n                                                    long long r) { n   if (l > end || start > r) return make_pair(0, make_pair(0, 0)); n   if (l <= start && r >= end) return stree[node]; n   long long mid = (start + end) / 2; n   pair<long long, pair<long long, long long> > p1 = n       query(2 * node, start, mid, l, r); n   pair<long long, pair<long long, long long> > p2 = n       query(2 * node + 1, mid + 1, end, l, r); n   long long a = min(p1.second.first, p2.second.second); n   long long b = p1.second.first + p2.second.first - a; n   long long c = p1.second.second + p2.second.second - a; n   return make_pair(p1.first + p2.first + a, make_pair(b, c)); n } n int main() { n   string str; n   cin >> str; n   long long n, q; n   n = str.length(); n   cin >> q; n   for (long long i = 1; i <= n; i++) sa[i] = str[i - 1]; n   build(1, 1, n); n   while (q-- != 0) { n     long long x, y; n     cin >> x >> y; n     long long ans = 2 * query(1, 1, n, x, y).first; n     cout << ans << endl; n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int main() { n   string s, t, ss, tt; n   int bc; n   vector<int> res; n   cin >> bc >> s >> t; n   ss = s; n   tt = t; n   sort(ss.begin(), ss.end()); n   sort(tt.begin(), tt.end()); n   if (ss != tt) { n     cout << -1; n     return 0; n   } n   if (!is_permutation(s.begin(), s.end(), t.begin())) return cout << -1, 0; n   for (int i = 0; i < t.size(); ++i) { n     for (int j = i; j < s.size(); ++j) n       if (t[t.size() - i - 1] == s[j]) { n         res.insert(res.end(), {(int)s.size(), j, 1}); n         reverse(s.begin() + j, s.end()); n         rotate(s.begin(), s.begin() + s.size() - 1, s.end()); n         break; n       } n   } n   cout << res.size() <<   n ; n   for (int i = 0; i < res.size(); i++) { n     cout << res[i] <<    ; n   } n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n template <class T> n typename T::value_type arr_sum(const T& v, int n) { n   typename T::value_type sum = 0; n   for (int i = 0; i < n; ++i) sum += v[i]; n   return sum; n } n struct Sync_stdio { n   Sync_stdio() { n     cin.tie(NULL); n     ios_base::sync_with_stdio(false); n   } n } _sync_stdio; n int n, m; n vector<string> w(n); n void print_square(int x1, int x2, int y1, int y2) { n   for (int i = x1; i < x2 + 1; ++i) { n     if (w[i][y1] !=  w ) { n       w[i][y1] =  + ; n     } n     if (w[i][y2] !=  w ) { n       w[i][y2] =  + ; n     } n   } n   for (int i = y1; i < y2 + 1; ++i) { n     if (w[x1][i] !=  w ) { n       w[x1][i] =  + ; n     } n     if (w[x2][i] !=  w ) { n       w[x2][i] =  + ; n     } n   } n   for (auto i : w) { n     cout << i <<   n ; n   } n   exit(0); n } n void check1(vector<pair<int, int> >& v) { n   int max1 = -1, min1 = 100001; n   int max2 = -1, min2 = 100001; n   for (int i = 0; i < v.size(); ++i) { n     max1 = max(max1, v[i].first); n     min1 = min(min1, v[i].first); n     max2 = max(max2, v[i].second); n     min2 = min(min2, v[i].second); n   } n   int left = 0, up = 0, right = 0, down = 0; n   for (int i = 0; i < v.size(); ++i) { n     if (v[i].first == min1 && min2 < v[i].second && v[i].second < max2) { n       up = 1; n     } n     if (v[i].first == max1 && min2 < v[i].second && v[i].second < max2) { n       down = 1; n     } n     if (v[i].second == min2 && min1 < v[i].first && v[i].first < max1) { n       left = 1; n     } n     if (v[i].second == max2 && min1 < v[i].first && v[i].first < max1) { n       right = 1; n     } n     if (min1 < v[i].first && v[i].first < max1 && min2 < v[i].second && n         v[i].second < max2) { n       cout << -1; n       exit(0); n     } n   } n   if (max1 == min1) { n     up = 0; n     down = 0; n   } n   if (min2 == max2) { n     left = 0; n     right = 0; n   } n   if (max1 - min1 == max2 - min2) { n     print_square(min1, max1, min2, max2); n   } n   if (up && down && left && right) { n     cout << -1; n     exit(0); n   } n   int diff = (max1 - min1) - (max2 - min2); n   if (diff > 0) { n     if (!left && max2 + (min1 - max1) >= 0) { n       print_square(min1, max1, max2 + (min1 - max1), max2); n     } n     if (!right && min2 + (max1 - min1) < m) { n       print_square(min1, max1, min2, min2 + (max1 - min1)); n     } n     if (!left && !right && max1 - min1 < m) { n       print_square(min1, max1, 0, max1 - min1); n     } n   } n   if (diff < 0) { n     if (!up && max1 + (min2 - max2) >= 0) { n       print_square(max1 + (min2 - max2), max1, min2, max2); n     } n     if (!down && min1 + (max2 - min2) < n) { n       print_square(min1, min1 + (max2 - min2), min2, max2); n     } n     if (!up && !down && max2 - min2 < n) { n       print_square(0, max2 - min2, min2, max2); n     } n   } n   cout << -1; n   exit(0); n } n int main() { n   cin >> n >> m; n   vector<pair<int, int> > v; n   for (int i = 0; i < n; ++i) { n     string t; n     cin >> t; n     w.push_back(t); n     for (int j = 0; j < m; ++j) { n       if (t[j] ==  w ) { n         v.push_back({i, j}); n       } n     } n   } n   check1(v); n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n using ll = long long; n int main() { n   ios_base::sync_with_stdio(false); n   cin.tie(0); n   int q; n   cin >> q; n   while (q--) { n     ll a, b, m; n     cin >> a >> b >> m; n     if (a == b) { n       cout << 1 <<     << a <<   n ; n       continue; n     } n     bool f = false; n     for (int k = 1; k <= 49 && (1ll << (k - 1)) <= b / a; k++) { n       ll t = (1ll << (k - 1)) * a; n       ll b_tmp = b - t; n       vector<ll> rs(k + 1); n       rs[0] = a; n       for (int cur = 1; cur <= k; cur++) { n         ll pw = (cur == k) ? 1 : (1ll << (k - cur - 1)); n         rs[cur] = 1; n         b_tmp -= pw * rs[cur]; n       } n       if (b_tmp < 0) { n         continue; n       } n       for (int cur = 1; cur <= k; cur++) { n         ll pw = (cur == k) ? 1 : (1ll << (k - cur - 1)); n         ll now = min(m - 1, b_tmp / pw); n         b_tmp -= pw * now; n         rs[cur] += now; n       } n       if (b_tmp == 0) { n         f = true; n         cout << k + 1 <<    ; n         vector<ll> ans; n         for (int i = 0; i <= k; i++) { n           ll cur = rs[i]; n           for (int j = i - 1; j >= 0; j--) { n             cur += ans[j]; n           } n           ans.push_back(cur); n           cout << cur <<    ; n         } n         cout <<   n ; n         break; n       } n     } n     if (!f) cout << -1 <<   n ; n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n bool check(string s) { n   string t = s; n   reverse(t.begin(), t.end()); n   return (s == t); n } n int main() { n   string s; n   cin >> s; n   int l = 0, r = ((int)s.length()) - 1; n   set<char> all; n   while (l < r) { n     all.insert(s[l]); n     all.insert(s[r]); n     l++; n     r--; n   } n   if (all.size() <= 1) { n     cout <<  Impossible  << endl; n     return 0; n   } n   for (int i = 0; i < ((int)s.length()) - 1; i++) { n     string fi =   , se =   ; n     for (int j = 0; j <= i; j++) fi += s[j]; n     for (int j = i + 1; j < (int)s.length(); j++) se += s[j]; n     if (check(se + fi) && (se + fi != s)) { n       cout << 1 << endl; n       return 0; n     } n   } n   cout << 2 << endl; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n template <class T> n inline T MAX(T a, T b) { n   if (a > b) return a; n   return b; n } n template <class T> n inline T MIN(T a, T b) { n   if (a < b) return a; n   return b; n } n template <class T> n inline T ABS(T x) { n   if (x < 0) return -x; n   return x; n } n inline void OPEN(const string &s) { n   freopen((s +  .in ).c_str(),  r , stdin); n   freopen((s +  .out ).c_str(),  w , stdout); n } n const static int inf = 1000000000; n int n, m, x, y, z, p; n int a, b; n vector<pair<int, int> > cek; n void rotate90(int &a, int &b, int &r, int &c) { n   int tempa = a; n   int tempb = b; n   a = tempb; n   b = r - tempa + 1; n   swap(r, c); n } n void flipH(int &a, int &b, int &r, int &c) { b = c - b + 1; } n void rotate(int &a, int &b, int &r, int &c) { n   int tempa = a; n   int tempb = b; n   a = c - tempb + 1; n   b = tempa; n   swap(r, c); n } n int main() { n   scanf( %d%d%d%d%d%d , &n, &m, &x, &y, &z, &p); n   for (int(i) = (0); (i) < (p); ++(i)) { n     scanf( %d%d , &a, &b); n     cek.push_back(make_pair(a, b)); n   } n   x %= 4; n   z %= 4; n   y %= 2; n   for (int(i) = (0); (i) < (cek.size()); ++(i)) { n     a = cek[i].first; n     b = cek[i].second; n     int r = n, c = m; n     for (int(j) = (0); (j) < (x); ++(j)) rotate90(a, b, r, c); n     for (int(j) = (0); (j) < (y); ++(j)) flipH(a, b, r, c); n     for (int(j) = (0); (j) < (z); ++(j)) rotate(a, b, r, c); n     printf( %d %d n , a, b); n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int dx[] = {0, -1, 0, 1, -1, -1, 1, 1}; n const int dy[] = {1, 0, -1, 0, 1, -1, 1, -1}; n int n, pre = 0; n int a[1005], b[1005], p[1005]; n vector<int> num; n bool vis[1005]; n bool valid() { n   int na = 0; n   set<int> st; n   for (int j = 0; j < n; ++j) { n     if (a[j] == p[j]) ++na; n     st.insert(p[j]); n   } n   return ((st.size()) == n && na == n - 1); n } n int main() { n   int v; n   scanf( %d , &n); n   for (int i = 0; i < n; ++i) scanf( %d , &a[i]); n   for (int i = 0; i < n; ++i) { n     scanf( %d , &b[i]); n     p[i] = b[i]; n     if (vis[p[i]]) v = p[i]; n     vis[p[i]] = 1; n   } n   vis[v] = 0; n   for (int i = 0; i < n; ++i) n     if (b[i] == v) num.push_back(i); n   int tmp1 = p[num[0]], tmp2 = p[num[1]]; n   for (int j = 1; j <= n; ++j) { n     if (!vis[j]) { n       vis[j] = 1; n       p[num[0]] = j; n       for (int k = 1; k <= n; ++k) { n         if (!vis[k]) { n           vis[k] = 1; n           p[num[1]] = k; n           break; n         } n       } n       if (valid()) n         break; n       else { n         vis[p[num[0]]] = vis[p[num[1]]] = 0; n         p[num[0]] = tmp1; n         p[num[1]] = tmp2; n       } n     } n   } n   for (int i = 0; i < n; ++i) printf( %d  , p[i]); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int main() { n   int n; n   cin >> n; n   string s; n   cin >> s; n   if (n % 2 == 0) { n     for (int i = 0; i < n - 2; i++) { n       cout << s[i]; n       if (i % 2) { n         cout <<  - ; n       } n     } n     cout << s[n - 2] << s[n - 1]; n   } n   if (n % 2) { n     for (int i = 0; i < n - 3; i++) { n       cout << s[i]; n       if (i % 2) { n         cout <<  - ; n       } n     } n     cout << s[n - 3] << s[n - 2] << s[n - 1]; n   } n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n int C[100005], D[505][505], L[100005], R[100005], Par[100005]; n int N, K, M; n using namespace std; n int find(int n) { n   if (Par[n] == n) n     return n; n   else n     return Par[n] = find(Par[n]); n } n void join(int a, int b) { Par[find(a)] = find(b); } n int main() { n   cin >> N >> M >> K; n   for (int i = 1; i <= K; i++) { n     int x; n     cin >> x; n     L[i] = R[i - 1] + 1; n     R[i] = L[i] + x - 1; n     for (int p = L[i]; p <= R[i]; p++) C[p] = i; n   } n   for (int i = 1; i <= N; i++) Par[i] = i; n   for (int i = 1; i <= K; i++) { n     for (int j = 1; j <= K; j++) D[i][j] = 1000000005; n     D[i][i] = 0; n   } n   while (M--) { n     int a, b, d; n     cin >> a >> b >> d; n     if (d == 0) join(a, b); n     D[C[a]][C[b]] = min(D[C[a]][C[b]], d); n     D[C[b]][C[a]] = min(D[C[b]][C[a]], d); n   } n   for (int i = 1; i <= K; i++) n     for (int p = L[i]; p <= R[i]; p++) n       if (find(p) != find(L[i])) { n         cout <<  No ; n         return 0; n       } n   for (int k = 1; k <= K; k++) n     for (int i = 1; i <= K; i++) n       for (int j = 1; j <= K; j++) D[i][j] = min(D[i][j], D[i][k] + D[k][j]); n   cout <<  Yes n ; n   for (int i = 1; i <= K; i++) { n     for (int j = 1; j <= K; j++) { n       if (D[i][j] < 1000000005) n         cout << D[i][j] <<    ; n       else n         cout <<  -1  ; n     } n     cout <<   n ; n   } n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int n, m; n vector<int> g[100001], vc; n int judge(int x) { n   vc.clear(); n   int need = x - g[0].size(), ans = 0; n   for (int i = 1; i < 100001; i++) { n     for (int j = 0; j < g[i].size(); j++) { n       if (g[i].size() - j >= x) { n         need--; n         ans += g[i][j]; n       } else n         vc.push_back(g[i][j]); n     } n   } n   sort(vc.begin(), vc.end()); n   for (int i = 0; i < need; i++) ans += vc[i]; n   return ans; n } n int main() { n   scanf( %d , &n); n   int a, b; n   for (int i = 0; i < n; i++) { n     scanf( %d%d , &a, &b); n     g[a].push_back(b); n   } n   for (int i = 1; i < 100001; i++) { n     sort(g[i].begin(), g[i].end()); n   } n   int l = g[0].size(), r = n; n   while (l < r) { n     int mid = (l + l + r) / 3, mmid = (l + r + r) / 3; n     if (judge(mid) > judge(mmid)) { n       if (l == mid) n         break; n       else n         l = mid; n     } else { n       if (r == mmid) n         break; n       else n         r = mmid; n     } n   } n   int ans = 0x3f3f3f3f; n   for (int i = l; i <= r; i++) ans = min(ans, judge(i)); n   printf( %d n , ans); n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int main() { n   int n, x, y, z; n   int sum1 = 0, sum2 = 0, sum3 = 0; n   cin >> n; n   for (int i = 0; i < n; i++) { n     cin >> x >> y >> z; n     sum1 += x; n     sum2 += y; n     sum3 += z; n   } n   if ((sum1 == 0) && (sum2 == 0) && (sum3 == 0)) { n     cout <<  YES  << endl; n   } else { n     cout <<  NO  << endl; n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int i, j, n; n void solve() { n   int n; n   long long l; n   cin >> n >> l; n   long long a[n]; n   for (i = 0; i < n; i++) cin >> a[i]; n   ; n   sort(a, a + n); n   long long m = 2 * max(a[0], l - a[n - 1]); n   for (i = 0; i < n - 1; i++) { n     m = max(m, a[i + 1] - a[i]); n   } n   long double d = 1.0 * m / 2; n   cout << setprecision(9) << d; n } n int main() { n   solve(); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int maxn = 100005; n const int maxd = 205; n struct Node { n   int l, d; n } leg[maxn]; n bool operator<(const Node &a, const Node &b) { return a.l > b.l; } n int n, tot[maxd], td = 0, md = 0; n int Solve(int st, int ed) { n   int cnt = ed - st; n   int res = td; n   for (int i = md; i >= 0 && cnt > 0; i--) { n     res -= min(cnt, tot[i]) * i; n     cnt -= min(cnt, tot[i]); n   } n   return res; n } n int main() { n   cin >> n; n   for (int i = 0; i < n; i++) cin >> leg[i].l; n   for (int i = 0; i < n; i++) cin >> leg[i].d; n   for (int i = 0; i < n; i++) md = max(md, leg[i].d); n   sort(leg, leg + n); n   for (int i = 0; i < n; i++) { n     tot[leg[i].d]++; n     td += leg[i].d; n   } n   int p = 0; n   int res = INT_MAX, tot_d = 0; n   while (p < n) { n     int p1 = p + 1; n     while (p1 < n && leg[p1].l == leg[p].l) p1++; n     p1--; n     for (int i = p; i <= p1; i++) { n       tot[leg[i].d]--; n       td -= leg[i].d; n     } n     int tmp = tot_d + Solve(p, p1); n     res = min(tmp, res); n     for (int i = p; i <= p1; i++) tot_d += leg[i].d; n     p = p1 + 1; n   } n   cout << res << endl; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n inline long long read() { n   register long long x = 0, f = 1; n   char ch = getchar(); n   while (!isdigit(ch)) { n     if (ch ==  - ) f = -1; n     ch = getchar(); n   } n   while (isdigit(ch)) { n     x = (x << 1) + (x << 3) + (ch ^ 48); n     ch = getchar(); n   } n   return x * f; n } n const long long N = 1e5 + 10; n long long n, m, k, p; n long long h[N], a[N]; n long long c[N]; n struct node { n   long long t, id; n   bool operator<(const node& x) const { return t > x.t; } n }; n priority_queue<node> q; n bool check(long long x) { n   while (!q.empty()) q.pop(); n   memset(c, 0, sizeof c); n   for (long long i = 1; i <= n; i++) n     if (x - a[i] * m < h[i]) q.push((node){x / a[i], i}); n   for (long long i = 1; !q.empty() && i <= m; i++) n     for (long long j = 1; !q.empty() && j <= k; j++) { n       node u = q.top(); n       q.pop(); n       if (u.t < i) return 0; n       ++c[u.id]; n       if (x + c[u.id] * p - a[u.id] * m < h[u.id]) n         q.push((node){(x + c[u.id] * p) / a[u.id], u.id}); n     } n   return q.empty(); n } n signed main() { n   n = read(), m = read(), k = read(), p = read(); n   for (long long i = 1; i <= n; i++) h[i] = read(), a[i] = read(); n   long long l = 0, r = 1e15, ans; n   while (l <= r) { n     long long mid = l + r >> 1; n     if (check(mid)) n       ans = mid, r = mid - 1; n     else n       l = mid + 1; n   } n   cout << ans; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n struct data { n   int idx, val; n   bool operator<(const data &a1) const { n     if (a1.val == val) { n       return a1.idx < idx; n     } n     return val > a1.val; n   } n   data(int t, int w) : idx(t), val(w) {} n }; n set<data> coastline; n set<data>::iterator it, it2; n int main() { n   int N; n   scanf( %d , &N); n   string ans[N]; n   int a; n   for (int i = 0; i < N; i++) { n     scanf( %d , &a); n     if (a == 0) { n       int sz = coastline.size(); n       if (sz == 0) { n         ans[i] =  0 ; n       } else if (sz == 1) { n         ans[i] =  1 popStack ; n         it = coastline.begin(); n         ans[it->idx] =  pushStack ; n       } else if (sz == 2) { n         ans[i] =  2 popStack popQueue ; n         it = coastline.begin(); n         ans[it->idx] =  pushQueue ; n         it++; n         ans[it->idx] =  pushStack ; n         it++; n       } else { n         ans[i] =  3 popStack popQueue popFront ; n         it = coastline.begin(); n         ans[it->idx] =  pushFront ; n         it++; n         ans[it->idx] =  pushQueue ; n         it++; n         ans[it->idx] =  pushStack ; n         it++; n       } n       coastline.clear(); n     } else { n       coastline.insert(data(i, a)); n     } n   } n   for (int i = 0; i < N; i++) { n     if (ans[i].size() == 0) { n       cout <<  pushBack  << endl; n     } else n       cout << ans[i] << endl; n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n #define ll long long n #define mod 1000000007 n using namespace std; n  n ll dp[10][200001]; n string s =  abcdefghijklmnopqrstuvwxyz ; n ll findgcd(ll a, ll b) { n     if (b == 0) { n         return a; n     } n     return findgcd(b, a % b); n } n  n bool ispalindrome(string s) { n     int n = s.length(); n     bool flag = true; n     for (int i = 0; i < n / 2; i++) { n         if (s[i] != s[n - 1 - i]) { n             flag = false; n             break; n         } n     } n     return flag; n } n  n ll factorial(ll n) { n     vector<ll> v(n + 1); n     for (ll i = 0; i <= n; i++) { n         if (i == 0 || i == 1) { n             v[i] = 1; n         } n         else { n             v[i] = (i * v[i - 1]) % mod; n         } n     } n     return v[n]; n } n  n void calculatedp() { n     for (ll i = 0; i <= 9; i++) { n         ll temp = 10 - i; n         for (ll j = 0; j <= 200000; j++) { n             if (j < temp) { n                 dp[i][j] = 1; n             } n             else if (j == temp) { n                 dp[i][j] = 2; n             } n             else { n                 break; n             } n         } n     } n     dp[1][10] = 2; n     for (ll i = 11; i <= 200000; i++) { n         int temp1 = i - 10; n         int temp2 = i - 9; n         dp[0][i] = (dp[0][temp1] + dp[1][temp1]) % mod; n         dp[1][i] = (dp[0][temp2] + dp[1][temp2]) % mod; n     } n     for (ll i = 2; i <= 9; i++) { n         ll temp = 10 - i; n         for (ll j = temp + 1; j <= 200000; j++) { n             dp[i][j] = (dp[0][j - temp] + dp[1][j - temp]) % mod; n         } n     } n } n  n void solve() { n     // ll m; n     // cin >> s; n     // cin >> m; n     // ll ans = 0; n     // for (int i = 0; i < s.length(); i++) { n     //     ans = (ans + (dp[s[i] -  0 ][m])) % mod; n     // } n     // cout << ans <<   n ; n     int n, k; n     cin >> n >> k; n  n     string ans =   ; n  n     for (int i = 0 ; i < k ; i++) { n         ans += s[i]; n         for (int j = i + 1 ; j < k ; j++) { n             ans += s[i]; n             ans += s[j]; n         } n     } n  n     if (n < ans.size()) { n         cout << ans.substr(0, n) << endl; n     } n     else { n         int j = ans.length(); n         int i = 0; n         while (j < n) { n             ans += ans[i]; n             i++; n             j++; n         } n  n         cout << ans << endl; n     } n } n int main() { n #ifndef ONLINE_JUDGE n     //for getting input from input.txt n     freopen( input.txt ,  r , stdin); n     //for writing output to output.txt n     freopen( output.txt ,  w , stdout); n #endif n     ios_base::sync_with_stdio(0); n     cin.tie(0); n     cout.tie(0); n     // calculatedp(); n     // for (int i = 0; i <= 10; i++) { n     //     for (int j = 0; j <= 10; j++) { n     //         cout << dp[i][j] <<    ; n     //     } n     //     cout <<   n ; n     // } n     int t; n     t = 1; n     // cin >> t; n     while (t--) { n         solve(); n     } n }"}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n template <typename T> n inline int popcount(T t) { n   if (std::numeric_limits<T>::digits <= n       std::numeric_limits<unsigned int>::digits) { n     return __builtin_popcount(t); n   } else { n     return __builtin_popcountll(t); n   } n } n const long double EPS = 1e-8; n const long double PI = acosl(0.0) * 2; n void solve() { n   int n; n   cin >> n; n   vector<int> a(n); n   for (int i = 0; i < int(n); ++i) cin >> a[i]; n   for (int i = 30; i >= 0; --i) { n     vector<int> b; n     int mask = (1 << i) - 1; n     for (int x : a) { n       if ((x >> i) & 1) { n         b.push_back(x); n         mask &= x; n       } n     } n     if (!mask) { n       cout << b.size() << endl; n       for (int x : b) { n         cout << x <<    ; n       } n       cout << endl; n       return; n     } n   } n   assert(false); n } n int main() { n   ios_base::sync_with_stdio(false); n   solve(); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int main() { n   int n1, n2, n3, n4; n   long long ans; n   unordered_map<char, int> m; n   string s; n   while (cin >> n1 >> n2 >> n3 >> n4) { n     ans = 0; n     m[ 1 ] = n1; n     m[ 2 ] = n2; n     m[ 3 ] = n3; n     m[ 4 ] = n4; n     cin >> s; n     for (int i = 0; i < s.size(); i++) { n       ans += m[s[i]]; n     } n     cout << ans << endl; n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n bool cmp(double a, double b) { return a > b; } n int n; n double a[110], x, sum, ans; n int main() { n   scanf( %d , &n); n   for (int i = 0; i < n; i++) scanf( %lf , &a[i]); n   sort(a, a + n, cmp); n   ans = 0; n   for (int i = 1; i <= n; i++) { n     sum = 0; n     for (int j = 0; j < i; j++) { n       x = a[j]; n       for (int k = 0; k < i; k++) { n         if (j != k) x *= 1 - a[k]; n       } n       sum += x; n     } n     ans = max(sum, ans); n   } n   printf( %.12lf n , ans); n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n long long int a[200][3]; n int main() { n   ios ::sync_with_stdio(false); n   cin.tie(0); n   ; n   long long int i, k, l, n, j; n   cin >> n; n   for (i = 0; i <= n - 1; i++) cin >> a[i][0] >> a[i][1]; n   cin >> j; n   for (i = 0; i <= n - 1; i++) n     if (j >= a[i][0] && j <= a[i][1]) { n       cout << n - i << endl; n       return 0; n     } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int N, K; n string S; n int vis[5050][5050]; n vector<pair<int, int>> nex[26]; n void dfs(int cur, int mask) { n   if (vis[cur][mask] || cur + 1 + mask > N) return; n   vis[cur][mask] = 1; n   int i; n   nex[S[cur] -  a ].push_back({cur + 1, mask}); n   for (i = 0; i < (K); i++) n     if (mask & (1 << i)) dfs(cur + (1 << i), mask ^ (1 << i)); n } n void solve() { n   int i, j, k, l, r, x, y; n   string s; n   cin >> S; n   N = S.size(); n   while (1 << (K + 1) <= N) K++; n   vector<pair<int, int>> now; n   now.push_back({0, (1 << K) - 1}); n   while (now.size()) { n     for (i = 0; i < (26); i++) nex[i].clear(); n     for (auto& n : now) dfs(n.first, n.second); n     char c =  z  + 1; n     for (i = 25; i >= 0; i--) n       if (nex[i].size()) c =  a  + i; n     if (c ==  z  + 1) break; n     cout << c; n     swap(now, nex[c -  a ]); n   } n   cout << endl; n } n int main(int argc, char** argv) { n   string s; n   int i; n   if (argc == 1) ios::sync_with_stdio(false), cin.tie(0); n   for (i = 0; i < (argc - 1); i++) s += argv[i + 1], s +=   n ; n   for (i = 0; i < (s.size()); i++) ungetc(s[s.size() - 1 - i], stdin); n   cout.tie(0); n   solve(); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n pair<double, double> get_vec_rotate(pair<double, double> nv, double fi) { n   return make_pair(nv.first * cos(fi) - nv.second * sin(fi), n                    nv.second * cos(fi) + nv.first * sin(fi)); n } n pair<double, double> get_normal(pair<double, double> vec) { n   double len = sqrt(vec.first * vec.first + vec.second * vec.second); n   vec.first /= len; n   vec.second /= len; n   return vec; n } n pair<double, double> end_p(pair<double, double> start_p, n                            pair<double, double> nv, double len) { n   nv.first *= len; n   nv.second *= len; n   return make_pair(nv.first + start_p.first, nv.second + start_p.second); n } n double a, b, c, d; n pair<double, double> p, v, ToWrite; n pair<double, double> len_fi[7]; n int main() { n   cin >> p.first >> p.second >> v.first >> v.second >> a >> b >> c >> d; n   v = get_normal(v); n   len_fi[0].first = b; n   len_fi[0].second = 0; n   len_fi[1].first = a / 2; n   len_fi[1].second = M_PI / 2; n   len_fi[2].first = c / 2; n   len_fi[2].second = M_PI / 2; n   len_fi[3].first = sqrt(c * c + 4 * d * d) / 2; n   len_fi[3].second = M_PI / 2 + atan(2 * d / c); n   len_fi[4].first = sqrt(c * c + 4 * d * d) / 2; n   len_fi[4].second = 3 * M_PI / 2 - atan(2 * d / c); n   len_fi[5].first = c / 2; n   len_fi[5].second = 3 * M_PI / 2; n   len_fi[6].first = a / 2; n   len_fi[6].second = 3 * M_PI / 2; n   cout.precision(10); n   for (int i = 0; i < 7; i++) { n     ToWrite = end_p(p, get_vec_rotate(v, len_fi[i].second), len_fi[i].first); n     cout << fixed << ToWrite.first <<     << ToWrite.second << endl; n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n int T; n int n, m; n bool get() { n   char ch = getchar(); n   while (ch !=  O  && ch !=  X ) ch = getchar(); n   return (ch ==  X ); n } n int map[21][21], con[4001][2], top, cnt[4001], head[401], nxt[100001], n     b[100001], k = 1, dis[4001], pre[4001]; n char ans[41][41]; n int q[4001], h, t; n void push(int s, int t) { n   nxt[++k] = head[s]; n   head[s] = k; n   b[k] = t; n } n bool iscut[4001], chosen[4001], lim[4001], good[4001][4001]; n std::vector<int> vec[4001]; n int Cnt; n int hash(int i, int j) { return (i - 1) * m + j; } n void dfs(int x, bool *vis) { n   if (vis[x]) return; n   ++Cnt; n   vis[x] = 1; n   for (int i = head[x]; i; i = nxt[i]) n     if (!chosen[i >> 1]) dfs(b[i], vis); n } n int main() { n   scanf( %d , &T); n   for (int fd = 1; fd <= T; fd++) { n     scanf( %d%d , &n, &m); n     int all = 0; n     top = 0; n     memset(chosen, 0, sizeof chosen); n     memset(lim, 0, sizeof lim); n     memset(head, 0, sizeof head); n     k = 1; n     for (int i = 1; i <= n; i++) n       for (int j = 1; j <= m; j++) map[i][j] = get(), all += (!map[i][j]); n     for (int i = 1; i < n; i++) n       for (int j = 1; j <= m; j++) n         if (!map[i][j] && !map[i + 1][j]) { n           ++top; n           con[top][0] = hash(i, j); n           con[top][1] = hash(i + 1, j); n           push(hash(i, j), hash(i + 1, j)); n           push(hash(i + 1, j), hash(i, j)); n         } n     for (int i = 1; i <= n; i++) n       for (int j = 1; j < m; j++) n         if (!map[i][j] && !map[i][j + 1]) { n           ++top; n           con[top][0] = hash(i, j); n           con[top][1] = hash(i, j + 1); n           push(hash(i, j), hash(i, j + 1)); n           push(hash(i, j + 1), hash(i, j)); n         } n     for (int i = 1; i <= n; i++) n       for (int j = 1; j <= m; j++) n         if ((i + j) % 2 == 0 && (i > 1 || j > 1)) lim[hash(i, j)] = 1; n     memset(cnt, 0, sizeof cnt); n     for (int i = 1; i <= top; i++) { n       ++cnt[con[i][0]], ++cnt[con[i][1]]; n     } n     bool cando = 1; n     for (int i = 1; i <= n; i++) n       for (int j = 1; j <= m; j++) n         if (lim[hash(i, j)] && cnt[hash(i, j)] <= 1 && !map[i][j]) { n           cando = 0; n         } n     memset(good[0], 0, sizeof good[0]); n     Cnt = 0; n     dfs(1, good[0]); n     if (Cnt < all) cando = 0; n     if (!cando) n       puts( NO ); n     else { n       for (;;) { n         memset(cnt, 0, sizeof cnt); n         for (int i = 1; i <= top; i++) n           if (!chosen[i]) { n             if (lim[con[i][0]]) n               ++cnt[con[i][0]]; n             else n               ++cnt[con[i][1]]; n             Cnt = 0; n             chosen[i] = 1; n             memset(good[i], 0, sizeof good[i]); n             dfs(1, good[i]); n             iscut[i] = (Cnt < all); n             chosen[i] = 0; n           } n         for (int i = 1; i <= top; i++) vec[i].clear(); n         for (int i = 1; i <= top; i++) n           if (chosen[i]) n             for (int j = 1; j <= top; j++) n               if (!chosen[j]) { n                 int u = (lim[con[i][0]] ? con[i][0] : con[i][1]), n                     v = (lim[con[j][0]] ? con[j][0] : con[j][1]); n                 if (u == v || cnt[v] >= 3) { n                   vec[j].push_back(i); n                 } n                 if (!iscut[j] || good[j][con[i][0]] != good[j][con[i][1]]) { n                   vec[i].push_back(j); n                 } n               } n         h = t = 0; n         for (int i = 1; i <= top; i++) { n           dis[i] = 0x7f7f7f7f; n           pre[i] = 0; n           if (!chosen[i] && !iscut[i]) dis[i] = 0, q[++t] = i; n         } n         while (h < t) { n           ++h; n           for (int i = 0; i < vec[q[h]].size(); i++) n             if (dis[vec[q[h]][i]] == 0x7f7f7f7f) { n               dis[vec[q[h]][i]] = dis[q[h]] + 1; n               q[++t] = vec[q[h]][i]; n               pre[vec[q[h]][i]] = q[h]; n             } n         } n         int p = 0; n         for (int i = 1; i <= top; i++) { n           if (!chosen[i] && (cnt[con[i][0]] >= 3 || !lim[con[i][0]]) && n               (cnt[con[i][1]] >= 3 || !lim[con[i][1]]) && n               dis[i] != 0x7f7f7f7f) { n             if (!p || dis[p] > dis[i]) p = i; n           } n         } n         if (!p) break; n         while (p) { n           chosen[p] ^= 1; n           p = pre[p]; n         } n       } n       Cnt = 0; n       for (int i = 1; i <= top; i++) Cnt += (!chosen[i]); n       if (Cnt != all - 1) n         puts( NO ); n       else { n         puts( YES ); n         for (int i = 1; i <= (n << 1); i++) n           for (int j = 1; j <= (m << 1); j++) ans[i][j] =    ; n         for (int i = 1; i <= n; i++) n           for (int j = 1; j <= m; j++) n             ans[(i << 1) - 1][(j << 1) - 1] = (map[i][j]) ?  X  :  O ; n         for (int i = 1; i <= top; i++) n           if (!chosen[i]) { n             int u = con[i][0], v = con[i][1]; n             if (v == u + 1) n               ans[(((u - 1) / m + 1) << 1) - 1][((u - 1) % m + 1) << 1] =  O ; n             else n               ans[(((u - 1) / m + 1) << 1)][(((u - 1) % m + 1) << 1) - 1] =  O ; n           } n         for (int i = 1; i < (n << 1); i++, putchar(  n )) n           for (int j = 1; j < (m << 1); j++) putchar(ans[i][j]); n       } n     } n   } n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n struct node { n   int active; n   set<int> prev, next; n   node() : active(1) {} n }; n int main() { n   int n, k, m, i, j; n   int a, b; n   cin >> n >> m; n   int cnt = 1; n   set<int> sh; n   set<int>::iterator it; n   for (i = 0; i < n; i++) sh.insert(i); n   node* graf = new node[n]; n   for (i = 0; i < m; i++) { n     cin >> a >> b; n     a--, b--; n     if (graf[a].active == 0) continue; n     if (graf[b].prev.size() == 0) sh.erase(b); n     graf[a].next.insert(b); n     graf[b].prev.insert(a); n     while (sh.size() == 1) { n       k = *sh.begin(); n       cnt++; n       if (cnt == n) { n         cout << i + 1 << endl; n         return 0; n       } n       for (it = graf[k].next.begin(); it != graf[k].next.end(); it++) { n         j = *it; n         graf[j].prev.erase(k); n         if (graf[j].prev.size() == 0) sh.insert(j); n       } n       sh.erase(k); n       graf[k].active = 0; n     } n   } n   cout << -1 << endl; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const long long maxn = 2e5 + 7; n struct Node { n   long long x, y; n } node[maxn]; n bool cmp(Node a, Node b) { return a.x < b.x; } n long long n, k; n long long len[maxn]; n int32_t main() { n   ios::sync_with_stdio(0); n   cin.tie(0); n   cout.tie(0); n   ; n   int t; n   cin >> t; n   while (t--) { n     cin >> n >> k; n     for (int i = 0; i < n; i++) cin >> node[i].x; n     for (int i = 0; i < n; i++) cin >> node[i].y; n     sort(node, node + n, cmp); n     long long tarl, tarr; n     for (tarr = tarl = 0; tarr < n; tarr++) { n       while (node[tarl].x < node[tarr].x - k) tarl++; n       len[tarr] = tarr - tarl + 1; n     } n     long long ans = 0, Max = 0; n     for (tarr = tarl = 0; tarr < n; tarr++) { n       while (node[tarl].x < node[tarr].x - k) { n         Max = max(Max, len[tarl]); n         tarl++; n       } n       ans = max(Max + len[tarr], ans); n     } n     cout << ans << endl; n     for (int i = 0; i < n; i++) len[i] = 0; n   } n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n #pragma GCC target( avx2 ) n #pragma GCC optimization( unroll-loops ) n #pragma GCC optimize( O2 ) n constexpr int dx[] = {-1, 0, 1, 0, 1, 1, -1, -1}; n constexpr int dy[] = {0, -1, 0, 1, 1, -1, 1, -1}; n constexpr long long INF = 1999999999999999997; n constexpr int inf = INT_MAX; n constexpr int MAXSIZE = int(1e6) + 5; n constexpr auto PI = 3.14159265358979323846L; n constexpr auto oo = numeric_limits<int>::max() / 2 - 2; n constexpr auto eps = 1e-6; n constexpr auto mod = 1000000007; n constexpr auto MOD = 1000000007; n constexpr auto MOD9 = 1000000009; n constexpr auto maxn = 100006; n template <typename T, size_t N> n int SIZE(const T (&t)[N]) { n   return N; n } n template <typename T> n int SIZE(const T &t) { n   return t.size(); n } n string to_string(string s, int x1 = 0, int x2 = 1e9) { n   return     + ((x1 < s.size()) ? s.substr(x1, x2 - x1 + 1) :   ) +    ; n } n string to_string(const char *s) { return to_string((string)s); } n string to_string(bool b) { return (b ?  true  :  false ); } n string to_string(char c) { return string({c}); } n template <size_t N> n string to_string(bitset<N> &b, int x1 = 0, int x2 = 1e9) { n   string t =   ; n   for (int __iii__ = min(x1, SIZE(b)), __jjj__ = min(x2, SIZE(b) - 1); n        __iii__ <= __jjj__; ++__iii__) { n     t += b[__iii__] +  0 ; n   } n   return     + t +    ; n } n template <typename A, typename... C> n string to_string(A(&v), int x1 = 0, int x2 = 1e9, C... coords); n int l_v_l_v_l = 0, t_a_b_s = 0; n template <typename A, typename B> n string to_string(pair<A, B> &p) { n   l_v_l_v_l++; n   string res =  (  + to_string(p.first) +  ,   + to_string(p.second) +  ) ; n   l_v_l_v_l--; n   return res; n } n template <typename A, typename... C> n string to_string(A(&v), int x1, int x2, C... coords) { n   int rnk = rank<A>::value; n   string tab(t_a_b_s,    ); n   string res =   ; n   bool first = true; n   if (l_v_l_v_l == 0) res +=   n ; n   res += tab +  [ ; n   x1 = min(x1, SIZE(v)), x2 = min(x2, SIZE(v)); n   auto l = begin(v); n   advance(l, x1); n   auto r = l; n   advance(r, (x2 - x1) + (x2 < SIZE(v))); n   for (auto e = l; e != r; e = next(e)) { n     if (!first) { n       res +=  ,  ; n     } n     first = false; n     l_v_l_v_l++; n     if (e != l) { n       if (rnk > 1) { n         res +=   n ; n         t_a_b_s = l_v_l_v_l; n       }; n     } else { n       t_a_b_s = 0; n     } n     res += to_string(*e, coords...); n     l_v_l_v_l--; n   } n   res +=  ] ; n   if (l_v_l_v_l == 0) res +=   n ; n   return res; n } n void dbgs() { ; } n template <typename Heads, typename... Tails> n void dbgs(Heads H, Tails... T) { n   cout << to_string(H) <<   |  ; n   dbgs(T...); n } n int main() { n   int n, d; n   cin >> n >> d; n   int m; n   cin >> m; n   while (m--) { n     int x, y; n     cin >> x >> y; n     if (x + y - d >= 0 && y + x - 2 * n + d <= 0 && y - x - d <= 0 && n         x - y - d <= 0) n       cout <<  YES  n            <<   n ; n     else { n       cout <<  NO  n            <<   n ; n     } n   } n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int mxN = 2e5 + 10; n vector<int> a[mxN]; n int main() { n   int n, k; n   cin >> n >> k; n   for (int i = 0; i < n; i++) { n     int cnt = 0, x; n     cin >> x; n     while (true) { n       a[x].push_back(cnt); n       if (!x) break; n       x >>= 1; n       cnt++; n     } n   } n   int ans = 1e9; n   for (int i = 0; i < mxN; i++) { n     if (a[i].size() >= k) { n       sort(a[i].begin(), a[i].end()); n       int cnt = 0; n       for (int j = 0; j < k; j++) cnt += a[i][j]; n       ans = min(ans, cnt); n     } n   } n   cout << ans << endl; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const long long inf = 1LL << 28; n const long long mod = 1LL; n vector<int> adj[30]; n long long b_search(int val, int indx) { n   int lo, hi, mid; n   long long ans = 1e12; n   lo = 0; n   hi = (int)adj[indx].size() - 1; n   while (lo <= hi) { n     mid = (lo + hi) / 2; n     if (adj[indx][mid] == val) return 0; n     if (adj[indx][mid] < val) n       lo = mid + 1; n     else n       hi = mid - 1; n     ans = min(ans, (long long)abs(val - adj[indx][mid])); n   } n   return ans; n } n int main() { n   int n, k, i, j; n   long long l; n   string s, c; n   while (scanf( %d %d , &n, &k) == 2) { n     for (i = 0; i < 26; i++) adj[i].clear(); n     cin >> s; n     for (i = 0; i < s.length(); i++) { n       adj[s[i] -  a ].push_back(i); n     } n     while (n--) { n       l = 0; n       cin >> c; n       for (i = 0; i < c.length(); i++) { n         if ((int)adj[c[i] -  a ].size() == 0) n           l += (int)c.size(); n         else n           l += b_search(i, c[i] -  a ); n       } n       printf( %I64d n , l); n     } n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n template <class T> n bool umin(T& a, T b) { n   if (a > b) { n     a = b; n     return 1; n   } n   return 0; n } n template <class T> n bool umax(T& a, T b) { n   if (a < b) { n     a = b; n     return 1; n   } n   return 0; n } n long long dp[200009][2], a, par[200009]; n priority_queue<long long> bg; n priority_queue<long long, vector<long long>, greater<long long> > sm; n void upd(long long type, long long x) { n   if (!type) n     sm.push(x); n   else n     bg.push(x); n } n long long tap(long long type) { n   if (!type) return sm.top(); n   return bg.top(); n } n int main() { n   memset(dp, -1, sizeof dp); n   scanf( %lld , &a); n   for (long long i = 1; i <= a; i++) { n     long long x; n     scanf( %lld , &x); n     par[i] = par[i - 1] + x; n   } n   long long ans = -100000000924052357; n   upd(0, -par[a]); n   upd(1, par[a]); n   for (long long i = a; i >= 3; i--) { n     dp[i][0] = tap(1); n     dp[i][1] = tap(0); n     upd(0, dp[i][0] - par[i - 1]); n     upd(1, dp[i][1] + par[i - 1]); n     umax(ans, dp[i][1] + par[i - 1]); n   } n   printf( %lld n , max(ans, par[a])); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const long long SZ = 1e5 + 4; n const double EPS = 1e-7; n const long long mod = 1e9 + 7; n const long long hashpow = 2; n const long long inf = 2e9; n struct custom_hash { n   static uint64_t splitmix64(uint64_t x) { n     x += 0x9e3779b97f4a7c15; n     x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9; n     x = (x ^ (x >> 27)) * 0x94d049bb133111eb; n     return x ^ (x >> 31); n   } n   size_t operator()(uint64_t x) const { n     static const uint64_t FIXED_RANDOM = n         chrono::steady_clock::now().time_since_epoch().count(); n     return splitmix64(x + FIXED_RANDOM); n   } n }; n long long n; n void read() { n   cin >> n; n   --n; n } n void solve() { n   long long x = 1; n   long long m = n % 3; n   n /= 3; n   long long cnt = 0; n   while (n >= x) { n     n -= x; n     x *= 4; n     ++cnt; n   } n   long long a = 1; n   long long b = 2; n   long long c = 3; n   vector<long long> y; n   while (n) { n     y.push_back(n % 4); n     n /= 4; n   } n   while (y.size() < cnt) { n     y.push_back(0); n   } n   for (long long i = (long long)(y.size()) - 1; i >= 0; --i) { n     a *= 4; n     b *= 4; n     c *= 4; n     if (y[i] == 1) { n       a += 1; n       b += 2; n       c += 3; n     } else if (y[i] == 2) { n       a += 2; n       b += 3; n       c += 1; n     } else if (y[i] == 3) { n       a += 3; n       b += 1; n       c += 2; n     } n   } n   if (m == 0) { n     cout << a <<   n ; n   } else if (m == 1) { n     cout << b <<   n ; n   } else { n     cout << c <<   n ; n   } n } n signed main() { n   ios_base::sync_with_stdio(0); n   cin.tie(0); n   long long t; n   cin >> t; n   for (long long i = 0; i < t; ++i) { n     read(); n     solve(); n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n struct segTree { n   long long* data; n   int n; n   segTree(int n) : n(n) { data = new long long[n * 2](); } n   void add(int i, long long v) { n     for (i += n; i; i >>= 1) data[i] += v; n   } n   int find(long long v) { n     int i = 1; n     while (i < n) { n       i *= 2; n       if (v >= data[i]) v -= data[i++]; n     } n     return i - n; n   } n   long long sum(int i) { n     long long r = data[i + n]; n     for (i += n; i > 1; i >>= 1) { n       if (i & 1) r += data[i - 1]; n     } n     return r; n   } n }; n segTree count_tree(1 << 17), sum_tree(1 << 17); n long long x[100000], t[100000]; n vector<pair<int, long long>> child[100000]; n map<int, int> ti_map; n int ti_list[100000]; n long long dp[100000], dp2[100000]; n void dfs(int p, long long T) { n   if (T <= 0) return; n   count_tree.add(ti_map[t[p]], x[p]); n   sum_tree.add(ti_map[t[p]], x[p] * t[p]); n   int i = sum_tree.find(T); n   dp[p] = count_tree.sum(i - 1); n   assert(sum_tree.sum(i - 1) <= T); n   assert(i >= 1e5 + 10 || sum_tree.sum(i) > T); n   if (i < 1e5 + 10) dp[p] += (T - sum_tree.sum(i - 1)) / ti_list[i]; n   vector<long long> child_vals; n   for (auto e : child[p]) { n     dfs(e.first, T - e.second * 2); n     child_vals.push_back(dp2[e.first]); n   } n   sort(child_vals.rbegin(), child_vals.rend()); n   dp2[p] = dp[p]; n   if (child_vals.size() >= 2) dp2[p] = max(dp2[p], child_vals[1]); n   if (p == 0) dp2[p] = max(dp2[p], child_vals[0]); n   count_tree.add(ti_map[t[p]], -x[p]); n   sum_tree.add(ti_map[t[p]], -x[p] * t[p]); n } n int main() { n   ios::sync_with_stdio(0); n   cin.tie(0); n   long long n, T; n   cin >> n >> T; n   for (int i = 0; i < n; i++) cin >> x[i]; n   for (int i = 0; i < n; i++) { n     cin >> t[i]; n     ti_map[t[i]]; n   } n   int c = 1; n   for (auto& p : ti_map) { n     ti_list[c] = p.first; n     p.second = c++; n   } n   for (int i = 1; i < n; i++) { n     long long p, l; n     cin >> p >> l; n     child[p - 1].push_back({i, l}); n   } n   dfs(0, T); n   cout << dp2[0] << endl; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n #pragma comment(linker,  /stack:200000000 ) n #pragma GCC optimize( Ofast ) n #pragma GCC optimize( unroll-loops ) n #pragma GCC target( sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native ) n using namespace std; n const long long inf = numeric_limits<long long>::max() / 2; n const long double eps = 1e-9; n const long double pi = acos(-1); n template <typename T> n inline bool mineq(T& a, T b) { n   return (a > b) ? (a = b, 1) : 0; n } n template <typename T> n inline bool maxeq(T& a, T b) { n   return (a < b) ? (a = b, 1) : 0; n } n inline void solve(), read(); n const string file =   ; n int main() { n   if (file !=   ) { n     freopen((file +  .in ).c_str(),  r , stdin); n     freopen((file +  .out ).c_str(),  w , stdout); n   } n   ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0); n   ; n   read(); n   solve(); n   return 0; n } n long long n; n vector<long long> a; n vector<pair<long long, long long> > b; n inline void solve() { n   for (long long i = 0; i < n; i++) { n     if (i && a[i] == a[i - 1]) { n       ++b.back().second; n     } else if (i == 0 || a[i] == a[i - 1] + 1) { n       b.push_back({a[i], 1}); n     } else { n       cout <<  NO  n            <<   n ; n       return; n     } n   } n   for (long long i = 0; i < (long long)((b).size()) - 2; i++) { n     b[i + 1].second -= b[i].second; n     if (b[i + 1].second <= 0) { n       cout <<  NO  n            <<   n ; n       return; n     } n   } n   if (b[(long long)((b).size()) - 1].second != n       b[(long long)((b).size()) - 2].second) { n     cout <<  NO  n          <<   n ; n     return; n   } n   cout <<  YES  n        <<   n ; n } n inline void read() { n   cin >> n; n   a.resize(n); n   for (long long i = 0; i < n; i++) { n     cin >> a[i]; n   } n   sort((a).begin(), (a).end()); n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n long long base = 31, M = 1000000007, base1 = 29, M1 = 1000000009; n long long fpow(long long x, long long y) { n   if (y == 0) return 1; n   if (y == 1) return x; n   long long p = fpow(x, y / 2) % M; n   p *= p; n   p %= M; n   if (y & 1) p *= x; n   return p % M; n } n long long po1[5005], pr[5005], po[5005], pr1[5005], suf[5005], suf1[5005]; n int ans[5005][5005], dp[5005][5005]; n pair<long long, long long> gethash(int i, int j) { n   long long has = pr[j]; n   if (i != 0) has -= (pr[i - 1] * po[j - i + 1]) % M; n   has += M; n   has %= M; n   long long has1 = pr1[j]; n   if (i != 0) has1 -= (pr1[i - 1] * po1[j - i + 1]) % M1; n   has1 += M1; n   has1 %= M1; n   return {has, has1}; n } n pair<long long, long long> gethash1(int i, int j) { n   long long has = suf[j]; n   if (i != 0) has -= (suf[i - 1] * po[j - i + 1]) % M; n   has += M; n   has %= M; n   long long has1 = suf1[j]; n   if (i != 0) has1 -= (suf1[i - 1] * po1[j - i + 1]) % M1; n   has1 += M1; n   has1 %= M1; n   return {has, has1}; n } n int main() { n   po[0] = 1; n   po1[0] = 1; n   for (int i = 1; i <= 5001; i++) { n     po[i] = po[i - 1] * base; n     po1[i] = po1[i - 1] * base1; n     po[i] %= M; n     po1[i] %= M1; n   } n   string s, t; n   char c[100005]; n   scanf( %s , &c); n   s = c; n   int n = s.size(); n   t = s; n   reverse(t.begin(), t.end()); n   int q; n   scanf( %d , &q); n   pr[0] = s[0] -  a  + 1; n   pr1[0] = s[0] -  a  + 1; n   suf[0] = t[0] -  a  + 1; n   suf1[0] = t[0] -  a  + 1; n   for (int i = 1; i < s.size(); i++) { n     long long x = s[i] -  a  + 1; n     long long y = t[i] -  a  + 1; n     pr[i] = (pr[i - 1] * base + x) % M; n     pr1[i] = (pr1[i - 1] * base1 + x) % M1; n     suf[i] = (suf[i - 1] * base + y) % M; n     suf1[i] = (suf1[i - 1] * base1 + y) % M1; n   } n   for (int i = 0; i < n; i++) { n     for (int j = i; j < n; j++) { n       pair<long long, long long> o = gethash(i, j); n       pair<long long, long long> os = gethash1(n - 1 - j, n - 1 - i); n       if (o.first == os.first && o.second == os.second) ans[i][j]++; n       if (j != i) ans[i][j] += ans[i][j - 1]; n     } n   } n   for (int i = n - 1; i >= 0; i--) { n     for (int j = i; j >= 0; j--) { n       dp[j][i] = dp[j + 1][i] + ans[j][i]; n     } n   } n   int l, r; n   while (q--) { n     scanf( %d%d , &l, &r); n     l--; n     r--; n     printf( %d n , dp[l][r]); n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int N = (int)3e5 + 50; n struct node { n   int sum, suf; n   void add(int val) { n     sum += val; n     suf = max(sum, 0); n   } n }; n node merge(node L, node R) { n   return {L.sum + R.sum, max(R.sum + L.suf, R.suf)}; n } n struct Tree { n   node dat[4 * N]; n   void init(int n) { fill(dat, dat + 4 * n, node{0, 0}); } n   void update(int pos, int x, int l, int r, int val) { n     if (l == r) { n       dat[x].add(val); n       return; n     } n     int mid = (l + r) / 2; n     if (pos <= mid) n       update(pos, 2 * x + 1, l, mid, val); n     else n       update(pos, 2 * x + 2, mid + 1, r, val); n     dat[x] = merge(dat[2 * x + 1], dat[2 * x + 2]); n   } n } tree; n int n; n int loc[N]; n int main() { n   ios::sync_with_stdio(false); n   cin.tie(NULL); n   cin >> n; n   tree.init(n); n   for (int i = 0; i < n; i++) { n     int x; n     cin >> x; n     x--; n     loc[x] = i; n   } n   int cur = n - 1; n   for (int i = 0; i < n; i++) { n     while (cur >= 0 && tree.dat[0].suf == 0) { n       tree.update(loc[cur--], 0, 0, n - 1, 1); n     } n     cout << cur + 2 <<    ; n     int q; n     cin >> q; n     q--; n     tree.update(q, 0, 0, n - 1, -1); n   } n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n long long max(long long a, long long b) { n   if (a > b) n     return a; n   else n     return b; n } n long long min(long long a, long long b) { n   if (a < b) n     return a; n   else n     return b; n } n int32_t main() { n   ios_base::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL); n   long long n; n   cin >> n; n   string s =   ; n   long long i = 0; n   while (i < n) { n     if (i < n) { n       s +=  a ; n       i++; n     } n     if (i < n) { n       s +=  a ; n       i++; n     } n     if (i < n) { n       s +=  b ; n       i++; n     } n     if (i < n) { n       s +=  b ; n       i++; n     } n   } n   cout << s <<   n ; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int maxn = 105; n int n, m, a[maxn][maxn]; n int sumr[maxn], sumc[maxn]; n bool ar[maxn], ac[maxn]; n int main() { n   ios_base::sync_with_stdio(0); n   cin >> n >> m; n   for (int i = 0; i < n; i++) n     for (int j = 0; j < m; j++) cin >> a[i][j]; n   for (int i = 0; i < n; i++) { n     for (int j = 0; j < m; j++) sumr[i] += a[i][j]; n   } n   for (int j = 0; j < m; j++) { n     for (int i = 0; i < n; i++) sumc[j] += a[i][j]; n   } n   while (1) { n     bool b = 0; n     for (int i = 0; i < n; i++) n       if (sumr[i] < 0) { n         b = 1; n         ar[i] ^= 1; n         for (int j = 0; j < m; j++) sumc[j] -= 2 * a[i][j], a[i][j] = -a[i][j]; n         sumr[i] *= -1; n       } n     for (int j = 0; j < m; j++) n       if (sumc[j] < 0) { n         b = 1; n         ac[j] ^= 1; n         for (int i = 0; i < n; i++) sumr[i] -= 2 * a[i][j], a[i][j] = -a[i][j]; n         sumc[j] *= -1; n       } n     if (!b) break; n   } n   vector<int> vr, vc; n   for (int i = 0; i < n; i++) n     if (ar[i]) vr.push_back(i); n   for (int i = 0; i < m; i++) n     if (ac[i]) vc.push_back(i); n   cout << vr.size() <<    ; n   for (int i : vr) cout << i + 1 <<    ; n   cout <<   n ; n   cout << vc.size() <<    ; n   for (int i : vc) cout << i + 1 <<    ; n   cout <<   n ; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int main() { n   ios_base::sync_with_stdio(0); n   cin.tie(0); n   int x1, y1; n   cin >> x1 >> y1; n   int x2, y2; n   cin >> x2 >> y2; n   int ans = 0x3f3f3f3f; n   for (int i = -1; i <= 1; i++) { n     for (int j = -1; j <= 1; j++) { n       if (i == 0 && j == 0) { n         continue; n       } n       ans = min(ans, abs(x1 - (x2 + i)) + abs(y1 - (y2 + j))); n     } n   } n   cout << 2 * ans + 8; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n int main() { n   int n, m, a, b, t; n   while (scanf( %d%d%d%d , &n, &m, &a, &b) != EOF) { n     if (b == n) b = (n - 1) / m * m + m; n     a--; n     b--; n     if (a > b) n       while (1) n         ; n     if (a / m == b / m || m == 1) n       t = 1; n     else if (a % m == 0) { n       if (b % m == m - 1) n         t = 1; n       else n         t = 2; n     } else { n       if (b / m - a / m == 1) n         t = 2; n       else if (b % m == m - 1) n         t = 2; n       else if ((b - a + 1) % m == 0) n         t = 2; n       else n         t = 3; n     } n     printf( %d n , t); n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int main() { n   long long int a[1000][7], i, j, m = 0, n; n   string ar; n   cin >> n; n   for (i = 0; i < n; i++) { n     cin >> ar; n     for (j = 0; j < 7; j++) { n       a[i][j] = ar[j] - 48; n     } n   } n   for (j = 0; j < 7; j++) { n     long long int l = 0; n     for (i = 0; i < n; i++) { n       if (a[i][j] == 1) { n         l++; n       } n     } n     if (l > m) { n       m = l; n     } n   } n   cout << m << endl; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int Set(int N, int pos) { return N |= (1LL << pos); } n int Reset(int N, int pos) { return N &= ~(1LL << pos); } n bool Check(int N, int pos) { return N & (1LL << pos); } n int dx[] = {0, 0, 1, -1, 1, -1, 1, -1}, dy[] = {1, -1, 0, 0, 1, -1, -1, 1}; n template <class T> n void cmin(T &a, T b) { n   if (b < a) a = b; n } n template <class T> n void cmax(T &a, T b) { n   if (b > a) a = b; n } n template <class T> n int len(const T &c) { n   return (int)c.size(); n } n template <class T> n int len(char c[]) { n   return (int)strlen(c); n } n string itos(long n) { n   string s; n   while (n) { n     s += (n % 10 + 48); n     n /= 10; n   } n   reverse(s.begin(), s.end()); n   return s; n } n long stoi(string s) { n   long n = 0; n   for (int i(0), _n(len(s)); i < _n; ++i) n = n * 10 + (s[i] - 48); n   return n; n } n long long n, ar[200005], arr[200005], m, a, p, b, aa, bb, mx = 0; n pair<int, int> fun(long d) { n   p = upper_bound(ar, ar + n, d) - ar; n   a = (p * 2 + (n - p) * 3); n   p = upper_bound(arr, arr + m, d) - arr; n   b = (p * 2 + (m - p) * 3); n   return make_pair(a, b); n } n int main() { n   mx = -100000000000000000LL; n   cin >> n; n   for (int i(0), _n(n); i < _n; ++i) cin >> ar[i]; n   cin >> m; n   for (int i(0), _n(m); i < _n; ++i) cin >> arr[i]; n   sort(ar, ar + n); n   sort(arr, arr + m); n   aa = n * 3; n   bb = m * 3; n   mx = aa - bb; n   pair<int, int> pr; n   pr = fun(ar[0] - 1); n   a = pr.first; n   b = pr.second; n   if (a - b > mx) { n     mx = a - b; n     aa = a; n     bb = b; n   } else if (a - b == mx && a > aa) { n     aa = a; n     bb = b; n   } n   for (int i(0), _n(n); i < _n; ++i) { n     pr = fun(ar[i]); n     a = pr.first; n     b = pr.second; n     if (a - b > mx) { n       mx = a - b; n       aa = a; n       bb = b; n     } else if (a - b == mx && a > aa) { n       aa = a; n       bb = b; n     } n   } n   for (int i(0), _n(m); i < _n; ++i) { n     pr = fun(arr[i]); n     a = pr.first; n     b = pr.second; n     if (a - b > mx) { n       mx = a - b; n       aa = a; n       bb = b; n     } else if (a - b == mx && a > aa) { n       aa = a; n       bb = b; n     } n   } n   pr = fun(ar[n - 1] + 1); n   a = pr.first; n   b = pr.second; n   if (a - b > mx) { n     mx = a - b; n     aa = a; n     bb = b; n   } else if (a - b == mx && a > aa) { n     aa = a; n     bb = b; n   } n   cout << aa <<  :  << bb; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int getResult(long long y) { n   printf( %lld n , y); n   fflush(stdout); n   int vd; n   scanf( %d , &vd); n   if (vd <= 0) exit(0); n   vd--; n   return vd; n } n bool solve(vector<long long> a) { n   int maxIndex = 0; n   for (int i = 1; i < 3; i++) n     if (a[i] > a[maxIndex]) maxIndex = i; n   int minIndex = 0; n   for (int i = 1; i < 3; i++) n     if (a[i] < a[minIndex]) minIndex = i; n   int middle = 3 - maxIndex - minIndex; n   long long w = 2 * a[maxIndex] - a[minIndex] - a[middle]; n   int r = getResult(w); n   if (r == maxIndex) { n     a[maxIndex] += w; n     return solve(a); n   } else { n     int otherone = 3 - maxIndex - r; n     long long w2 = a[maxIndex] - a[otherone]; n     int r2 = getResult(w2); n     return r2 == 0; n   } n } n int main() { n   vector<long long> a(3); n   for (int i = 0; i < 3; i++) scanf( %lld , &a[i]); n   printf( First n ); n   fflush(stdout); n   solve(a); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const double EPS = 1e-8; n const int INFI = 1000 * 1000 * 1000; n const long long INFL = 1000LL * 1000LL * 1000LL * 1000LL * 1000LL; n const int MX_N = 1000; n int N; n string s, t; n string strs[] = { abc ,  acb ,  bac ,  bca ,  cab ,  cba }; n int nstrs = 6; n int main() { n   cin >> N; n   cin >> s >> t; n   int dobc = 0; n   cout <<  YES  << endl; n   if (s[0] == s[1]) ++dobc; n   if (t[0] == t[1]) ++dobc; n   if (N == 1 || !dobc) { n     for (int i = 0; i < nstrs; ++i) { n       string s1 = strs[i].substr(0, 2); n       string s2 = strs[i].substr(1, 2); n       if (s == s1 || s == s2 || t == s1 || t == s2) continue; n       for (int j = 0; j < 3; ++j) n         for (int k = 0; k < N; ++k) cout << strs[i][j]; n       putchar(  n ); n       return 0; n     } n   } else { n     for (int i = 0; i < nstrs; ++i) { n       bool pass = true; n       string ap = strs[i] + strs[i]; n       for (int j = 0; j < ap.size() - 1 && pass; ++j) { n         string sb = ap.substr(j, 2); n         if (s == sb || t == sb) pass = false; n       } n       if (!pass) continue; n       for (int j = 0; j < N; ++j) cout << strs[i]; n       cout << endl; n       break; n     } n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int a[200000]; n long long INF = 1e12; n inline bool comp_bit(int x, int y) { return !!(x & y); } n inline int binsearch(int l, int r, int depth) { n   return (upper_bound(a + l, a + r, 1 << depth, comp_bit) - a); n } n long long connect(int depth, int l1, int r1, int l2, int r2) { n   if (l1 == r1 || l2 == r2) return INF; n   if (a[l1] == a[r1 - 1] && a[l2] == a[r2 - 1]) return a[l1] ^ a[l2]; n   int mid1 = binsearch(l1, r1, depth), mid2 = binsearch(l2, r2, depth); n   if (mid1 == l1 && mid2 == r2 || mid1 == r1 && mid2 == l2) n     return connect(depth - 1, l1, r1, l2, r2); n   else n     return min(connect(depth - 1, l1, mid1, l2, mid2), n                connect(depth - 1, mid1, r1, mid2, r2)); n } n long long solve(int depth, int l, int r) { n   if (!depth) return (a[l] ^ a[r - 1]) & 1; n   int mid = binsearch(l, r, depth); n   if (mid == l || mid == r) n     return solve(depth - 1, l, r); n   else n     return connect(depth - 1, l, mid, mid, r) + solve(depth - 1, l, mid) + n            solve(depth - 1, mid, r); n } n int main() { n   int n; n   scanf( %d , &n); n   for (int i = 0; i < n; ++i) scanf( %d , &a[i]); n   sort(a, a + n); n   printf( %lld , solve(29, 0, n)); n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n struct tim { n   int begin, end; n } t[200005]; n int cmp(tim a, tim b) { n   if (a.begin != b.begin) return a.begin < b.begin; n   return a.end < b.end; n } n int main() { n   int n; n   cin >> n; n   for (int i = 1; i <= n; i++) cin >> t[i].begin >> t[i].end; n   sort(t + 1, t + n + 1, cmp); n   t[0].end = -1; n   int p[3] = {0}; n   int i; n   for (i = 1; i <= n; i++) { n     if (t[p[1]].end < t[i].begin) { n       p[1] = i; n       continue; n     } n     if (t[p[2]].end < t[i].begin) { n       p[2] = i; n       continue; n     } n     break; n   } n   if (i > n) n     cout <<  YES ; n   else n     cout <<  NO ; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int dx[] = {0, 0, -1, 1}; n int dy[] = {-1, 1, 0, 0}; n const int mod = 1000000007; n const int INF = 1000000010; n int n; n char S[5020]; n int L[5010]; n int C[5010]; n int RV; n pair<int, int> RM; n int lookup[5010]; n int val[5010][15]; n int hp[5010][5010]; n int H[13][(1 << 13) + 3]; n void kmr() { n   for (int i = (0); i < (n); ++i) H[0][i] = S[i] -  0 ; n   pair<pair<int, int>, int> T[n]; n   for (int s = (0); s < (12); ++s) { n     int d = (1 << s); n     for (int i = (0); i < (n); ++i) n       T[i] = make_pair(pair<int, int>(H[s][i], i + d < n ? H[s][i + d] : 0), i); n     sort(T, T + n); n     d = 0; n     for (int i = (0); i < (n); ++i) { n       if (i && T[i - 1].first != T[i].first) ++d; n       H[s + 1][T[i].second] = d; n     } n   } n } n bool eq(pair<int, int> a, pair<int, int> b) { n   if (a.second - a.first != b.second - b.first) return 0; n   return hp[a.first][a.second] == hp[b.first][b.second]; n } n int cmp_d; n bool cmp(pair<int, int> a, pair<int, int> b) { n   int ha = hp[a.first][a.second]; n   int hb = hp[b.first][b.second]; n   if (ha == hb) return a.first < b.first; n   return ha < hb; n } n int diff(pair<int, int> a, pair<int, int> b) { n   if (max(a.second - a.first, b.second - b.first) > 12) { n     if (!eq(pair<int, int>(a.first, a.second - 12), n             pair<int, int>(b.first, b.second - 12))) n       return INF; n     a.first = a.second - 12; n     b.first = b.second - 12; n   } n   return val[a.first][a.second - a.first] - val[b.first][b.second - b.first]; n } n vector<pair<int, pair<int, int> > > P; n pair<int, pair<int, int> > prep(pair<int, int> p) { n   return make_pair(hp[p.first][p.second], p); n } n int main() { n   scanf( %s , S); n   n = strlen(S); n   for (int i = (1); i < (n + 1); ++i) { n     int d = 0; n     while ((1 << (d + 1)) < i) ++d; n     lookup[i] = d; n   } n   for (int i = (0); i < (n); ++i) { n     val[i][0] = 0; n     for (int d = (1); d < (14); ++d) n       val[i][d] = val[i][d - 1] * 2 + S[i + d - 1] -  0 ; n   } n   kmr(); n   for (int i = (0); i < (n); ++i) n     for (int j = (i + 1); j < (n + 1); ++j) n       hp[i][j] = (H[lookup[j - i]][i] << 16) + n                  H[lookup[j - i]][j - (1 << lookup[j - i])]; n   for (int d = (1); d < (n + 1); ++d) { n     int m = P.size(); n     for (int i = (0); i < (n + 1 - d); ++i) n       if (S[i] ==  1 ) P.push_back(prep(pair<int, int>(i, i + d))); n     sort(P.begin() + m, P.end()); n   } n   C[0] = 1; n   for (int i = (1); i < (n + 1); ++i) L[i] = INF; n   RV = INF; n   for (pair<int, pair<int, int> > p_ : P) { n     pair<int, int> p = p_.second; n     if (L[p.first] == INF) continue; n     C[p.second] = (C[p.second] + C[p.first]) % mod; n     L[p.second] = min(L[p.second], L[p.first] + 1); n     if (p.second == n) { n       if (RV == INF) { n         RV = L[n]; n         RM = p; n       } else { n         if (diff(p, RM) < RV - L[n]) { n           RM = p; n           RV = L[n]; n         } n       } n     } n   } n   printf( %d n , C[n]); n   int r = 0; n   for (int i = (RM.first); i < (RM.second); ++i) r = (2 * r + S[i] -  0 ) % mod; n   r = (r + RV) % mod; n   printf( %d n , r); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int c[210]; n int pre[210][210]; n int precnt[210]; n int cnt[210] = {0}; n int main() { n   int n; n   scanf( %d , &n); n   for (int i = 0; i < (n); i++) { n     scanf( %d , c + i); n     c[i] %= 3; n   } n   for (int i = 0; i < (n); i++) n     for (int j = 0; j < (n); j++) pre[i][j] = 0; n   for (int i = 0; i < (n); i++) { n     scanf( %d , precnt + i); n     int t; n     for (int j = 0; j < (precnt[i]); j++) { n       scanf( %d , &t); n       pre[i][t - 1] = 1; n     } n   } n   int mintime = 1000100; n   for (int p = 0; p < (3); p++) { n     int pos = p, time = 0, done = 0; n     for (int i = 0; i < (n); i++) cnt[i] = 0; n     while (done < n) { n       queue<int> Q; n       for (int i = 0; i < (n); i++) n         if (precnt[i] == cnt[i] && c[i] == pos) Q.push(i); n       while (!Q.empty()) { n         int part = Q.front(); n         Q.pop(); n         done++; n         time++; n         cnt[part]++; n         for (int i = 0; i < (n); i++) n           if (pre[i][part] == 1) { n             cnt[i]++; n             if (cnt[i] == precnt[i] && c[i] == pos) Q.push(i); n           } n       } n       pos = (pos + 1) % 3; n       time++; n     } n     time--; n     if (time < mintime) mintime = time; n   } n   printf( %d n , mintime); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int gcd(int a, int b) { n   if (b == 0) return a; n   return gcd(b, a % b); n } n bool isPrime(long long n) { n   long long c; n   if (n <= 1) return false; n   c = sqrt(n); n   for (int i = 2; i <= c; i++) n     if (n % i == 0) return false; n   return true; n } n int D(long long n) { n   int count = 0; n   while (n != 0) { n     n = n / 10; n     ++count; n   } n   return count; n } n const long long N = 2e5 + 7; n long long l, k, d, tr, n, m, sum, mini, maxi, a, b, c, x, y; n long long t[5007]; n set<int> vis; n vector<int> v; n int main() { n   ios_base::sync_with_stdio(false); n   cin.tie(NULL); n   for (cin >> tr; tr--;) { n     cin >> n; n     mini = 0; n     cin >> t[0]; n     for (int i = 1; i < n; i++) { n       cin >> t[i]; n       if (t[i] != t[i - 1]) { n         a = i; n         c = t[i]; n         b = i - 1; n         mini++; n       } n     } n     if (mini) { n       cout <<  YES  << endl; n       for (int i = 0; i < n; i++) { n         if (i != a) { n           if (t[i] != c) { n             cout << i + 1 <<     << a + 1 << endl; n           } else { n             cout << i + 1 <<     << b + 1 << endl; n           } n         } n       } n     } else { n       cout <<  NO  << endl; n     } n   } n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int MAXN = 3e5 + 5, LOG = 19, off = 1 << 19; n pair<int, int> t[LOG][2 * off]; n void upd(int x, pair<int, int> p, int lg) { n   for (x += off; x; x /= 2) { n     t[lg][x].first = min(t[lg][x].first, p.first); n     t[lg][x].second = max(t[lg][x].second, p.second); n   } n } n pair<int, int> get(int x, int lo, int hi, int a, int b, int lg) { n   if (lo >= a && hi <= b) { n     return t[lg][x]; n   } n   if (lo >= b || hi <= a) { n     return {off, 0}; n   } n   int mid = (lo + hi) >> 1; n   pair<int, int> lson = get(x * 2, lo, mid, a, b, lg); n   pair<int, int> rson = get(x * 2 + 1, mid, hi, a, b, lg); n   return pair<int, int>(min(lson.first, rson.first), n                         max(lson.second, rson.second)); n } n int r[MAXN]; n pair<int, int> par[MAXN][LOG]; n int main() { n   ios_base::sync_with_stdio(false); n   cin.tie(0); n   int n; n   cin >> n; n   for (int i = 0; i < n; ++i) { n     cin >> r[i]; n   } n   if (n == 1) { n     cout << 0; n     return 0; n   } n   for (int i = 0; i < 2 * off; ++i) n     for (int lg = 0; lg < LOG; ++lg) { n       t[lg][i].first = off; n     } n   for (int i = 0; i < n; ++i) n     for (int j = 0; j < 3; ++j) { n       par[i + j * n][0].first = max(0, i + j * n - r[i]); n       par[i + j * n][0].second = min(3 * n - 1, i + j * n + r[i]); n       upd(i + j * n, par[i + j * n][0], 0); n     } n   for (int lg = 1; lg < LOG; ++lg) { n     for (int i = n; i < 2 * n; ++i) { n       par[i][lg] = get(1, 0, off, par[i][lg - 1].first, n                        par[i][lg - 1].second + 1, lg - 1); n     } n     for (int i = 0; i < n; ++i) { n       par[i][lg].first = max(0, par[i + n][lg].first - n); n       par[i][lg].second = min(3 * n - 1, par[i + n][lg].second - n); n     } n     for (int i = 2 * n; i < 3 * n; ++i) { n       par[i][lg].first = max(0, par[i - n][lg].first + n); n       par[i][lg].second = min(3 * n - 1, par[i - n][lg].second + n); n     } n     for (int i = 0; i < 3 * n; ++i) { n       upd(i, par[i][lg], lg); n     } n   } n   for (int j = 0; j < n; ++j) { n     int i = n + j; n     int lo = i, hi = i, sol = 0; n     for (int lg = LOG - 1; lg >= 0; --lg) { n       pair<int, int> res = get(1, 0, off, lo, hi + 1, lg); n       if (res.second - res.first + 1 < n) { n         lo = res.first; n         hi = res.second; n         sol += (1 << lg); n       } n     } n     cout << sol + 1 << endl; n   } n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n #pragma comment(linker,  /STACK:255000000 ) n bool firstout = 1; n template <class T> n T &minn(T &a, T b) { n   if (b < a) a = b; n   return a; n } n template <class T> n T &maxx(T &a, T b) { n   if (a < b) a = b; n   return a; n } n int &madd(int &a, int b) { n   a += b; n   if (a >= 1000000009) a -= 1000000009; n   return a; n } n int &msub(int &a, int b) { n   a -= b; n   if (a < 0) a += 1000000009; n   return a; n } n int &mmult(int &a, int b) { return a = (long long)a * b % 1000000009; } n int mdiv(long long a, long long b, long long m) { n   a = (a % m + m) % m; n   b = (b % m + m) % m; n   if (a % b == 0) return a / b; n   return (a + m * mdiv(-a, m, b)) / b; n } n int n, m; n int A[201234]; n int B[201234]; n int R[201234]; n int RR[201234]; n int P[201234]; n vector<int> O[201234]; n vector<int> OO[201234]; n void fnd(int *R) { n   int i, j, k; n   for (i = (0); i < (n); ++i) P[B[i]] = i; n   for (i = (0); i < (2 * n); ++i) OO[i].clear(), O[i].clear(); n   for (i = (0); i < (n); ++i) { n     j = P[A[i]]; n     j = (i - j + n) % n; n     O[j].push_back(-j); n     OO[j + n - i].push_back(-j); n   } n   for (i = (0); i < (n); ++i) R[i] = 1012345678; n   multiset<int> s; n   s.clear(); n   for (i = (0); i < (2 * n); ++i) { n     for (k = (0); k < (O[i].size()); ++k) s.insert(O[i][k]); n     for (k = (0); k < (OO[i].size()); ++k) s.erase(s.find(OO[i][k])); n     if (s.size()) minn(R[i % n], *s.begin() + i); n   } n } n int main() { n   int i, j, k; n   char c; n   int a, d; n   int ts; n   for (ts = 1; scanf( %  n                       d , n                      &(n)) > 0; n        ++ts) { n     for (i = (0); i < (n); ++i) n       scanf( n            %  n            d , n           &(A[i])), n           --A[i]; n     for (i = (0); i < (n); ++i) n       scanf( n            %  n            d , n           &(B[i])), n           --B[i]; n     fnd(R); n     reverse(A, A + n); n     reverse(B, B + n); n     fnd(RR); n     int res = 0; n     for (i = (0); i < (n); ++i) n       printf( n            %  n            d , n           (min(RR[i], R[(n - i) % n]))), n           printf(  n ), firstout = 1; n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n map<double, int> a; n double b[200007]; n inline long long int read() { n   long long int x = 0, f = 1; n   char ch = getchar(); n   while (ch <  0  || ch >  9 ) { n     if (ch ==  - ) f = -1; n     ch = getchar(); n   } n   while (ch >=  0  && ch <=  9 ) x = x * 10 + ch -  0 , ch = getchar(); n   return x * f; n } n inline void writ(int x) { n   if (x < 0) putchar( - ), x = -x; n   if (x > 9) writ(x / 10); n   putchar(x % 10 +  0 ); n } n inline void write(int x) { n   writ(x); n   putchar(   ); n } n int main() { n   a.clear(); n   int n = read(), x, y, z; n   for (int i = 1; i <= n; ++i) n     x = read(), y = read(), z = read(), b[i] = (double)(x + y) / z, ++a[b[i]]; n   for (int i = 1; i <= n; ++i) write(a[b[i]]); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n unsigned long long int n, m, l; n unsigned long long int r, k, nn; n template <class T> n inline T min(T a, T b) { n   return ((a < b) ? a : b); n } n char frac[9][500][500]; n string p[500]; n char isfrac(char a, char b, char c, char d) { n   char mx = max(max(a, b), max(c, d)); n   return ( n       (((mx & 8) ? (a == mx) : (a == 0)) && ((mx & 4) ? (b == mx) : (b == 0)) && n        ((mx & 2) ? (c == mx) : (c == 0)) && ((mx & 1) ? (d == mx) : (d == 0))) n           ? mx n           : -1); n } n int main(int argc, char** argv) { n   cin >> n >> m; n   for (int i = 0; i < n; ++i) { n     cin >> p[i]; n   } n   char f = 0; n   for (int i = 0; i < (n - 1); ++i) { n     for (int j = 0; j < (m - 1); ++j) { n       f = 0; n       if (p[i][j] ==  . ) { n         f += 8; n       } n       if (p[i][j + 1] ==  . ) { n         f += 4; n       } n       if (p[i + 1][j] ==  . ) { n         f += 2; n       } n       if (p[i + 1][j + 1] ==  . ) { n         f += 1; n       } n       frac[0][i][j] = f; n     } n   } n   int cnt = 0; n   int l = 1; n   int pw = 2; n   while (((2 * pw) <= n) && ((2 * pw) <= m)) { n     for (int i = 0; i <= (n - 2 * pw); ++i) { n       for (int j = 0; j <= (m - 2 * pw); ++j) { n         frac[l][i][j] = n             isfrac(frac[l - 1][i][j], frac[l - 1][i][j + pw], n                    frac[l - 1][i + pw][j], frac[l - 1][i + pw][j + pw]); n         if (frac[l][i][j] >= 0) { n           cnt++; n         } n       } n     } n     ++l; n     pw *= 2; n   } n   cout << cnt; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n bitset<4001> g[4001]; n int main() { n   int n, m; n   cin >> n >> m; n   vector<pair<int, int> > v; n   for (int i = 0; i < m; i++) { n     int a, b; n     cin >> a >> b; n     a--; n     b--; n     g[a][b] = 1; n     g[b][a] = 1; n     v.push_back(pair<int, int>(a, b)); n   } n   int minx = 100000000; n   bool was = 0; n   for (int i = 0; i < v.size(); i++) { n     int a = v[i].first; n     int b = v[i].second; n     for (int j = 0; j < n; j++) { n       if (g[a][j] && g[b][j]) { n         minx = min(minx, (int)(g[a].count() + g[b].count() + g[j].count()) - 6); n         was = true; n       } n     } n   } n   if (was) n     cout << minx; n   else n     cout << -1; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const long long mod = 1e9 + 7; n const int N = 1e5 + 4; n const long long MOD = 998244353; n bool ans[2 * N]; n long long POW(long long base, long long exponent) { n   long long result = 1; n   while (exponent > 0) { n     if (exponent % 2 == 1) result = (result * base) % MOD; n     exponent = exponent >> 1; n     base = (base * base) % MOD; n   } n   return result; n } n long long Inv(long long x) { return POW(x, MOD - 2); } n void BFS(int s, vector<int> &d, vector<int> edge[]) { n   d[s] = 0; n   queue<int> q; n   q.push(s); n   while (!q.empty()) { n     int v = q.front(); n     q.pop(); n     for (auto to : edge[v]) { n       if (d[to] == (int)1e9) { n         d[to] = d[v] + 1; n         q.push(to); n       } n     } n   } n } n int main() { n   std::ios::sync_with_stdio(false); n   cin.tie(0); n   int t; n   cin >> t; n   while (t--) { n     int n; n     cin >> n; n     int a[n]; n     for (int i = 0; i < n; i++) cin >> a[i]; n     int l = 0, r = n - 1, ls = 0, rs = 0, al = 0, b = 0, mv = 0; n     while (l <= r) { n       if (mv & 1) { n         rs = 0; n         while (rs <= ls and r >= l) rs += a[r--]; n         b += rs; n         mv++; n       } else { n         ls = 0; n         while (ls <= rs and l <= r) ls += a[l++]; n         al += ls; n         mv++; n       } n     } n     cout << mv <<     << al <<     << b <<   n ; n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int dis[75][1 << 18]; n bool mark[75][1 << 18]; n int n, m, A, B; n vector<pair<int, int> > ve[75]; n struct zzt { n   pair<int, int> to; n   int di; n }; n bool operator<(zzt aa, zzt bb) { return aa.di > bb.di; } n priority_queue<zzt> q; n int fa[75]; n int gf(int x) { return fa[x] == x ? x : fa[x] = gf(fa[x]); } n int sz[75]; n void merge(int x, int y) { n   x = gf(x); n   y = gf(y); n   if (x != y) fa[x] = y, sz[y] += sz[x]; n } n int mk[75], mkid; n int ozt(int x) { return mk[x] ? (1 << (mk[x] - 1)) : 0; } n int main() { n   scanf( %d%d%d%d , &n, &m, &A, &B); n   for (int i = 1; i <= n; i++) fa[i] = i, sz[i] = 1; n   for (int i = 1; i <= m; i++) { n     int x, y, z; n     scanf( %d%d%d , &x, &y, &z); n     ve[x].push_back(pair<int, int>(y, z)); n     ve[y].push_back(pair<int, int>(x, z)); n     if (z == A) merge(x, y); n   } n   mkid = 0; n   for (int i = 1; i <= n; i++) { n     if ((!mk[i]) && sz[gf(i)] > 3) { n       ++mkid; n       for (int j = i; j <= n; j++) { n         if (gf(j) == gf(i)) mk[j] = mkid; n       } n     } n   } n   q.push((zzt){pair<int, int>(1, ozt(1)), 0}); n   memset(dis, 0x3f, sizeof dis); n   dis[1][ozt(1)] = 0; n   while (q.size()) { n     int x = q.top().to.first; n     int zt = q.top().to.second; n     q.pop(); n     if (mark[x][zt]) continue; n     mark[x][zt] = 1; n     for (auto p : ve[x]) { n       int y = p.first; n       int le = p.second; n       if (le == A) { n         if (dis[y][zt] > dis[x][zt] + le) { n           dis[y][zt] = dis[x][zt] + le; n           q.push((zzt){pair<int, int>(y, zt), dis[y][zt]}); n         } n       } else if (gf(y) != gf(x) && (ozt(y) & zt) == 0) { n         if (dis[y][zt | ozt(y)] > dis[x][zt] + le) { n           dis[y][zt | ozt(y)] = dis[x][zt] + le; n           q.push((zzt){pair<int, int>(y, zt | ozt(y)), dis[y][zt | ozt(y)]}); n         } n       } n     } n   } n   for (int i = 1; i <= n; i++) { n     int ans = 0x3f3f3f3f; n     for (int j = 0; j <= (1 << mkid) - 1; j++) { n       ans = min(ans, dis[i][j]); n     } n     cout << ans <<    ; n   } n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int main() { n   long long i, j, k, l, m, n, t, x, y; n   cin >> n; n   if (n % 2 == 0) n     cout << n + 4 <<     << 4 << endl; n   else n     cout << n + 9 <<     << 9 << endl; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n inline bool is_prime(int n) { n   for (int i = 2; i * i <= n; ++i) n     if (n % i == 0) return 0; n   return 1; n } n inline int Exp(int a, int p, int mod) { n   int res = 1; n   while (p) { n     if (p & 1) res = (long long)res * a % mod; n     p >>= 1; n     a = (long long)a * a % mod; n   } n   return res; n } n inline int get_root(int n) { n   for (int i = 2; i < n; ++i) { n     if (Exp(i, n - 1, n) != 1) continue; n     bool ok = 1; n     for (int j = 1; j < n - 1; ++j) n       if (Exp(i, j, n) == 1) { n         ok = 0; n         break; n       } n     if (ok) return i; n   } n   return -1; n } n int main() { n   int n; n   scanf( %d , &n); n   if (n == 1) { n     puts( YES ); n     puts( 1 ); n     return 0; n   } n   if (n == 4) { n     puts( YES ); n     puts( 1 ); n     puts( 3 ); n     puts( 2 ); n     puts( 4 ); n     return 0; n   } n   if (n == 2) { n     puts( YES ); n     puts( 1 2 ); n     return 0; n   } n   if (is_prime(n)) { n     puts( YES ); n     int g = get_root(n); n     printf( %d n , Exp(g, n - 1, n)); n     for (int i = 1; i <= n - 2; ++i) { n       if (i & 1) n         printf( %d n , Exp(g, i, n)); n       else n         printf( %d n , Exp(g, n - 1 - i, n)); n     } n     printf( %d n , n); n   } else n     puts( NO ); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n char str[105]; n int main() { n   int n; n   scanf( %d , &n); n   scanf( %s , str); n   vector<int> g; n   int sum = 0; n   for (int i = 0; i < n; i++) { n     if (str[i] ==  B ) { n       sum++; n     } else { n       if (sum) g.push_back(sum); n       sum = 0; n     } n   } n   if (sum) g.push_back(sum); n   printf( %d n , g.size()); n   for (int i = 0; i < g.size(); i++) { n     printf( %d  , g[i]); n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int main() { n   int T; n   scanf( %d , &T); n   while (T--) { n     long long s, n, k; n     scanf( %lld%lld%lld , &s, &n, &k); n     if (s < k) n       printf( NO n ); n     else if (s == k) n       printf( YES n ); n     else { n       long long left_sum = s - n; n       long long extra_sum = (n / k) * k; n       if (left_sum < extra_sum) n         printf( YES n ); n       else n         printf( NO n ); n     } n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n long long gcd(long long a, long long b) { n   if (a == 0 || b == 0) return (a + b); n   if (a > b) return (gcd(a % b, b)); n   return (gcd(a, b % a)); n } n long long lcm(long long a, long long b) { return ((a * b / gcd(a, b))); } n int sqr(int x) { return (x * x); } n void out() { n   puts( NO ); n   exit(0); n } n using namespace std; n int n; n int p[100008]; n int main() { n   cin >> n; n   for (int i = (int)(1); i < (int)(n + 1); ++i) p[i] = i; n   if (n % 2 == 1) { n     cout <<  -1 n ; n     return 0; n   } n   for (int i = (int)(1); i < (int)(n + 1); ++i) { n     swap(p[i], p[i + 1]); n     i++; n   } n   for (int i = (int)(n); i >= (int)(1); --i) cout << i <<    ; n   cout << endl; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n const int N = 1e5 + 5; n const int K = 655; n const int mod = 998244353; n int T; n int n, a[N]; n int q[K], v[K], w[K], top = 0; n int q2[K], v2[K], w2[K], top2 = 0; n int MOD(int x) { return x >= mod ? x - mod : x; } n int u(int x, int y) { return (x + y - 1) / y; } n int main() { n   scanf( %d , &T); n   while (T--) { n     scanf( %d , &n); n     for (int i = 1; i <= n; ++i) scanf( %d , &a[i]); n     q[top = 1] = a[n], v[1] = 0, w[1] = 1; n     int ans = 0; n     for (int i = n - 1; i >= 1; --i) { n       top2 = 0; n       for (int l = 1, r, j = 0; l <= a[i]; l = r + 1) { n         r = a[i] / (a[i] / l); n         q2[++top2] = a[i] / l; n         v2[top2] = 0; n         w2[top2] = (l == 1); n         if (i == 1) { n           int tmp = 1; n         } n         while (j < top && u(a[i], q[j + 1]) >= l && u(a[i], q[j + 1]) <= r) { n           ++j; n           v2[top2] = MOD(v2[top2] + MOD(v[j] + (long long)(u(a[i], q[j]) - 1) * n                                                    w[j] % mod)); n           w2[top2] = w2[top2] + w[j]; n         } n       } n       for (int j = 1; j <= top2; ++j) { n         q[j] = q2[j]; n         v[j] = v2[j]; n         w[j] = w2[j]; n       } n       top = top2; n       for (int j = 1; j <= top; ++j) ans = MOD(ans + v[j]); n     } n     printf( %d n , ans); n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int main() { n   int n, m, min, max, i, t, f = 0; n   cin >> n >> m; n   cin >> min; n   max = min; n   for (i = 1; i < n; i++) { n     cin >> t; n     if (t > max) n       max = t; n     else if (t < min) n       min = t; n   } n   if (2 * min > max) max = 2 * min; n   for (i = 0; i < m; i++) { n     cin >> t; n     if (t <= max) f = 1; n   } n   if (f == 1) n     cout <<  -1 n ; n   else n     cout << max << endl; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n template <typename T> n inline void read(T& x) { n   char c = getchar(); n   bool f = false; n   for (x = 0; !isdigit(c); c = getchar()) { n     if (c ==  - ) { n       f = true; n     } n   } n   for (; isdigit(c); c = getchar()) { n     x = x * 10 + c -  0 ; n   } n   if (f) { n     x = -x; n   } n } n template <typename T, typename... U> n inline void read(T& x, U&... y) { n   read(x), read(y...); n } n const int N = 5e1 + 10; n const double eps = 1e-6; n int n; n int ID[N]; n double K; n double A[N], B[N], F[N][N]; n double V(int a) { return A[a] - K * B[a]; } n bool cmp(int a, int b) { return A[a] == A[b] ? V(a) > V(b) : A[a] > A[b]; } n int main() { n   read(n); n   for (int i = 1; i <= n; ++i) scanf( %lf , &A[i]); n   for (int i = 1; i <= n; ++i) scanf( %lf , &B[i]), ID[i] = i; n   double L = 0.01, R = 5e9, res = 233; n   while (R - L >= eps) { n     double mid = (L + R) / 2.0; n     K = mid; n     sort(ID + 1, ID + n + 1, cmp); n     for (int i = 0; i <= n; ++i) n       for (int j = 0; j <= n; ++j) F[i][j] = 1e18; n     F[0][0] = 0; n     int cnt = 0; n     for (int i = 1; i <= n; ++i) { n       ++cnt; n       double sum = V(ID[i]); n       int p = i; n       while (p != n && A[ID[p + 1]] == A[ID[i]]) sum += V(ID[++p]); n       double g = 0; n       int s = p - i + 1; n       for (int j = 0; j <= s; ++j) { n         if (j) g += V(ID[i + j - 1]); n         for (int k = 0; k <= i - 1; ++k) n           if (j <= k) { n             F[cnt][k - j + s - j] = n                 min(F[cnt][k - j + s - j], F[cnt - 1][k] + sum - g); n           } n       } n       i = p; n     } n     double ANS = 1e18; n     for (int i = 0; i <= n; ++i) ANS = min(ANS, F[cnt][i]); n     if (ANS <= eps) n       res = mid, R = mid - eps; n     else n       L = mid + eps; n   } n   printf( %lld n , (long long)(res * 100000 + 99) / 100); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int Maxn = 200005; n struct M { n   int val, pos; n }; n M a[Maxn], b[Maxn]; n int idx[Maxn], idy[Maxn], Nx[Maxn], Ny[Maxn]; n int read() { n   int sum = 0, t = 1; n   char c = getchar(); n   while (c <  0  || c >  9 ) { n     if (c ==  - ) t = -1; n     c = getchar(); n   } n   while (c >=  0  && c <=  9 ) { n     sum = sum * 10 + c -  0 ; n     c = getchar(); n   } n   return sum * t; n } n bool cmp(M x, M y) { n   return (x.val < y.val || (x.val == y.val && b[x.pos].val < b[y.pos].val)); n } n long long C2(long long x) { return 1ll * x * (x - 1) / 2; } n int main() { n   int n; n   scanf( %d , &n); n   for (int i = 1; i <= n; ++i) { n     a[i].val = read(), b[i].val = read(); n     a[i].pos = b[i].pos = i; n   } n   sort(a + 1, a + n + 1, cmp); n   int cnt = 0, same = 1; n   long long res = 0; n   a[0].val = b[0].val = -0x3f3f3f3f; n   cnt = 0; n   for (int i = 1; i <= n; ++i) { n     if (a[i].val != a[i - 1].val) n       cnt++, res += C2(same), same = 1; n     else { n       if (b[a[i].pos].val == b[a[i - 1].pos].val) n         same++; n       else n         res += C2(same), same = 1; n     } n     idx[a[i].pos] = cnt; n   } n   res += C2(same); n   sort(b + 1, b + n + 1, cmp); n   cnt = 0; n   for (int i = 1; i <= n; ++i) { n     if (b[i].val != b[i - 1].val) cnt++; n     idy[b[i].pos] = cnt; n   } n   for (int i = 1; i <= n; ++i) { n     Nx[idx[i]]++; n     Ny[idy[i]]++; n   } n   long long ans = 0; n   for (int i = 1; i <= n; ++i) { n     ans += C2(Nx[i]) + C2(Ny[i]); n   } n   ans -= res; n   printf( %lld , ans); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int n, m, k, i, dis = 10000000, temp, a[1000]; n int main() { n   cin >> n >> m >> k; n   for (i = 0; i < n; ++i) cin >> a[i]; n   for (i = 0; i < n; ++i) { n     if (a[i] != 0 && a[i] <= k) { n       if (m <= i) n         temp = (i - m + 1) * 10; n       else n         temp = (m - i - 1) * 10; n       if (dis > temp) dis = temp; n     } n   } n   cout << dis; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int main() { n   long long k, m = 9, x; n   long long r = 1, n, j, d = 0; n   cin >> k; n   while (k - m * r > 0) { n     k -= m * r; n     ++r; n     m = m * 10; n   } n   n = (k - 1) / r; n   j = (k - 1) % r; n   x = pow(10, r - 1) + n; n   for (long i = 0; i < r - j - 1; ++i) x /= 10; n   d = x % 10; n   cout << d << endl; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int main() { n   int n, count1 = 0, count2 = 0, sum = 0; n   scanf( %d , &n); n   vector<pair<int, int> > v1; n   vector<pair<int, int> > v2; n   for (int i = 0; i < n; i++) { n     int x, a; n     scanf( %d %d , &x, &a); n     if (x < 0) { n       v1.push_back(make_pair(x, a)); n       count1++; n     } else { n       v2.push_back(make_pair(x, a)); n       count2++; n     } n   } n   sort(v1.begin(), v1.end()); n   reverse(v1.begin(), v1.end()); n   sort(v2.begin(), v2.end()); n   vector<pair<int, int> >::iterator it1 = v1.begin(); n   vector<pair<int, int> >::iterator it2 = v2.begin(); n   vector<pair<int, int> >::iterator it3 = v1.end(); n   vector<pair<int, int> >::iterator it4 = v2.end(); n   if (count1 > count2) { n     while (it1 != v1.end()) { n       sum += it1->second; n       it1++; n       if (it2 != v2.end()) { n         sum += it2->second; n         it2++; n       } else n         break; n     } n   } else if (count1 < count2) { n     while (it2 != v2.end()) { n       sum += it2->second; n       it2++; n       if (it1 != v1.end()) { n         sum += it1->second; n         it1++; n       } else n         break; n     } n   } else if (count1 == count2) { n     if ((it3->second) > (it4->second)) { n       while (it1 != v1.end()) { n         sum += it1->second; n         it1++; n         sum += it2->second; n         it2++; n       } n     } else { n       while (it2 != v2.end()) { n         sum += it2->second; n         it2++; n         sum += it1->second; n         it1++; n       } n     } n   } n   printf( %d n , sum); n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n inline int read() { n   int x = 0, f = 1; n   char c = getchar(); n   while (c <  0  || c >  9 ) { n     if (c ==  - ) f = -1; n     c = getchar(); n   } n   while (c >=  0  && c <=  9 ) { n     x = (x << 3) + (x << 1) + c -  0 ; n     c = getchar(); n   } n   return x * f; n } n const int MAX_N = 1e3 + 10; n int H[MAX_N][MAX_N], CM[MAX_N][MAX_N], TM[MAX_N][MAX_N], N, M, A, B, SUM = 0; n long long S[MAX_N][MAX_N]; n bool vis[MAX_N][MAX_N]; n vector<pair<long long, pair<int, int> > > V, Ans; n struct MY_QUEUE { n   deque<pair<int, int> > Q; n   inline void reset() { Q.clear(); } n   inline void push(int val, int mark) { n     pair<int, int> now = make_pair(val, mark); n     while (Q.size() && Q.back().first > val) Q.pop_back(); n     Q.push_back(make_pair(val, mark)); n   } n   inline void pop(int mark) { n     if (Q.front().second == mark) Q.pop_front(); n   } n   inline int get() { return Q.front().first; } n }; n inline bool check_X(int x) { return x >= 0 && x < N; } n inline bool check_Y(int y) { return y >= 0 && y < M; } n signed main() { n   ios::sync_with_stdio(false); n   cin.tie(0); n   cout.tie(0); n   N = read(); n   M = read(); n   A = read(); n   B = read(); n   for (int i = 0; i < N; i++) n     for (int j = 0; j < M; j++) H[i][j] = read(); n   for (int i = 0; i < M; i++) { n     MY_QUEUE QUEUE; n     for (int j = 0; j < N; j++) { n       QUEUE.push(H[j][i], j); n       if (j >= A) QUEUE.pop(j - A); n       if (j >= A - 1) CM[j - A + 1][i] = QUEUE.get(); n     } n   } n   for (int i = 0; i < N; i++) { n     MY_QUEUE QUEUE; n     for (int j = 0; j < M; j++) { n       QUEUE.push(CM[i][j], j); n       if (j >= B) QUEUE.pop(j - B); n       if (j >= B - 1) TM[i][j - B + 1] = QUEUE.get(); n     } n   } n   for (int i = 1; i <= N; i++) n     for (int j = 1; j <= M; j++) n       S[i][j] = (long long)S[i][j] + S[i][j - 1] + H[i - 1][j - 1]; n   for (int i = 1; i <= M; i++) n     for (int j = 1; j <= N; j++) S[j][i] = (long long)S[j][i] + S[j - 1][i]; n   for (int i = 0; i <= N - A; i++) n     for (int j = 0; j <= M - B; j++) { n       long long sum = (long long)S[i + A][j + B] - S[i + A][j] - S[i][j + B] + n                       S[i][j], n                 dec = (long long)TM[i][j] * A * B; n       V.push_back(make_pair(sum - dec, make_pair(i, j))); n     } n   sort(V.begin(), V.end()); n   for (int i = 0; i < V.size(); i++) { n     long long val = V[i].first; n     int X = V[i].second.first, Y = V[i].second.second; n     if (vis[X][Y]) continue; n     SUM++; n     Ans.push_back(make_pair(val, make_pair(X + 1, Y + 1))); n     for (int i = X - A + 1; i <= X + A - 1; i++) n       for (int j = Y - B + 1; j <= Y + B - 1; j++) n         if (check_X(i) && check_Y(j)) vis[i][j] = 1; n   } n   printf( %d n , SUM); n   for (int i = 0; i < Ans.size(); i++) n     printf( %d %d %I64d n , Ans[i].second.first, Ans[i].second.second, n            Ans[i].first); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n #pragma comment(linker,  /STACK:1024000000,1024000000 ) n using namespace std; n const int maxm = 100005 * 2; n const int maxn = 100005; n const int mod = 1000000007; n struct Edge { n   int v, next; n } E[maxm]; n struct sw { n   int v, next; n } EE[maxm]; n int head[maxn], ind; n int headd[maxn], indd; n int dfs[maxn], low[maxn], clo; n int bri, cou, S[maxn], hi; n int n, m; n int f[maxn], have[maxn]; n void add(int u, int v) { n   E[ind].v = v, E[ind].next = head[u], head[u] = ind++; n   E[ind].v = u, E[ind].next = head[v], head[v] = ind++; n } n void add1(int u, int v) { n   EE[indd].v = v, EE[indd].next = headd[u], headd[u] = indd++; n   EE[indd].v = u, EE[indd].next = headd[v], headd[v] = indd++; n } n void init() { n   memset(head, -1, sizeof(head)); n   memset(headd, -1, sizeof(headd)); n   memset(dfs, -1, sizeof(dfs)); n   memset(low, -1, sizeof(low)); n   clo = ind = indd = 0; n } n vector<int> vvv[maxn]; n void tarjan(int u, int id) { n   dfs[u] = low[u] = clo++; n   S[hi++] = u; n   for (int i = head[u]; ~i; i = E[i].next) { n     if (i == (id ^ 1)) continue; n     int v = E[i].v; n     if (dfs[v] == -1) { n       tarjan(v, i); n       low[u] = min(low[u], low[v]); n       if (dfs[u] < low[v]) { n         bri++; n         vvv[u].push_back(v); n       } n     } else n       low[u] = min(low[u], dfs[v]); n   } n   if (dfs[u] == low[u]) { n     int v; n     do { n       v = S[--hi]; n       f[v] = u; n       for (int j = 0; j < vvv[v].size(); j++) { n         int pa = f[vvv[v][j]]; n         add1(u, pa); n       } n       have[u]++; n     } while (u != v); n   } n } n void work() { n   hi = 0; n   for (int i = 1; i <= n; i++) n     if (dfs[i] == -1) { n       tarjan(i, -1); n     } n } n int ff[maxn][18], lev; n int dep[maxn]; n long long dis[maxn]; n int LCA(int x, int y) { n   if (dep[x] > dep[y]) x = x ^ y, y = x ^ y, x = x ^ y; n   for (int i = lev; i >= 0; i--) n     if (dep[y] - dep[x] >> i & 1) y = ff[y][i]; n   if (x == y) return x; n   for (int i = lev; i >= 0; i--) n     if (ff[x][i] != ff[y][i]) x = ff[x][i], y = ff[y][i]; n   return ff[x][0]; n } n void done(int u, int p) { n   dep[u] = dep[p] + 1; n   if (have[u] > 1) n     dis[u] = dis[p] * 2 % mod; n   else n     dis[u] = dis[p]; n   ff[u][0] = p; n   int v; n   for (int i = headd[u]; ~i; i = EE[i].next) { n     v = EE[i].v; n     if (v != p) { n       done(v, u); n     } n   } n } n void initLca() { n   dis[0] = 1; n   done(1, 0); n   lev = 1; n   for (; (1 << lev) <= n; lev++) n     for (int i = 0; i <= n; i++) n       if (f[i] == i) ff[i][lev] = ff[ff[i][lev - 1]][lev - 1]; n   lev--; n } n long long extend_gcd(long long a, long long b, long long &x, long long &y) { n   if (b == 0) { n     x = 1, y = 0; n     return a; n   } n   long long gcd = extend_gcd(b, a % b, x, y); n   long long t = x; n   x = y; n   y = t - a / b * x; n   return gcd; n } n long long Get_Inverse(long long num) { n   long long x, y; n   extend_gcd(num, 1000000007, x, y); n   return (x % 1000000007 + 1000000007) % 1000000007; n } n int main(void) { n   while (~scanf( %d%d , &n, &m)) { n     init(); n     while (m--) { n       int u, v; n       scanf( %d%d , &u, &v); n       add(u, v); n     } n     work(); n     initLca(); n     int k, a, b, fa, fb, pa; n     scanf( %d , &k); n     for (int i = 0; i < k; i++) { n       scanf( %d%d , &a, &b); n       fa = f[a]; n       fb = f[b]; n       long long ans = dis[fa] * dis[fb] % mod; n       pa = LCA(fa, fb); n       int need = (have[pa] > 1 ? 2 : 1); n       ans = ans * Get_Inverse(dis[pa]) % mod; n       ans = ans * (Get_Inverse(dis[pa] * Get_Inverse(need) % mod)) % mod; n       printf( %I64d n , ans); n     } n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int main() { n   int x, a, b, i, j, k, siz, cnt = 0, p, q, s, t, z, h, po; n   string str; n   cin >> str; n   cin >> x; n   siz = str.size(); n   for (i = 0; i < siz; i++) { n     if (str[i] !=  *  && str[i] !=  ? ) cnt++; n   } n   p = siz - cnt; n   q = cnt - p; n   if (x < q) n     cout <<  Impossible  << endl; n   else if (x >= q && x <= cnt) { n     s = 0; n     t = cnt - x; n     for (i = 0; i < siz; i++) { n       if (s < t && (str[i + 1] ==  ?  || str[i + 1] ==  * )) { n         s++; n       } else { n         if (str[i] >=  a  && str[i] <=  z ) cout << str[i]; n       } n     } n   } else { n     z = x - cnt; n     h = 0; n     for (i = 0; i < siz; i++) { n       if (str[i] ==  * ) { n         h++; n         po = i; n         break; n       } n     } n     if (h == 0) n       cout <<  Impossible  << endl; n     else { n       for (i = 0; i < siz; i++) { n         if (i == po) { n           for (j = 1; j <= z; j++) { n             cout << str[i - 1]; n           } n         } else { n           if (str[i] >=  a  && str[i] <=  z ) { n             cout << str[i]; n           } n         } n       } n     } n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n #pragma GCC optimize( Ofast ) n #pragma GCC optimize( unroll-loops ) n #pragma GCC target( sse,sse2,sse3,ssse3,abm,mmx,tune=native ) n using namespace std; n long long gcd(long long i, long long j) { n   if (j == 0) n     return i; n   else n     return gcd(j, i % j); n } n template <typename T> n inline T getint() { n   T val = 0; n   char c; n   bool neg = false; n   while ((c = getchar()) && !(c >=  0  && c <=  9 )) { n     neg |= c ==  - ; n   } n   do { n     val = (val * 10) + c -  0 ; n   } while ((c = getchar()) && (c >=  0  && c <=  9 )); n   return val * (neg ? -1 : 1); n } n const long long INF = 1e9 + 100; n const int mod = 1000000007; n const long double eps = 1e-10, pi = acosl(-1); n const long long maxN = 300010, maxT = 10010, A = 179, mid = 150; n mt19937 mt_rand(time(0)); n long long bp(long long et, long long b) { n   b %= mod - 1; n   long long res = 1; n   for (int i = 30; i >= 0; --i) { n     res = (res * res) % mod; n     if ((b & (1 << i)) != 0) res = (res * et) % mod; n   } n   return res; n } n void panic() { n   cout <<  -1 n ; n   exit(0); n } n const int byben_size = 23; n vector<int> merge(const vector<int>& a, const vector<int>& b, n                   bool want_mx = true) { n   int s1 = a.size(), s2 = b.size(); n   int sz = min(s1 + s2, byben_size); n   vector<int> r(sz); n   if (!want_mx) { n     int y1 = 0, y2 = 0; n     int y = 0; n     while (y < sz && y1 < s1 && y2 < s2) { n       if (a[y1] < b[y2]) n         r[y++] = a[y1++]; n       else n         r[y++] = b[y2++]; n     } n     while (y < sz && y1 < s1) r[y++] = a[y1++]; n     while (y < sz && y2 < s2) r[y++] = b[y2++]; n   } else { n     int y1 = s1 - 1, y2 = s2 - 1; n     int y = sz - 1; n     while (y >= 0 && y1 >= 0 && y2 >= 0) { n       if (a[y1] > b[y2]) n         r[y--] = a[y1--]; n       else n         r[y--] = b[y2--]; n     } n     while (y >= 0 && y1 >= 0) r[y--] = a[y1--]; n     while (y >= 0 && y2 >= 0) r[y--] = b[y2--]; n   } n   return r; n } n vector<int> t[1 << 18]; n int sz = 1 << 17; n int a[maxN]; n vector<int> l1[maxN], r1[maxN]; n inline void add(int l, int r, int id, bool want_mx) { n   for (l += sz, r += sz; l <= r; l >>= 1, r >>= 1) { n     if (l & 1) { n       int v = l++; n       t[v].push_back(id); n       int szz = t[v].size(); n       int rr = szz; n       --szz; n       while (szz > 0 && t[v][szz] < t[v][szz - 1]) { n         swap(t[v][szz], t[v][szz - 1]); n         --szz; n       } n       if (rr > byben_size) { n         if (want_mx) n           t[v].erase(t[v].begin()); n         else n           t[v].pop_back(); n       } n     } n     if (~r & 1) { n       int v = r--; n       t[v].push_back(id); n       int szz = t[v].size(); n       int rr = szz; n       --szz; n       while (szz > 0 && t[v][szz] < t[v][szz - 1]) { n         swap(t[v][szz], t[v][szz - 1]); n         --szz; n       } n       if (rr > byben_size) { n         if (want_mx) n           t[v].erase(t[v].begin()); n         else n           t[v].pop_back(); n       } n     } n   } n } n vector<int> get(int v, bool want_mx) { n   vector<int> r; n   v |= sz; n   for (v = v | sz; v; v >>= 1) { n     r = merge(t[v], r, want_mx); n   } n   return r; n } n long double pw[maxT]; n void solve() { n   pw[0] = 1; n   for (int i = 1; i < maxT; ++i) pw[i] = pw[i - 1] * 2; n   int n = getint<int>(); n   for (int i = 1; i <= n; ++i) { n     a[i] = getint<int>(); n   } n   add(0, sz - 1, 0, 1); n   for (int i = 1; i <= n; ++i) { n     add(0, a[i], i, 1); n     l1[i] = get(a[i], 1); n   } n   for (int i = 0; i < 2 * sz; ++i) t[i].clear(); n   add(0, sz - 1, n + 1, 0); n   for (int i = n; i > 0; --i) { n     add(0, a[i], i, 0); n     r1[i] = merge({i}, get(a[i] + 1, 0), 0); n   } n   long double ans = 0; n   for (int i = 1; i <= n; ++i) { n     for (int j = 1; j < l1[i].size(); ++j) { n       for (int k = 0; k + 1 < r1[i].size(); ++k) { n         long long cnt = n             (long long)(l1[i][j] - l1[i][j - 1]) * (r1[i][k + 1] - r1[i][k]); n         int pww = k + l1[i].size() - j; n         if (pww > byben_size) break; n         ans += (long double)cnt / pw[pww] * a[i]; n       } n     } n   } n   cout << fixed << ans / n / n <<   n ; n } n int32_t main() { n   ios_base::sync_with_stdio(0); n   cin.tie(0); n   cout.tie(0); n   cout.precision(20); n   int t = 1; n   while (t--) { n     solve(); n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int max_n = 303333, inf = 1000111222; n int n, x, y; n pair<int, int> a[max_n]; n void wa() { n   printf( No n ); n   exit(0); n } n int main() { n   scanf( %d%d%d , &n, &x, &y); n   for (int i = 0; i < n; ++i) { n     scanf( %d , &a[i].first); n     a[i].second = i + 1; n   } n   sort(a, a + n); n   int last = -1; n   for (int i = n - 1; i >= 0; --i) { n     if (1LL * a[i].first * (n - i) >= y) { n       last = i; n       break; n     } n   } n   if (last == -1) { n     wa(); n   } n   for (int i = 0; i < n; ++i) { n     int need = (x + a[i].first - 1) / a[i].first; n     if (i + need <= last) { n       printf( Yes n ); n       printf( %d %d n , need, n - last); n       for (int j = i; j < i + need; ++j) { n         printf( %d  , a[j].second); n       } n       printf(  n ); n       for (int j = last; j < n; ++j) { n         printf( %d  , a[j].second); n       } n       printf(  n ); n       return 0; n     } n   } n   swap(x, y); n   last = -1; n   for (int i = n - 1; i >= 0; --i) { n     if (1LL * a[i].first * (n - i) >= y) { n       last = i; n       break; n     } n   } n   if (last == -1) { n     wa(); n   } n   for (int i = 0; i < n; ++i) { n     int need = (x + a[i].first - 1) / a[i].first; n     if (i + need <= last) { n       printf( Yes n ); n       printf( %d %d n , n - last, need); n       for (int j = last; j < n; ++j) { n         printf( %d  , a[j].second); n       } n       printf(  n ); n       for (int j = i; j < i + need; ++j) { n         printf( %d  , a[j].second); n       } n       printf(  n ); n       return 0; n     } n   } n   wa(); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n void prime(long long int n, set<long long int> &s) { n   if (n % 2 == 0) { n     s.insert(2); n     n /= 2; n   } n   while (n % 2 == 0) { n     n /= 2; n   } n   for (int i = 3; i <= sqrt(n); i += 2) { n     if (n % i == 0) { n       s.insert(i); n       n /= i; n     } n     while (n % i == 0) { n       n /= i; n     } n   } n   if (n > 2) s.insert(n); n } n int main() { n   long long int n; n   cin >> n; n   set<long long int> s; n   prime(n, s); n   if (s.size() == 1) n     cout << *(s.begin()) << endl; n   else n     cout << 1 << endl; n   return (0); n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n template <typename T> n inline T BigMod(T b, T p, T m) { n   if (p == 0) return 1; n   if (p % 2 == 0) { n     T s = BigMod(b, p / 2, m); n     return ((s % m) * (s % m)) % m; n   } n   return ((b % m) * (BigMod(b, p - 1, m) % m)) % m; n } n template <typename T> n inline T ModInv(T b, T m) { n   return BigMod(b, m - 2, m); n } n template <typename T> n inline T Bigmod(T b, T p, T m) { n   if (p == 0) n     return 1; n   else if (!(p & 1)) n     return (Bigmod(b, p / 2, m) * Bigmod(b, p / 2, m)) % m; n   else n     return ((b % m) * Bigmod(b, p - 1, m)) % m; n } n template <typename T> n inline T gcd(T a, T b) { n   if (b == 0) return a; n   return gcd(b, a % b); n } n template <typename T> n inline T lcm(T a, T b) { n   if (a < 0) return lcm(-a, b); n   if (b < 0) return lcm(a, -b); n   return a * (b / gcd(a, b)); n } n template <typename T> n inline T euclide(T a, T b, T &x, T &y) { n   if (a < 0) { n     T d = euclide(-a, b, x, y); n     x = -x; n     return d; n   } n   if (b < 0) { n     T d = euclide(a, -b, x, y); n     y = -y; n     return d; n   } n   if (b == 0) { n     x = 1; n     y = 0; n     return a; n   } else { n     T d = euclide(b, a % b, x, y); n     T t = x; n     x = y; n     y = t - (a / b) * y; n     return d; n   } n } n template <typename T> n inline T Dis(T x1, T y1, T x2, T y2) { n   return sqrt((((x1 - x2) * (x1 - x2)) + ((y1 - y2) * (y1 - y2)))); n } n template <typename T> n inline T Angle(T x1, T y1, T x2, T y2) { n   return atan(double(y1 - y2) / double(x1 - x2)); n } n template <typename T> n inline T DIFF(T a, T b) { n   T d = a - b; n   if (d < (T)0) n     return -d; n   else n     return d; n } n template <typename T> n inline T ABS(T a) { n   if (a < 0) n     return -a; n   else n     return a; n } n template <typename T> n inline long long isLeft(T a, T b, T c) { n   return (a.x - b.x) * (b.y - c.y) - (b.x - c.x) * (a.y - b.y); n } n template <typename T> n inline void _in(T &x) { n   register int c = getchar(); n   x = 0; n   bool neg = 0; n   for (; ((c<48 | c> 57) && c !=  - ); c = getchar()) n     ; n   if (c ==  - ) { n     neg = 1; n     c = getchar(); n   } n   for (; c > 47 && c < 58; c = getchar()) { n     x = (x << 1) + (x << 3) + c - 48; n   } n   if (neg) x = -x; n } n template <typename T> n inline bool isLeapYear(T N) { n   if (N % 4) n     return 0; n   else if (N % 100) n     return 1; n   else if (N % 400) n     return 0; n   else n     return 1; n } n template <typename T> n inline T Set(T N, T pos) { n   T A = 1; n   return N = N | (A << pos); n } n template <typename T> n inline T Reset(T N, T pos) { n   T A = 1; n   return N = N & ~(A << pos); n } n template <typename T> n inline bool Check(T N, T pos) { n   T A = 1; n   return (bool)(N & (A << pos)); n } n template <class T, class X> n inline T togglebit(T a, X i) { n   T t = 1; n   return (a ^ (t << i)); n } n template <class T, class X> n inline T toInt(T &sm, X s) { n   stringstream ss(s); n   ss >> sm; n   return sm; n } n template <typename T> n inline int cdigittoint(T ch) { n   return ch -  0 ; n } n template <typename T> n inline bool isVowel(T ch) { n   ch = toupper(ch); n   if (ch ==  A  || ch ==  U  || ch ==  I  || ch ==  O  || ch ==  E ) n     return true; n   return false; n } n template <typename T> n inline bool isConst(T ch) { n   if (isalpha(ch) && !isVowel(ch)) return true; n   return false; n } n inline double DEG(double x) { return (180.0 * x) / (2 * acos(0.0)); } n inline double RAD(double x) { return (x * (double)2 * acos(0.0)) / (180.0); } n int main() { n   long long b1 = ({ n     long long a; n     _in(a); n     a; n   }), n             q = ({ n               long long a; n               _in(a); n               a; n             }), n             l = ({ n               long long a; n               _in(a); n               a; n             }), n             m = ({ n               long long a; n               _in(a); n               a; n             }); n   map<long long, bool> A; n   for (long long i = 1; i <= m; i++) n     A[({ n       long long a; n       _in(a); n       a; n     })] = true; n   if (abs(b1) > l) { n     printf( 0 n ); n     return 0; n   } n   if (q == 0 || q == 1 || q == -1) { n     if (q == 0) { n       if (A[b1]) { n         if (A[0] == 0) n           printf( inf n ); n         else n           printf( 0 n ); n       } else { n         if (A[0] == 0) n           printf( inf n ); n         else { n           if (abs(b1) <= l) n             printf( 1 n ); n           else n             printf( 0 n ); n         } n       } n     } else if (q == 1) { n       if (A[b1]) n         printf( 0 n ); n       else { n         if (abs(b1) <= l) n           printf( inf n ); n         else n           printf( 0 n ); n       } n     } else { n       if (A[-b1] == 1 && A[b1] == 1) n         printf( 0 n ); n       else if (A[-b1] == 1 || A[b1] == 1) { n         if (abs(b1) <= l) n           printf( inf n ); n         else n           printf( 0 n ); n       } else { n         if (abs(b1) <= l) n           printf( inf n ); n         else n           printf( 0 n ); n       } n     } n   } else { n     if (b1 == 0) { n       if (A[b1] == 0) n         printf( inf n ); n       else n         printf( 0 n ); n       return 0; n     } n     long long count = 0; n     while (true) { n       if (A[b1] == 0 && abs(b1) <= l) count++; n       b1 *= q; n       if (abs(b1) > l) break; n     } n     printf( %lld n , count); n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n bitset<64> f1[3610], f2[3610]; n int n, m; n map<int, vector<int>> mp1, mp2; n int y[66], y2[66]; n set<int> s; n vector<int> res; n int main() { n   cin >> n >> m; n   for (int i = 1; i <= n; i++) cin >> y[i], y[i] *= 2, mp1[y[i]].push_back(i); n   for (int i = 1; i <= m; i++) n     cin >> y2[i], y2[i] *= 2, mp2[y2[i]].push_back(i); n   for (int i = 1; i <= n; i++) n     for (int j = 1; j <= m; j++) res.push_back((y[i] + y2[j]) / 2); n   sort(res.begin(), res.end()); n   res.erase(unique(res.begin(), res.end()), res.end()); n   for (int i = 0; i < res.size(); i++) { n     int k = res[i]; n     for (int j = 1; j <= m; j++) { n       int d = 2 * k - y2[j]; n       if (mp1[d].size()) n         for (auto xx : mp1[d]) f1[i].set(xx, 1); n     } n   } n   for (int i = 0; i < res.size(); i++) { n     int k = res[i]; n     for (int j = 1; j <= n; j++) { n       int d = 2 * k - y[j]; n       if (mp2[d].size()) n         for (auto xx : mp2[d]) f2[i].set(xx, 1); n     } n   } n   int ans = 0; n   for (int i = 0; i < res.size(); i++) n     for (int j = 0; j < res.size(); j++) { n       int tmp = (f1[i] | f1[j]).count() + (f2[i] | f2[j]).count(); n       ans = max(ans, tmp); n     } n   cout << ans << endl; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int main() { n   int t; n   cin >> t; n   while (t--) { n     long long int n, m, i, j, zero = 0, neg = 0, tot = 0, val = INT_MIN, n                               val2 = INT_MAX; n     cin >> n >> m; n     long long int b[n][m]; n     for (i = 0; i < n; i++) { n       for (j = 0; j < m; j++) { n         cin >> b[i][j]; n         if (b[i][j] < 0) { n           neg++; n           if (neg == 1) n             val = b[i][j]; n           else if (val < b[i][j]) n             val = b[i][j]; n         } else if (b[i][j] == 0) n           zero++; n         else n           val2 = min(val2, b[i][j]); n         tot += abs(b[i][j]); n       } n     } n     if (neg % 2 == 0 || zero != 0) n       cout << tot << endl; n     else { n       cout << tot + 2 * max(val, -val2) << endl; n     } n   } n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int N = 50 + 5; n int n, dp[N][N][N][N]; n char g[N][N]; n int dfs(int x, int y, int h, int w) { n   if (dp[x][y][h][w] != -1) return dp[x][y][h][w]; n   if (h == 1 && w == 1) return dp[x][y][h][w] = g[x][y] ==  # ; n   if (h == 0 || w == 0) return dp[x][y][h][w] = 0; n   dp[x][y][h][w] = max(h, w); n   for (int i = 0; i <= h; ++i) { n     dp[x][y][h][w] = n         min(dp[x][y][h][w], dfs(x, y, i, w) + dfs(x + i, y, h - i, w)); n   } n   for (int j = 0; j <= w; ++j) { n     dp[x][y][h][w] = n         min(dp[x][y][h][w], dfs(x, y, h, j) + dfs(x, y + j, h, w - j)); n   } n   return dp[x][y][h][w]; n } n int main() { n   memset(dp, -1, sizeof(dp)); n   cin >> n; n   for (int i = 1; i <= n; ++i) { n     for (int j = 1; j <= n; ++j) { n       cin >> g[i][j]; n     } n   } n   printf( %d , dfs(1, 1, n, n)); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int maxn = 100010; n const int inf = 0x3f3f3f3f; n int n, m; n int mi[maxn], cnt[maxn]; n int main() { n   cin >> n >> m; n   memset(mi, 0x3f, sizeof(mi)); n   for (int i = 1; i <= m; i++) { n     int x, y; n     cin >> x >> y; n     mi[x] = min(mi[x], (y - x + n) % n); n     cnt[x]++; n   } n   for (int i = 1; i <= n; i++) { n     long long ans = 0; n     for (int j = 1; j <= n; j++) n       if (cnt[j]) n         ans = max(ans, (j - i + n) % n + (long long)n * (cnt[j] - 1) + mi[j]); n     cout << ans <<    ; n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n template <class T> n void pv(T a, T b) { n   for (T i = a; i != b; ++i) cout << *i <<    ; n   cout << endl; n } n template <class T> n void chmin(T &t, const T &f) { n   if (t > f) t = f; n } n template <class T> n void chmax(T &t, const T &f) { n   if (t < f) t = f; n } n int in() { n   int x; n   scanf( %d , &x); n   return x; n } n int N, M; n int X[1000010], Y[1000010]; n int bitN; n int bit[2100010]; n void bitAdd(int pos, int val) { n   for (int x = pos; x <= bitN; x += x & -x) bit[x] += val; n } n int bitLowerBound(int w) { n   if (w <= 0) return 0; n   int x = 0; n   for (int k = bitN; k > 0; k /= 2) { n     if (x + k <= bitN && bit[x + k] < w) { n       w -= bit[x + k]; n       x += k; n     } n   } n   return x + 1; n } n int perm[1000010]; n int ids[2000010]; n bool used[1000010]; n bool solve() { n   for (bitN = 2; bitN < M + N + 5; bitN <<= 1) n     ; n   memset(bit, 0, sizeof(bit)); n   memset(perm, ~0, sizeof(perm)); n   memset(ids, ~0, sizeof(ids)); n   for (int j = 1; j <= N; ++j) { n     bitAdd(M + j, +1); n     ids[M + j] = j; n   } n   for (int i = 0; i < M; ++i) { n     const int pos = bitLowerBound(Y[i]); n     const int j = ids[pos]; n     if (!~perm[j]) { n       perm[j] = X[i]; n     } n     if (perm[j] != X[i]) { n       return false; n     } n     bitAdd(pos, -1); n     bitAdd(M - i, +1); n     ids[pos] = -1; n     ids[M - i] = j; n   } n   memset(used, 0, sizeof(used)); n   for (int j = 1; j <= N; ++j) n     if (~perm[j]) { n       if (used[perm[j]]) { n         return false; n       } n       used[perm[j]] = true; n     } n   int k = 1; n   for (int j = 1; j <= N; ++j) n     if (!~perm[j]) { n       for (; used[k]; ++k) n         ; n       perm[j] = k; n       used[k] = true; n     } n   return true; n } n int main() { n   for (; ~scanf( %d%d , &N, &M);) { n     for (int i = 0; i < M; ++i) { n       X[i] = in(); n       Y[i] = in(); n     } n     bool res = solve(); n     if (res) { n       for (int j = 1; j <= N; ++j) { n         if (j > 1) printf(   ); n         printf( %d , perm[j]); n       } n       puts(  ); n     } else { n       puts( -1 ); n     } n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int MN = 70010; n vector<int> vs[MN]; n int main() { n   ios_base::sync_with_stdio(false); n   cin.tie(0); n   int n; n   cin >> n; n   vector<string> vs(n); n   for (int i = 0; i < n; i++) cin >> vs[i]; n   vector<string> ans(n); n   for (int len = 1; len < 10; len++) { n     map<string, set<int> > mapper; n     for (int i = 0; i < n; i++) n       for (int j = 0; j + len - 1 < 9; j++) n         mapper[vs[i].substr(j, len)].insert(i); n     for (auto &curr : mapper) n       if (((int)curr.second.size()) == 1) { n         int id = *curr.second.begin(); n         if (ans[id] ==   ) ans[id] = curr.first; n       } n   } n   for (int i = 0; i < n; i++) cout << ans[i] <<   n ; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n template <class T> n inline void remax(T& A, T B) { n   if (A < B) A = B; n } n template <class T> n inline void remin(T& A, T B) { n   if (A > B) A = B; n } n string ToString(long long num) { n   string ret; n   do { n     ret += ((num % 10) +  0 ); n     num /= 10; n   } while (num); n   reverse(ret.begin(), ret.end()); n   return ret; n } n long long ToNumber(string s) { n   long long r = 0, p = 1; n   for (int i = s.size() - 1; i >= 0; --i) r += (s[i] -  0 ) * p, p *= 10; n   return r; n } n long long Gcd(long long a, long long b) { n   while (a %= b ^= a ^= b ^= a) n     ; n   return b; n } n long long Power(long long base, long long power) { n   long long ret = 1; n   while (power) { n     if (power & 1) ret *= base; n     power >>= 1; n     base *= base; n   } n   return ret; n } n long long PowerMod(long long base, long long power, long long mod) { n   if (!power) return 1; n   if (power & 1) return (base * PowerMod(base, power - 1, mod)) % mod; n   return PowerMod((base * base) % mod, power >> 1, mod); n } n int Log(long long num, long long base) { n   int ret = 0; n   while (num) { n     ++ret; n     num /= base; n   } n   return ret; n } n int Count(long long mask) { n   int ret = 0; n   while (mask) { n     if (mask & 1) ++ret; n     mask >>= 1; n   } n   return ret; n } n inline void run() { n   int arr[2000]; n   int n, b, ans; n   scanf( %d%d , &n, &b); n   for (int i = 0; i < n;) scanf( %d , arr + i++); n   ans = b; n   for (int i = 0; i < n; ++i) n     for (int j = i + 1; j < n; ++j) n       remax(ans, arr[j] * (b / arr[i]) + b % arr[i]); n   printf( %d n , ans); n } n int main() { n   run(); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n long long exgcd(long long a, long long b, long long &x, long long &y) { n   if (b == 0) { n     x = 1, y = 0; n     return a; n   } n   long long g = exgcd(b, a % b, x, y); n   long long t; n   t = x, x = y, y = t - (a / b) * y; n   return g; n } n int main() { n   long long a, b, c, x, y; n   cin >> a >> b >> c; n   long long t = exgcd(a, b, x, y); n   if (c % t == 0) n     printf( %lld %lld n , -x * c / t, -y * c / t); n   else n     printf( -1 n ); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int MOD = 1e9 + 7; n const int N = 1010; n int dp[N][N][2]; n int bits[N]; n int t, k; n long long dfs(int len, int pos, int num, bool mark) { n   int maxx; n   long long sum; n   if (!len) { n     if (num == 1) { n       return true; n     } else { n       return false; n     } n   } n   if (!mark && dp[len][pos][num] != -1) { n     return dp[len][pos][num]; n   } n   if (mark) { n     maxx = bits[len]; n   } else { n     maxx = 9; n   } n   sum = 0; n   for (int i = 0; i <= maxx; i++) { n     if (i == 4 || i == 7) { n       sum += n           dfs(len - 1, len, (pos && pos - len <= k) | num, mark && i == maxx); n     } else { n       sum += dfs(len - 1, pos, num, mark && i == maxx); n     } n   } n   sum %= MOD; n   if (!mark) { n     dp[len][pos][num] = sum; n   } n   return sum; n } n long long f(string s) { n   int len; n   len = 0; n   for (int i = s.size() - 1; i >= 0; i--) { n     len++; n     bits[len] = s[i] -  0 ; n   } n   return dfs(len, 0, 0, 1); n } n bool check(string &s) { n   int p; n   p = 0; n   for (int i = 1; i <= s.size(); i++) { n     if (s[i - 1] ==  4  || s[i - 1] ==  7 ) { n       if (!p || i - p > k) { n         p = i; n       } else if (i - p <= k) { n         return true; n       } n     } n   } n   return false; n } n int main() { n   string l, r; n   long long ans; n   while (scanf( %d%d , &t, &k) == 2) { n     memset(dp, -1, sizeof(dp)); n     for (int i = 0; i < t; i++) { n       cin >> l >> r; n       ans = f(r) - f(l) + (check(l) ? 1 : 0); n       printf( %lld n , (ans % MOD + MOD) % MOD); n     } n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int vis[200005][3], n; n long long dp[200005][3], a[200005]; n long long dfs(int x, int s) { n   if (dp[x][s]) return dp[x][s]; n   if (vis[x][s]) return -1; n   vis[x][s] = 1; n   int k; n   if (s) n     k = x + a[x]; n   else n     k = x - a[x]; n   if (k <= 0 || k > n) n     dp[x][s] += a[x]; n   else { n     dp[x][s] = dfs(k, s ^ 1); n     if (dp[x][s] != -1) dp[x][s] += a[x]; n   } n   return dp[x][s]; n } n int main() { n   while (scanf( %d , &n) != EOF) { n     memset(vis, 0, sizeof(vis)); n     memset(dp, 0, sizeof(dp)); n     for (int i = 2; i <= n; i++) scanf( %I64d , &a[i]); n     for (int i = 2; i <= n; i++) dfs(i, 0); n     for (int i = 1; i < n; i++) { n       if (dp[i + 1][0] == -1) n         printf( -1 n ); n       else n         printf( %I64d n , i + dp[i + 1][0]); n     } n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n double PI = acos(-1.0); n long long mod = 998244353; n struct custom_hash { n   static uint64_t splitmix64(uint64_t x) { n     x += 0x9e3779b97f4a7c15; n     x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9; n     x = (x ^ (x >> 27)) * 0x94d049bb133111eb; n     return x ^ (x >> 31); n   } n   size_t operator()(uint64_t x) const { n     static const uint64_t FIXED_RANDOM = n         chrono::steady_clock::now().time_since_epoch().count(); n     return splitmix64(x + FIXED_RANDOM); n   } n }; n long long GCD(long long a, long long b) { n   if (b == 0) return a; n   return GCD(b, a % b); n } n long long prod(long long a, long long b) { n   long long res = 0; n   a %= mod; n   while (b) { n     if (b & 1ll) res = (res + a) % mod; n     a = (2ll * a) % mod; n     b >>= 1ll; n   } n   return res; n } n long long power(long long a, long long b) { n   long long res = 1ll; n   while (b > 0) { n     if (b % 2ll) res = (res * a) % mod; n     a = (a * a) % mod; n     b /= 2ll; n   } n   return res; n } n long long binaryExponentiation(long long a, long long b) { n   long long result = 1ll; n   while (b > 0) { n     if (b % 2 == 1) result = (result * a) % mod; n     a = (a * a) % mod; n     b /= 2ll; n   } n   return result; n } n long long ModularInverse(long long a) { n   return binaryExponentiation(a, mod - 2); n } n long long n, m; n void solve() { n   cin >> n; n   vector<long long> a(n); n   for (long long i = 0; i < n; i++) { n     cin >> a[i]; n   } n   for (long long i = 0; i < n; i++) { n     if (a[i] >= 0) { n       a[i] = -a[i] - 1; n     } n   } n   long long x = INT_MAX, p = 0; n   for (long long i = 0; i < n; i++) { n     if (a[i] < x) { n       x = a[i]; n       p = i; n     } n   } n   if (n % 2) { n     a[p] = -a[p] - 1; n   } n   for (auto &e : a) { n     cout << e <<    ; n   } n   cout <<   n ; n } n signed main() { n   ios_base::sync_with_stdio(false); n   cin.tie(NULL); n   long long t = 1; n   while (t--) { n     solve(); n   } n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n #define inp_out_work ios::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL); n #define testCase    int T; cin>>T; while(T--) n #define debug(P) cout<<#P<<   <<P<<endl n #define endl   n  n   n using namespace std; n   n typedef long long ll; n   n int main() { n   testCase { n    int n; n    cin>>n; n    string s; n    cin>>s; n   n    bool poss = true; n   n    int t = 0; n   n    for(char x : s) { n     if(x ==  T )++t; n    } n   n    if(2*(n-t) != t) { n     poss = false; n    } n   n    t = 0; n   n    for(int i = 0; i < n; ++i) { n     if(s[i] ==  T ) ++t; n     else { n      --t; n      if(t < 0) { n       poss = false; n       break; n      } n     } n    } n     n    t = 0; n   n    for(int i = n-1; i >= 0; --i) { n     if(s[i] ==  T ) ++t; n     else { n      --t; n      if(t < 0) { n       poss = false; n       break; n      } n     } n    } n   n    if(poss) { n     cout<<  YES n ; n    } else { n     cout<<  NO n ; n    } n   n   } n }"}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int main() { n   int n; n   cin >> n; n   if (n % 2 == 0) n     cout << (n * n) / 2 << endl; n   else n     cout << (n / 2) * (n / 2) + (n / 2 + 1) * (n / 2 + 1) << endl; n   for (int i = 1; i <= n; i++) { n     for (int j = 1; j <= n; j++) n       if ((i + j) % 2 == 0) n         cout <<  C ; n       else n         cout <<  . ; n     cout << endl; n   } n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int N = (int)2e6 + 10; n vector<int> a[N]; n vector<int> pos[N]; n string ans; n int n; n string s[N]; n int m; n vector<int> cur; n int cnt[N]; n int main() { n   ios_base::sync_with_stdio(false); n   cin.tie(0); n   memset(cnt, 0, sizeof(cnt)); n   m = 0; n   cin >> n; n   for (int i = 1; i <= n; i++) { n     cin >> s[i]; n     int len = s[i].length(); n     int k; n     cin >> k; n     while (k--) { n       int p; n       cin >> p; n       p--; n       m = max(m, p + len); n       a[p].push_back(i); n       a[p + len].push_back(-i); n       pos[i].push_back(p); n     } n   } n   ans.resize(m); n   for (int i = 0; i < m; i++) { n     for (int x : a[i]) { n       if (x > 0) { n         cur.push_back(x); n         cnt[x]++; n       } else { n         cnt[-x]--; n       } n     } n     while (!cur.empty() && cnt[cur.back()] == 0) cur.pop_back(); n     if (cur.empty()) n       ans[i] =  a ; n     else { n       int id = cur.back(); n       auto it = upper_bound(pos[id].begin(), pos[id].end(), i); n       it--; n       int p = *it; n       if (i - p >= (int)s[id].length()) continue; n       ans[i] = s[id][i - p]; n     } n   } n   cout << ans << endl; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int main() { n   int a, b, c; n   while (cin >> a >> b >> c) { n     long long l = 0, r = 100000000; n     while (l <= r) { n       long long t = (l + r) / 2; n       long long w = b * t; n       long long d = b * t; n       bool ok = true; n       while (d < a * c) { n         if (w < a) { n           ok = false; n           break; n         } n         w -= a; n         w += b; n         d += b; n       } n       if (ok) n         r = t - 1; n       else n         l = t + 1; n     } n     cout << l - 1 << endl; n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n inline int read() { n   int x = 0; n   char ch = getchar(); n   while (ch <  0  || ch >  9 ) ch = getchar(); n   while (ch >=  0  && ch <=  9 ) x = x * 10 + ch -  0 , ch = getchar(); n   return x; n } n vector<pair<int, int> > v[1000000 + 5]; n int s[1000000 / 5], num = 0, last[1000000 + 5], vis[1000000 + 5], n                     la[1000000 + 5], lastans = 0, n, q, mx, a[1000000 + 5], n                     rt[1000000 + 5], cnt = 0, inv[1000000 + 5], n                     Ans[1000000 + 5]; n struct Tree { n   int l, r, x; n } T[1000000 * 4 + 5]; n bool b[1000000 + 5]; n int Build(int l, int r) { n   int x = ++cnt; n   T[x].x = 1; n   if (l != r) { n     int mid = l + r >> 1; n     T[x].l = Build(l, mid); n     T[x].r = Build(mid + 1, r); n   } n   return x; n } n void Modify(int x, int l, int r, int lt, int rt, int v) { n   if (l == lt && r == rt) { n     T[x].x = 1LL * T[x].x * v % 1000000007; n     return; n   } n   int mid = lt + rt >> 1; n   if (r <= mid) n     Modify(T[x].l, l, r, lt, mid, v); n   else if (l > mid) n     Modify(T[x].r, l, r, mid + 1, rt, v); n   else n     Modify(T[x].l, l, mid, lt, mid, v), n         Modify(T[x].r, mid + 1, r, mid + 1, rt, v); n } n void Query(int x, int k, int lt, int rt) { n   lastans = 1LL * lastans * T[x].x % 1000000007; n   if (lt == rt) return; n   int mid = lt + rt >> 1; n   if (k <= mid) n     Query(T[x].l, k, lt, mid); n   else n     Query(T[x].r, k, mid + 1, rt); n } n int main() { n   n = read(); n   inv[0] = inv[1] = 1; n   for (int i = 1; i <= n; ++i) mx = max(mx, a[i] = read()); n   q = read(); n   for (register int i = 2; i <= mx; ++i) { n     inv[i] = n         1LL * (1000000007 - 1000000007 / i) * inv[1000000007 % i] % 1000000007; n     if (!b[i]) s[++num] = i, last[i] = i; n     for (int j = 1; s[j] * i <= mx; ++j) { n       b[s[j] * i] = 1; n       last[s[j] * i] = s[j]; n       if (i % s[j] == 0) break; n     } n   } n   rt[0] = Build(1, n); n   for (int i = 1; i <= q; ++i) { n     int l = read(), r = read(); n     v[r].push_back(make_pair(l, i)); n   } n   for (register int i = 1; i <= n; ++i) { n     Modify(rt[i] = rt[i - 1], 1, i, 1, n, a[i]); n     for (int t = a[i]; t > 1; t /= last[t]) n       if (vis[last[t]] != i) { n         vis[last[t]] = i; n         Modify(rt[i], la[last[t]] + 1, i, 1, n, n                1LL * inv[last[t]] * (last[t] - 1) % 1000000007); n         la[last[t]] = i; n       } n     for (int j = 0; j < v[i].size(); ++j) n       lastans = 1, Query(rt[i], v[i][j].first, 1, n), n       Ans[v[i][j].second] = lastans; n   } n   for (int i = 1; i <= q; ++i) printf( %d n , Ans[i]); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n using LL = long long; n const LL MOD = 998244353; n string s; n LL cal(int x) { n   if (x < 10 || x > 18) return 0; n   return 9 - (x - 10); n } n struct SegmentTree { n   struct Node { n     int L, R, l, r; n     LL v[2][2]; n   }; n   vector<Node> N; n   int p; n   vector<int> rt; n   int n; n   inline void init(int _n) { n     n = _n; n     N.resize(n * 4); n     p = 1; n     rt.clear(); n     rt.push_back(build(0, n)); n   } n   inline int copy(Node u) { return N[p] = u, p++; } n   int build(int L, int R) { n     int u = copy({L, R}), M = (L + R) >> 1; n     ; n     if (R - L == 1) n       return N[u].v[0][0] = s[L] -  0  + 1, N[u].v[0][1] = 1, N[u].v[1][0] = 1, n              N[u].v[1][1] = 0, u; n     return pull(u, build(L, M), build(M, R)); n   } n   inline int push(int u) { return u; } n   inline int pull(int u, int l, int r) { n     if (!l || !r) return l ? l : r; n     push(N[u].l = l); n     push(N[u].r = r); n     for (int i = 0; i < 2; i++) { n       for (int j = 0; j < 2; j++) { n         N[u].v[i][j] = n             (N[l].v[i][0] * N[r].v[0][j] + n              N[l].v[i][1] * N[r].v[1][j] % MOD * n                  cal((s[N[l].R - 1] -  0 ) * 10 + (s[N[r].L] -  0 ))) % n             MOD; n       } n     } n     return u; n   } n   int m(int L, int R, int u, int v) { n     if (!u || R <= N[u].L || N[u].R <= L) return u; n     push(u); n     if (L <= N[u].L && N[u].R <= R) return N[u].v[0][0] = v + 1, u; n     return pull(u, m(L, R, N[u].l, v), m(L, R, N[u].r, v)); n   } n   int q(int L, int R, int u) { n     if (!u || R <= N[u].L || N[u].R <= L) return 0; n     if (L <= N[u].L && N[u].R <= R) return u; n     push(u); n     return pull(copy(N[u]), q(L, R, N[u].l), q(L, R, N[u].r)); n   } n   inline void modify(int L, int R, int ver, int v) { n     rt[ver] = m(L, R, rt[ver], v); n   } n   inline Node& query(int L, int R, int ver) { n     p = 2 * n + 1; n     return N[q(L, R, rt[ver])]; n   } n } solver; n int main() { n   ios_base::sync_with_stdio(false); n   cin.tie(0); n   int n, q; n   cin >> n >> q; n   cin >> s; n   solver.init(n); n   while (q--) { n     int x, d; n     cin >> x >> d; n     x--; n     s[x] =  0  + d; n     solver.modify(x, x + 1, 0, d); n     auto v = solver.query(0, n, 0).v; n     cout << v[0][0] <<   n ; n   } n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n vector<int> av; n int main() { n   int n; n   scanf( %d , &n); n   for (int i = max(1, n - 100); i <= n; i++) { n     int j = i, ans = i; n     while (j) { n       ans += j % 10; n       j /= 10; n     } n     if (ans == n) av.push_back(i); n   } n   int avs = av.size(); n   printf( %d n , avs); n   for (int i = 0; i < avs; i++) { n     printf( %d n , av[i]); n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n #pragma GCC optimize( O3 ) n #pragma GCC optimize( Ofast ) n using namespace std; n long long int n, res[200005], cnt = 0, ans[200005]; n vector<long long int> g[200005]; n vector<long long int> v[200005]; n map<long long int, long long int> c; n queue<long long int> q; n void dfs1(long long int node, long long int color) { n   c[node] = color; n   for (auto it : g[node]) { n     if (!c[it]) { n       dfs1(it, color % 2 + 1); n     } n   } n } n void dfs2(long long int node, long long int p) { n   for (auto it : g[node]) { n     if (it != p) { n       dfs2(it, node); n     } n   } n   for (auto it : g[node]) { n     if (c[it] != c[node] && res[it] == 0 && res[node] == 0) { n       cnt++; n       res[it] = cnt; n       res[node] = cnt; n       q.push(it); n       q.push(node); n     } n   } n } n int32_t main() { n   ios_base::sync_with_stdio(false); n   cin.tie(0); n   cout.tie(0); n   ; n   cin >> n; n   for (long long int i = 1; i < n; i++) { n     long long int x, y; n     cin >> x >> y; n     g[x].push_back(y); n     g[y].push_back(x); n   } n   dfs1(1, 1); n   dfs2(1, 1); n   while (!q.empty()) { n     long long int x = q.front(); n     q.pop(); n     for (auto it : g[x]) { n       if (res[it] == 0) { n         res[it] = res[x]; n         q.push(it); n       } n     } n   } n   for (long long int i = 1; i <= n; i++) { n     v[res[i]].push_back(i); n   } n   long long int mn = 0; n   for (long long int i = 1; i <= cnt; i++) { n     mn += (v[i].size() - 1) * 2; n     for (long long int j = 0; j < v[i].size(); j++) { n       ans[v[i][j]] = v[i][(j + 1) % v[i].size()]; n     } n   } n   cout << mn <<   n ; n   for (long long int i = 1; i <= n; i++) { n     cout << ans[i] <<    ; n   } n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int block_size = 320; n const long long mod = 1e9 + 7; n const long long inf = 1e9 + 7; n const long double eps = 1e-9; n const double PI = atan(1) * 4; n template <typename T> n inline int sign(const T &a) { n   if (a < 0) return -1; n   if (a > 0) return 1; n   return 0; n } n string to_string(string s) { return     + s +    ; } n string to_string(const char *s) { return to_string((string)s); } n string to_string(bool b) { return (b ?  true  :  false ); } n template <typename A, typename B> n string to_string(pair<A, B> p) { n   return  (  + to_string(p.first) +  ,   + to_string(p.second) +  ) ; n } n template <typename A> n string to_string(A v) { n   bool first = true; n   string res =  { ; n   for (const auto &x : v) { n     if (!first) { n       res +=  ,  ; n     } n     first = false; n     res += to_string(x); n   } n   res +=  } ; n   return res; n } n void debug_out() { cerr << endl; } n template <typename Head, typename... Tail> n void debug_out(Head H, Tail... T) { n   cerr <<     << to_string(H); n   debug_out(T...); n } n template <typename T, typename S> n inline bool upmin(T &a, const S &b) { n   return a > b ? a = b, 1 : 0; n } n template <typename T, typename S> n inline bool upmax(T &a, const S &b) { n   return a < b ? a = b, 1 : 0; n } n template <typename T> n inline void in(T &x) { n   x = 0; n   T f = 1; n   char ch = getchar(); n   while (!isdigit(ch)) { n     if (ch ==  - ) f = -1; n     ch = getchar(); n   } n   while (isdigit(ch)) { n     x = x * 10 + ch -  0 ; n     ch = getchar(); n   } n   x *= f; n } n long long twop(int x) { return 1LL << x; } n template <typename A, typename B> n inline void in(A &x, B &y) { n   in(x); n   in(y); n } n template <typename A, typename B, typename C> n inline void in(A &x, B &y, C &z) { n   in(x); n   in(y); n   in(z); n } n template <typename A, typename B, typename C, typename D> n inline void in(A &x, B &y, C &z, D &d) { n   in(x); n   in(y); n   in(z); n   in(d); n } n long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); } n namespace SOLVE { n int n, q; n string s; n int nxt[100010][26]; n int dp[255][255][255]; n vector<int> word[3]; n void solve(int i, int j, int k) { n   dp[i][j][k] = inf; n   if (i and dp[i - 1][j][k] <= n) n     upmin(dp[i][j][k], nxt[dp[i - 1][j][k]][word[0][i]]); n   if (j and dp[i][j - 1][k] <= n) n     upmin(dp[i][j][k], nxt[dp[i][j - 1][k]][word[1][j]]); n   if (k and dp[i][j][k - 1] <= n) n     upmin(dp[i][j][k], nxt[dp[i][j][k - 1]][word[2][k]]); n } n void main() { n   cin >> n >> q >> s; n   for (long long i = 0; i < n; i++) s[i] -=  a ; n   s =     + s; n   for (long long i = 0; i < 26; i++) nxt[n][i] = inf; n   for (long long i = n - 1; i >= 0; i--) { n     for (long long j = 0; j < 26; j++) nxt[i][j] = nxt[i + 1][j]; n     nxt[i][s[i + 1]] = i + 1; n   } n   for (long long i = 0; i < 3; i++) word[i].push_back(0); n   dp[0][0][0] = 0; n   while (q--) { n     string op; n     cin >> op; n     int id; n     cin >> id; n     id--; n     if (op ==  + ) { n       string sss; n       cin >> sss; n       int ch = sss[0] -  a ; n       word[id].push_back(ch); n       if (id == 0) { n         for (long long b = 0; b < ((int)word[1].size()); b++) { n           for (long long c = 0; c < ((int)word[2].size()); c++) { n             solve(((int)word[0].size()) - 1, b, c); n           } n         } n       } n       if (id == 1) { n         for (long long b = 0; b < ((int)word[0].size()); b++) { n           for (long long c = 0; c < ((int)word[2].size()); c++) { n             solve(b, ((int)word[1].size()) - 1, c); n           } n         } n       } n       if (id == 2) { n         for (long long b = 0; b < ((int)word[0].size()); b++) { n           for (long long c = 0; c < ((int)word[1].size()); c++) { n             solve(b, c, ((int)word[2].size()) - 1); n           } n         } n       } n     } else { n       word[id].pop_back(); n     } n     cout << ((dp[((int)word[0].size()) - 1][((int)word[1].size()) - 1] n                 [((int)word[2].size()) - 1] <= n) n                  ?  YES  n                  :  NO ) n          << endl; n   } n } n }  // namespace SOLVE n signed main() { n   int t; n   t = 1; n   while (t--) { n     SOLVE::main(); n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int main() { n   long long int t; n   cin >> t; n   while (t--) { n     long long int n; n     cin >> n; n     long long int a[n]; n     long long int sum = 0; n     for (int i = 0; i < n; i++) { n       cin >> a[i]; n       if (!(i & 1)) sum += a[i]; n     } n     long long int best = 0; n     long long int cur = 0; n     long long int z, z1; n     if (n & 1) n       z = n - 1; n     else n       z = n; n     for (int i = 0; i < z; i += 2) { n       cur = max(0ll, cur + a[i + 1] - a[i]); n       best = max(cur, best); n     } n     cur = 0; n     if (!(n & 1)) n       z1 = n - 1; n     else n       z1 = n; n     for (int i = 1; i < z1; i += 2) { n       cur = max(0ll, cur + a[i] - a[i + 1]); n       best = max(cur, best); n     } n     cout << sum + best << endl; n   } n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int MAXN = 35000 + 10; n const int MAXK = 55; n int tree[MAXN << 2], info[MAXN << 2]; n int dp[MAXK][MAXN]; n int nums[MAXN]; n int pre[MAXN], cur[MAXN]; n void build(int node, int start, int end, int i) { n   if (start == end) { n     tree[node] = dp[i][start - 1]; n     info[node] = 0; n     return; n   } n   int mid = (start + end) >> 1; n   build((node << 1), start, mid, i); n   build(((node << 1) | 1), mid + 1, end, i); n   tree[node] = max(tree[(node << 1)], tree[((node << 1) | 1)]); n   info[node] = 0; n } n void update(int node, int start, int end, int i, int j, int val) { n   if (end < i || j < start) return; n   if (i <= start && end <= j) { n     tree[node] += val; n     info[node] += val; n     return; n   } n   int mid = (start + end) >> 1; n   if (info[node] != 0) { n     update((node << 1), start, mid, start, mid, info[node]); n     update(((node << 1) | 1), mid + 1, end, mid + 1, end, info[node]); n     info[node] = 0; n   } n   update((node << 1), start, mid, i, j, val); n   update(((node << 1) | 1), mid + 1, end, i, j, val); n   tree[node] = max(tree[(node << 1)], tree[((node << 1) | 1)]); n } n int query(int node, int start, int end, int i, int j) { n   if (end < i || j < start) return INT_MIN; n   if (i <= start && end <= j) { n     return tree[node]; n   } n   int mid = (start + end) >> 1; n   if (info[node] != 0) { n     update((node << 1), start, mid, start, mid, info[node]); n     update(((node << 1) | 1), mid + 1, end, mid + 1, end, info[node]); n     info[node] = 0; n   } n   return max(query((node << 1), start, mid, i, j), n              query(((node << 1) | 1), mid + 1, end, i, j)); n } n int main() { n   int n, k; n   cin >> n >> k; n   for (int i = 1; i <= n; i++) { n     scanf( %d , &nums[i]); n     pre[i] = cur[nums[i]]; n     cur[nums[i]] = i; n   } n   for (int i = 1; i <= k; i++) { n     build(1, 1, n, i - 1); n     for (int j = i; j <= n; j++) { n       update(1, 1, n, pre[j] + 1, j, 1); n       dp[i][j] = query(1, 1, n, 1, j); n     } n   } n   cout << dp[k][n] << endl; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n typedef struct { n   int x; n   int y; n   long long z; n   long long o; n } H; n long long b, g, i, j, k, sz, t, p[200040], w[200040]; n int pv[200040]; n H e[400005]; n int C(H a, H b) { return a.x < b.x; } n void BP(void); n void S(void); n long long dfs(int v); n int main() { n   ios_base::sync_with_stdio(false); n   cin.tie(NULL); n   cout.tie(NULL); n   for (cin >> t; t--;) { n     S(); n     BP(); n     k++; n     for (i = 0; i++ < k;) { n       if (w[i] < 2 && !p[e[pv[i]].y]) { n         dfs(pv[i]); n         p[e[pv[i]].y] = 1; n       } n     } n     for (b = g = i = 0; i < sz; i++) { n       if (!e[i].o) { n         if (w[e[i].y] < 2) n           e[i].o = 1; n         else n           e[i].o = k - 1; n       } n       if (e[i].o * 2 < k || e[i].o * 2 == k && e[i].x < e[i].y) { n         g += e[i].o % 2 * e[i].z; n         b += e[i].o * e[i].z; n       } n     } n     cout << g <<     << b <<   n ; n     for (i = 0; i++ < k + 1;) p[i] = pv[i] = w[i] = 0; n     for (i = 0; i < sz + 1; i++) e[i].o = 0; n   } n } n void BP(void) { n   for (int i = 0; ++i < sz;) { n     if (e[i].x > e[i - 1].x) { n       for (int j = e[i - 1].x; j++ < e[i].x;) { n         pv[j] = i; n       } n     } n   } n   for (int j = e[sz - 1].x; j++ < k + 2;) pv[j] = sz; n } n void S(void) { n   cin >> k; n   k = 2 * k - 1; n   for (int i = 0; i < k; i++) { n     cin >> e[i].x >> e[i].y >> e[i].z; n     e[i + k].x = e[i].y; n     e[i + k].y = e[i].x; n     e[i + k].z = e[i].z; n     w[e[i].x]++; n     w[e[i].y]++; n   } n   sz = 2 * k; n   sort(e, e + sz, C); n } n long long dfs(int v) { n   long long s = 0; n   if (e[v].o) return e[v].o; n   for (int i = pv[e[v].y]; i < pv[e[v].y + 1]; i++) { n     if (e[i].y != e[v].x) s += dfs(i); n   } n   return e[v].o = s + 1; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int main() { n   int a, b; n   cin >> a >> b; n   if ((a >= 0 && b < 0) || (a < 0 && b >= 0)) { n     cout <<  -1 ; n     return 0; n   } n   if (a == 0 && b == 0) { n     cout <<  -1 ; n     return 0; n   } n   if (a < 0 && b < 0) { n     cout <<  -1 ; n     return 0; n   } n   if (b == 0 && a > 0) { n     cout <<  -1 ; n     return 0; n   } n   if (a == b) { n     cout << a; n     return 0; n   } n   if (a > 0 && b > 0) { n     if (b > a) { n       cout <<  -1 ; n       return 0; n     } else { n       int k1 = (a - b) / (2 * b); n       double x1 = (double)(a - b) / (2 * k1); n       int k2 = (a + b) / (2 * b); n       double x2 = (double)(a + b) / (2 * k2); n       cout << setprecision(10) << min(x1, x2); n     } n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int main() { n   int fr[301][301]; n   int al[301]; n   int i, j, n; n   cin >> n; n   for (i = 1; i <= n; ++i) n     for (j = 1; j <= n; ++j) cin >> fr[i][j]; n   for (i = 1; i <= n; ++i) cin >> al[i]; n   int k, best[301], best_time[301], cur; n   for (j = 1; j <= n; ++j) { n     best[j] = 301; n     best_time[j] = 301; n     for (i = 1; i <= n; ++i) { n       if (j == 1 && i == 1) continue; n       for (k = 1; k <= n; ++k) n         if (al[k] <= i && al[k] != j) { n           cur = al[k]; n           break; n         } n       for (k = 1; k <= n; ++k) { n         if (cur == fr[j][k]) { n           if (k < best[j]) { n             best[j] = k; n             best_time[j] = i; n           } n           break; n         } n       } n     } n   } n   for (i = 1; i <= n; ++i) cout << best_time[i] <<   t ; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int main() { n   int n; n   cin >> n; n   int x = 0, xi = INT_MIN, q = 0; n   vector<int> v; n   for (int i = 0; i < n; i++) { n     int y; n     cin >> y; n     q = x; n     v.push_back(y); n     xi = max(x, v[i]); n     if (x != q) x = i; n   } n   long long ans = 0; n   for (int i = 0; i < n; i++) { n     int z = (abs(x - i) + i + x) * 2; n     ans += (z * v[i]); n   } n   cout << ans; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n inline int min(int _a, int _b) { return _a < _b ? _a : _b; } n inline int max(int _a, int _b) { return _a > _b ? _a : _b; } n template <class _T> n inline void rd(_T &_a) { n   int _f = 0, _ch = getchar(); n   _a = 0; n   while (_ch <  0  || _ch >  9 ) { n     if (_ch ==  - ) _f = 1; n     _ch = getchar(); n   } n   while (_ch >=  0  && _ch <=  9 ) _a = _a * 10 + _ch -  0 , _ch = getchar(); n   if (_f) _a = -_a; n } n const int inf = 0x3f3f3f3f; n const double eps = 1e-8; n const int mod = 1e9 + 7, N = 15; n int mp[N][N], f[N][N], ct[N], n, m, k, ans; n void dfs(int x, int y) { n   if (y > m) x++, y = 1; n   if (x > n) { n     ans++; n     ans %= mod; n     return; n   } n   int st = f[x - 1][y] | f[x][y - 1], pre, d = -1; n   if (n + m - x - y + 1 > k - __builtin_popcount(st)) return; n   for (int i = 1; i <= k; i++) n     if (!(st >> i - 1 & 1) && (!mp[x][y] || mp[x][y] == i)) { n       f[x][y] = st | (1 << i - 1); n       ct[i]++; n       if (ct[i] == 1) { n         if (~d) n           ans += d; n         else { n           pre = ans; n           dfs(x, y + 1); n           d = ans - pre; n         } n       } else n         dfs(x, y + 1); n       ans %= mod; n       ct[i]--; n     } n } n int main() { n   rd(n); n   rd(m); n   rd(k); n   if (n + m - 1 > k) return puts( 0 ), 0; n   for (int i = 1; i <= n; i++) n     for (int j = 1; j <= m; j++) { n       rd(mp[i][j]); n       if (mp[i][j]) ct[mp[i][j]]++; n     } n   dfs(1, 1); n   printf( %d , ans); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int a, b, n, m; n int A[100010], B[100010], L[100010]; n double dis(int a, int b, int c, int d) { n   return sqrt( n       double((a - c + 0.0) * (a - c + 0.0) + (b - d + 0.0) * (b - d + 0.0))); n } n double getK(int y) { return 1.0 * y * a / (b * 1.0); } n int find(double xx) { n   int x = xx; n   return upper_bound(A, A + n, x) - A; n } n int main() { n   int ll, rr, id; n   double ans = 0, tmp; n   scanf( %d%d%d%d , &n, &m, &a, &b); n   for (int i = 0; i < n; i++) scanf( %d , A + i); n   for (int i = 0; i < m; i++) scanf( %d , B + i); n   for (int i = 0; i < m; i++) scanf( %d , L + i); n   ll = rr = 0; n   ans = dis(0, 0, a, A[0]) + dis(a, A[0], b, B[0]) + L[0]; n   for (int i = 0; i < m; i++) { n     double k = getK(B[i]); n     id = find(k); n     id = max(0, id - 2); n     for (int j = id; j < n && j <= id + 4; j++) { n       tmp = dis(0, 0, a, A[j]) + dis(a, A[j], b, B[i]) + 1.0 * L[i]; n       if (tmp < ans) ans = tmp, ll = j, rr = i; n     } n   } n   printf( %d %d n , ll + 1, rr + 1); n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n long long int base(long long int n, long long int k) { n   string res =   ; n   long long int temp = 0, i; n   while (n >= k) { n     res += to_string(n % k); n     n /= k; n   } n   res += to_string(n); n   reverse(res.begin(), res.end()); n   for (i = 0; i < res.length(); i++) { n     temp = temp * 10 + (res[i] -  0 ); n   } n   return temp; n } n int main() { n   long long int n, i, j, flag = 0; n   cin >> n; n   flag = 9; n   for (i = 1; i <= n - 1; i++) { n     for (j = 1; j <= n - 1; j++) { n       cout << base(i * j, n) <<    ; n     } n     cout << endl; n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int MAXM = 2e5 + 3, MAXN = 2e5 + 3, MAXQ = 2e5 + 3, MAXC = 2e5 + 3, n           ADD = 1 << 18; n int n, m, q; n int edge_from[MAXM << 1], edge_to[MAXM << 1], edge_nex[MAXM << 1]; n int cntm = 1, head[MAXN]; n void link(int from, int to) { n   edge_from[++cntm] = from; n   edge_to[cntm] = to; n   edge_nex[cntm] = head[from]; n   head[from] = cntm; n } n bool isb[MAXM << 1]; n int edge1_to[MAXC << 1], edge1_nex[MAXC << 1]; n int cntm1 = 0, head1[MAXC]; n void link1(int from, int to) { n   edge1_to[++cntm1] = to; n   edge1_nex[cntm1] = head1[from]; n   head1[from] = cntm1; n } n int dfn[MAXN], low[MAXN], cntd = 0; n void tarjan(int now, int fa) { n   low[now] = dfn[now] = ++cntd; n   for (int i = head[now]; i; i = edge_nex[i]) { n     if ((i ^ 1) == fa) continue; n     if (!dfn[edge_to[i]]) { n       tarjan(edge_to[i], i); n       if (low[edge_to[i]] > low[now]) { n         isb[i] = isb[i ^ 1] = 1; n       } else { n         low[now] = low[edge_to[i]]; n       } n     } else { n       low[now] = min(low[now], low[edge_to[i]]); n     } n   } n } n int col[MAXN], cntc = 0, Fa[MAXC][23], Deep[MAXC], cntd1 = 0; n void dfs(int now) { n   col[now] = cntc; n   for (int i = head[now]; i; i = edge_nex[i]) n     if (!col[edge_to[i]] && !isb[i]) dfs(edge_to[i]); n } n void dfs2(int now) { n   for (int i = head1[now]; i; i = edge1_nex[i]) { n     if (!Deep[edge1_to[i]] && edge1_to[i] != Fa[now][0]) { n       Fa[edge1_to[i]][0] = now; n       Deep[edge1_to[i]] = Deep[now] + 1; n       dfs2(edge1_to[i]); n     } n   } n } n long long val1[MAXN]; n long long sum1; n bool Arr[MAXN]; n int ans = 1; n void dfs3(int now) { n   if (!ans) return; n   Arr[now] = 1; n   long long in1 = sum1; n   sum1 += val1[now]; n   for (int i = head1[now]; i; i = edge1_nex[i]) n     if (!Arr[edge1_to[i]] && ans) dfs3(edge1_to[i]); n   in1 = sum1 - in1; n   if ((in1 >> 18) && in1 - ((in1 >> 18) << 18)) ans = 0; n } n inline int lca(register int A, register int B) { n   if (Deep[A] < Deep[B]) swap(A, B); n   for (int i = 17; i >= 0; i--) { n     if (Deep[Fa[A][i]] >= Deep[B]) A = Fa[A][i]; n   } n   if (A == B) return A; n   for (int i = 17; i >= 0; i--) { n     if (Fa[A][i] != Fa[B][i]) { n       A = Fa[A][i]; n       B = Fa[B][i]; n     } n   } n   if (Fa[A][0] == Fa[B][0] && Fa[A][0] != 0) return Fa[A][0]; n   return -1; n } n int main() { n   ios::sync_with_stdio(false); n   cin >> n >> m >> q; n   for (int i = 1, U, V; i <= m; i++) { n     cin >> U >> V; n     link(U, V); n     link(V, U); n   } n   for (int i = 1; i <= n; i++) n     if (!dfn[i]) tarjan(i, 0); n   for (int i = 1; i <= n; i++) n     if (!col[i]) { n       cntc++; n       dfs(i); n     } n   for (int i = 2; i <= cntm; i++) n     if (isb[i]) link1(col[edge_from[i]], col[edge_to[i]]); n   for (int i = 1; i <= cntc; i++) n     if (!Deep[i]) { n       Deep[i] = 1; n       dfs2(i); n     } n   for (int i = 1; i <= 17; i++) n     for (int j = 1; j <= cntc; j++) Fa[j][i] = Fa[Fa[j][i - 1]][i - 1]; n   for (int i = 1, i2, i3, i4; i <= q; i++) { n     cin >> i2 >> i3; n     i2 = col[i2]; n     i3 = col[i3]; n     if (i2 == i3) continue; n     i4 = lca(i2, i3); n     if (i4 == -1) { n       ans = 0; n       break; n     } n     val1[i2] += 1; n     val1[i4] -= 1; n     val1[i3] += ADD; n     val1[i4] -= ADD; n   } n   for (int i = 1; i <= cntc; i++) n     if (!Arr[i]) dfs3(i); n   if (ans) n     cout <<  Yes ; n   else n     cout <<  No ; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int adj[205][205]; n int rgraph[205][205]; n int n, m; n int parent[205]; n bool visited[205]; n int a[105]; n int b[105]; n bool bfs(int s, int t) { n   memset(visited, 0, sizeof(visited)); n   queue<int> q; n   q.push(s); n   visited[s] = true; n   parent[s] = -1; n   while (!q.empty()) { n     int u = q.front(); n     q.pop(); n     for (int i = 0; i <= 2 * n + 1; i++) { n       if (!visited[i] && rgraph[u][i] > 0) { n         q.push(i); n         parent[i] = u; n         visited[i] = true; n       } n     } n   } n   return visited[t] == true; n } n int solve(int s, int t) { n   for (int i = 0; i <= 2 * n + 1; i++) { n     for (int j = 0; j <= 2 * n + 1; j++) { n       rgraph[i][j] = adj[i][j]; n     } n   } n   int max_flow = 0; n   while (bfs(0, 2 * n + 1)) { n     int path = 2000000000; n     for (int i = t; i != s; i = parent[i]) { n       int u = parent[i]; n       path = min(path, rgraph[u][i]); n     } n     for (int i = t; i != s; i = parent[i]) { n       int u = parent[i]; n       rgraph[u][i] -= path; n       rgraph[i][u] += path; n     } n     max_flow += path; n   } n   return max_flow; n } n int main() { n   cin >> n >> m; n   int suma = 0, sumb = 0; n   for (int i = 1; i <= n; i++) { n     cin >> a[i]; n     adj[0][i] = a[i]; n     suma += a[i]; n   } n   for (int i = 1; i <= n; i++) { n     cin >> b[i]; n     adj[n + i][2 * n + 1] = b[i]; n     sumb += b[i]; n     adj[i][n + i] = 1000000; n   } n   for (int i = 0; i < m; i++) { n     int c, d; n     cin >> c >> d; n     adj[c][n + d] = 1000000; n     adj[d][n + c] = 1000000; n   } n   int ans = solve(0, 2 * n + 1); n   if (ans == suma && ans == sumb) { n     printf( YES n ); n     for (int i = 1; i <= n; i++) { n       for (int j = 1; j <= n; j++) { n         if (rgraph[i][n + j] != 0) n           printf( %d  , 1000000 - rgraph[i][n + j]); n         else n           printf( %d  , rgraph[i][n + j]); n       } n       printf(  n ); n     } n   } else { n     printf( NO n ); n   } n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int32_t main() { n   ios_base::sync_with_stdio(false); n   cin.tie(NULL); n   long long t; n   t = 1; n   for (long long test = 1; test <= t; test++) { n     long long n; n     cin >> n; n     vector<long long> a; n     for (long long i = 0; i <= n - 1; i++) { n       long long x; n       cin >> x; n       if (x != 0) a.push_back(x); n     } n     long long bits[61] = {0}; n     n = a.size(); n     for (long long i = 0; i <= n - 1; i++) { n       long long temp = a[i]; n       long long j = 0; n       while (temp > 0) { n         if (temp & 1) bits[j]++; n         temp = temp >> 1; n         j++; n       } n     } n     for (long long i = 0; i <= 60; i++) n       if (bits[i] >= 3) { n         cout << 3; n         exit(0); n       } n     long long cyclec = -1; n     vector<vector<long long>> adj(n); n     for (long long i = 0; i < n; i++) n       for (long long j = i + 1; j < n; j++) n         if ((a[i] & a[j]) != 0) { n           adj[i].push_back(j); n           adj[j].push_back(i); n         } n     for (long long i = 0; i <= n - 1; i++) n       if (adj[i].size() != 0) { n         vector<long long> dis(n, -1); n         vector<long long> par(n, -1); n         queue<long long> q; n         q.push(i); n         dis[i] = 0; n         par[i] = -1; n         while (!q.empty()) { n           auto x = q.front(); n           q.pop(); n           for (auto y : adj[x]) n             if (dis[y] == -1) { n               dis[y] = 1 + dis[x]; n               par[y] = x; n               q.push(y); n             } else if (y != par[x]) { n               if (cyclec == -1) n                 cyclec = (dis[y] + dis[x] + 1); n               else n                 cyclec = min(cyclec, dis[y] + dis[x] + 1); n             } n         } n       } n     cout << cyclec; n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const long long N = 200001; n std::vector<long long> g[N]; n long long s[N]; n long long h[N]; n long long a[N] = {0}; n bool visited[N] = {false}; n void dfs1(long long n, long long parent, long long depth) { n   h[n] = depth; n   for (long long v : g[n]) { n     if (v != parent) { n       dfs1(v, n, depth + 1); n     } n   } n } n void dfs2(long long n, long long parent) { n   if (h[n] % 2 == 0) { n     for (long long v : g[n]) { n       if (v != parent) { n         a[n] = s[v] - s[parent]; n       } n     } n     for (long long v : g[n]) { n       if (v != parent) { n         a[n] = min(s[v] - s[parent], a[n]); n       } n     } n     s[n] = a[n] + s[parent]; n   } else { n     a[n] = s[n] - s[parent]; n   } n   for (long long v : g[n]) { n     if (v != parent) { n       dfs2(v, n); n     } n   } n } n int main() { n   long long n; n   cin >> n; n   for (long long i = 2; i <= n; i++) { n     long long parent; n     cin >> parent; n     g[parent].push_back(i); n     g[i].push_back(parent); n   } n   for (long long i = 1; i <= n; i++) { n     cin >> s[i]; n   } n   dfs1(1, -1, 1); n   a[1] = s[1]; n   dfs2(1, n + 1); n   long long sum = 0; n   for (long long i = 1; i <= n; i++) { n     if (a[i] < 0) { n       cout <<  -1  << endl; n       return 0; n     } n     sum += a[i]; n   } n   cout << sum << endl; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n template <typename C> n int sz(const C &c) { n   return c.size(); n } n using namespace std; n int main() { n   iostream::sync_with_stdio(false); n   int64_t n; n   cin >> n; n   int k; n   cin >> k; n   int64_t maxV = 0; n   int maxI = 1; n   int64_t maxC = 0; n   for (int i = 1; i <= k; ++i) { n     int64_t a; n     cin >> a; n     if (a * (n / a) > maxV) { n       maxV = a * (n / a); n       maxI = i; n       maxC = n / a; n     } n   } n   cout << maxI <<     << maxC <<   n ; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n long long a[10], rest[10]; n int n, res = 1e9, pre[10], tmp, size[10], flag = 0; n vector<int> ve[10]; n map<long long, long long> mp; n int count(long long x) { n   if (mp[x]) return mp[x]; n   long long tmp = x; n   long long res = 0; n   for (long long i = 2; i * i <= x; i++) { n     if (x % i == 0) { n       while (x % i == 0) { n         x /= i; n         res++; n       } n     } n   } n   if (x > 1) res++; n   return mp[tmp] = res; n } n bool prime(long long x) { n   if (x == 2 || x == 3) return true; n   for (long long i = 2; i * i <= x; i++) n     if (x % i == 0) return false; n   return true; n } n int isprime[10] = {0}; n void cal(int now) { n   tmp++; n   if (size[now] == 0) { n     if (!isprime[now]) tmp += count(a[now]); n     return; n   } n   if (now) { n     if (rest[now]) tmp += count(rest[now]); n   } n   for (int i = 0; i < size[now]; i++) { n     cal(ve[now][i]); n     if (flag) return; n   } n } n void dfs(int pos) { n   if (pos == n + 1) { n     tmp = 0; n     flag = 0; n     for (int i = 0; i <= n; i++) { n       ve[i].clear(); n       size[i] = 0; n     } n     for (int i = 1; i <= n; i++) { n       size[pre[i]]++; n       ve[pre[i]].push_back(i); n     } n     cal(0); n     if (size[0] == 1) { n       tmp -= 1; n     } n     if (flag) tmp = 1e9; n     if (tmp < res) { n       res = tmp; n     } n     return; n   } n   for (int i = 0; i < pos; i++) { n     if (i && rest[i] % a[pos]) continue; n     rest[i] = rest[i] / a[pos]; n     pre[pos] = i; n     dfs(pos + 1); n     rest[i] *= a[pos]; n   } n } n int main() { n   scanf( %d , &n); n   for (int i = 1; i <= n; i++) scanf( %lld , a + i); n   sort(a + 1, a + n + 1, greater<long long>()); n   for (int i = 1; i <= n; i++) { n     rest[i] = a[i]; n     if (prime(a[i])) isprime[i] = 1; n   } n   dfs(1); n   printf( %d n , res); n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int n, m, INF = 2e9; n vector<vector<int>> value; n void shift_column(int j, int k) { n   vector<int> res(n); n   for (int i = 0; i < n; i++) res[(i - k + n) % n] = value[i][j]; n   for (int i = 0; i < n; i++) value[i][j] = res[i]; n } n void run() { n   cin >> n >> m; n   value.resize(n, vector<int>(m)); n   for (int i = 0; i < n; i++) { n     for (int j = 0; j < m; j++) { n       cin >> value[i][j]; n     } n   } n   int ans = 0; n   for (int j = 0; j < m; j++) { n     map<int, int> pos; n     vector<int> cnt(n); n     for (int i = 0; i < n; i++) pos[1 + j + i * m] = i; n     for (int i = 0; i < n; i++) { n       if (pos.find(value[i][j]) == pos.end()) continue; n       int shift = (i - pos[value[i][j]] + n) % n; n       cnt[shift]++; n     } n     auto best_shift = n         distance(cnt.begin(), max_element(cnt.begin(), cnt.end())); n     shift_column(j, best_shift); n     int best_add = INF; n     for (int i = 0; i < n; i++) best_add = min(best_add, n - cnt[i] + i); n     ans += best_add; n   } n   cout << ans; n } n signed main() { n   cout.setf(ios::fixed); n   cout.precision(10); n   cin.tie(0); n   cout.tie(0); n   ios::sync_with_stdio(0); n   run(); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int n, m, a[300100], b[300100], pos[300100]; n vector<pair<int, int> > ans; n inline void ws(int xx, int yy) { ans.push_back(make_pair(xx, yy)); } n int main() { n   scanf( %d , &n); n   for (int i = 1; i <= n; ++i) { n     scanf( %d , &a[i]); n     pos[a[i]] = i; n   } n   if (a[1] != 1) { n     int p = pos[1]; n     int x = a[1]; n     if (p - 1 >= n / 2) { n       ws(1, p); n       a[1] = 1; n       pos[1] = 1; n       pos[x] = p; n       a[p] = x; n     } else if (n - p >= n / 2) { n       ws(p, n); n       ws(1, n); n       ws(p, n); n       a[1] = 1; n       pos[1] = 1; n       pos[x] = p; n       a[p] = x; n     } n   } n   if (a[n] != n) { n     int p = pos[n]; n     int x = a[1]; n     int z = a[n]; n     if (p - 1 >= n / 2) { n       ws(1, p); n       ws(1, n); n       ws(1, p); n       a[p] = z; n       pos[z] = p; n       pos[n] = n; n       a[n] = n; n     } else if (n - p >= n / 2) { n       ws(p, n); n       a[p] = z; n       pos[z] = p; n       pos[n] = n; n       a[n] = n; n     } n   } n   for (int i = 2; i < n; ++i) { n     if (pos[i] == i) continue; n     int p = pos[i]; n     int x = a[1]; n     int y = a[i]; n     int z = a[n]; n     if (p - 1 >= n / 2 && i - 1 >= n / 2) { n       ws(1, p); n       ws(1, i); n       ws(1, p); n       swap(a[i], a[pos[i]]); n       pos[y] = p; n       pos[i] = i; n     } else if (p - 1 >= n / 2 && n - i >= n / 2) { n       ws(1, p); n       ws(1, n); n       ws(i, n); n       ws(1, n); n       ws(1, p); n       swap(a[i], a[p]); n       pos[y] = p; n       pos[i] = i; n     } else if (n - p >= n / 2 && i - 1 >= n / 2) { n       ws(p, n); n       ws(1, n); n       ws(1, i); n       ws(1, n); n       ws(p, n); n       swap(a[i], a[p]); n       pos[y] = p; n       pos[i] = i; n     } else if (n - p >= n / 2 && n - i >= n / 2) { n       ws(p, n); n       ws(i, n); n       ws(p, n); n       swap(a[i], a[p]); n       pos[y] = p; n       pos[i] = i; n     } n   } n   printf( %d n , ans.size()); n   for (int i = 0; i < ans.size(); ++i) { n     printf( %d %d n , ans[i].first, ans[i].second); n   } n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n #pragma GCC optimize( Ofast ) n #pragma GCC optimize( no-stack-protector ) n #pragma GCC optimize( unroll-loops ) n #pragma GCC target( sse,sse2,sse3,ssse3,popcnt,abm,mmx,tune=native ) n #pragma GCC optimize( fast-math ) n using namespace std; n inline void ForSpeed() { n   ios_base::sync_with_stdio(0); n   cin.tie(0); n   cout.tie(0); n } n const int MAXN = int(1e5 + 5); n const int inf = 1e9 + 7; n const int MOD = 998244353; n const long long INF = (1e18 + 7); n long long b, k, a[MAXN]; n int main() { n   ForSpeed(); n   cin >> b >> k; n   for (int i = 0; i < k; i++) { n     cin >> a[i]; n   } n   if (k == 1) { n     if (a[0] % 2 != 0 && b % 2 != 0) { n       cout <<  odd ; n       return 0; n     } n   } n   if (b % 2 == 0 && a[k - 1] % 2 == 0) { n     cout <<  even ; n     return 0; n   } else if (b % 2 == 0 && a[k - 1] % 2 != 0) { n     cout <<  odd ; n     return 0; n   } n   long long ch = 0; n   if (a[0] % 2 == 0) { n     ch = 1; n   } n   for (int i = 1; i < k - 1; i++) { n     if (ch == 0 && a[i] % 2 != 0) { n       ch = 1; n     } else if (ch == 1 && a[i] % 2 == 0) { n       continue; n     } else { n       ch = 0; n     } n   } n   if (ch == 1 && a[k - 1] % 2 == 0) { n     cout <<  even ; n   } else if (ch == 0 && a[k - 1] % 2 != 0) { n     cout <<  even ; n   } else { n     cout <<  odd ; n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int mod =  1000000007; n const int LIM = 100005; n #define int long long n #define IOS ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0) n #define mem(a,b) memset(a,b,sizeof(a)) n #define all(a) a.begin() , a.end() n #define pii pair<int,int> n #define vi vector<int> n #define endl   n  n #define pb push_back n #define sp <<   << n #define ss second n #define ff first n int power(int x, int n){ n     int res = 1; n     while(n){ n           if(n&1){ n                 res = res * x % mod; n           } n           x = x * x % mod; n           n>>=1; n     } n     return (res%mod); n } n /*bool prime[1000006]; n void sieve(int n) n { n       memset(prime, true, sizeof(prime)); n       int rootn = (int)sqrt(n); n       for (int p = 2; p <= rootn; p++) n             if(prime[p] == true) n                   for(int i = p*p; i <= n; i += p) n                         prime[i] = false; n       prime[1] = 0; n  n }*/ n /* n int fac[300005]; n int ncr(int n,int r) n { n       return fac[n]*((power(fac[n-r], mod-2)*power(fac[r], mod-2))%mod)%mod; n } n */ n bool check(int a[],int n) n { n  for(int i=1;i<n;i++) n  { n   if(a[i]<a[i-1])return false; n  } n  return true; n } n  n int32_t main() n { n   IOS; n   int tt=1,n,x,k,y,z,i,j; n   cin>>tt; n   while(tt--){ n     cin>>n>>x; n   int a[n]; n   for(int i=0;i<n;i++) n   { n    cin>>a[i]; n   } n   int ans=0; n   for(int i=0;i<=n;i++) n   { n    if(check(a,n))break; n    ans++; n    for(int j=0;j<n;j++) n    { n     if(a[j]>x) n     { n      swap(a[j],x); n      break; n     } n    } n   } n   if(check(a,n))cout<<ans<<endl; n   else cout<<-1<<endl; n   } n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n bool debug = 0; n int n, m, k; n int dx[4] = {0, 1, 0, -1}, dy[4] = {1, 0, -1, 0}; n string direc =  RDLU ; n long long ln, lk, lm; n void etp(bool f = 0) { n   puts(f ?  YES  :  NO ); n   exit(0); n } n void addmod(int &x, int y, int mod = 1000000007) { n   assert(y >= 0); n   x += y; n   if (x >= mod) x -= mod; n   assert(x >= 0 && x < mod); n } n void et() { n   puts( -1 ); n   exit(0); n } n long long fastPow(long long x, long long y, int mod = 1000000007) { n   long long ans = 1; n   while (y > 0) { n     if (y & 1) ans = (x * ans) % mod; n     x = x * x % mod; n     y >>= 1; n   } n   return ans; n } n long long gcd1(long long x, long long y) { n   long long z = y; n   while (x % y != 0) { n     z = x % y; n     x = y; n     y = z; n   } n   return z; n } n int h, u[100005], dp[100005]; n vector<int> mp[100005]; n set<pair<int, int> > cs; n void add(int x, int y) { n   if (cs.count({x, y})) return; n   cs.insert({x, y}); n   mp[x].push_back(y); n } n int dfn[100005], sta[100005], low[100005], color, ii, cnt, belong[100005]; n bool ins[100005]; n int sz[100005]; n void tarjan(int x) { n   dfn[x] = low[x] = ++ii; n   sta[++cnt] = x; n   ins[x] = 1; n   for (auto child : mp[x]) { n     if (!dfn[child]) { n       tarjan(child); n       low[x] = min(low[x], low[child]); n     } else if (ins[child]) { n       low[x] = min(low[x], dfn[child]); n     } n   } n   if (dfn[x] == low[x]) { n     ++color; n     int t; n     do { n       t = sta[cnt]; n       cnt--; n       ins[t] = 0; n       belong[t] = color; n       sz[color]++; n     } while (dfn[t] != low[t]); n   } n } n bool del[100005]; n void fmain(int ID) { n   scanf( %d%d%d , &n, &m, &h); n   for (int(i) = 1; (i) <= (int)(n); (i)++) { n     scanf( %d , u + i); n   } n   for (int(i) = 1; (i) <= (int)(m); (i)++) { n     int x, y; n     scanf( %d%d , &x, &y); n     if ((u[x] + 1) % h == u[y]) add(x, y); n     if ((u[y] + 1) % h == u[x]) add(y, x); n   } n   for (int(i) = 1; (i) <= (int)(n); (i)++) n     if (belong[i] == 0) tarjan(i); n   for (auto p : cs) { n     int x = belong[p.first], y = belong[p.second]; n     if (x == y) continue; n     del[x] = 1; n   } n   int ans = -1; n   for (int(i) = 1; (i) <= (int)(color); (i)++) n     if (!del[i]) { n       if (ans == -1 || sz[ans] > sz[i]) ans = i; n     } n   printf( %d n , sz[ans]); n   for (int(i) = 1; (i) <= (int)(n); (i)++) n     if (belong[i] == ans) printf( %d  , i); n } n int main() { n   int t = 1; n   for (int(i) = 1; (i) <= (int)(t); (i)++) { n     fmain(i); n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int N = 1e5 + 10, V = 1e5; n inline int read() { n   register int x = 0, f = 0; n   register char c = getchar(); n   while (c <  0  || c >  9 ) f |= c ==  - , c = getchar(); n   while (c >=  0  && c <=  9 ) x = (x << 3) + (x << 1) + c -  0 , c = getchar(); n   return f ? -x : x; n } n int n, tot, top; n struct point { n   int x, y; n } p[N * 10], s[N * 10]; n point operator-(const point &A, const point &B) { n   return (point){A.x - B.x, A.y - B.y}; n } n inline void add(int x, int y) { n   p[++tot].x = x; n   p[tot].y = y; n } n inline double accross(point A, point B) { n   return (double)A.x * B.y - (double)A.y * B.x; n } n inline double dis(point A, point B) { n   return (double)(A.x - B.x) * (A.x - B.x) + (double)(A.y - B.y) * (A.y - B.y); n } n inline bool cmp1(const point &A, const point &B) { n   return A.x == B.x ? A.y < B.y : A.x < B.x; n } n inline bool cmp2(const point &A, const point &B) { n   return A.x == B.x && A.y == B.y; n } n inline bool cmp3(const point &A, const point &B) { n   double res = accross(A - p[1], B - p[1]); n   if (res > 0) n     return true; n   else if (res == 0 && dis(A, p[1]) < dis(B, p[1])) n     return true; n   return false; n } n void Get_TB() { n   for (int i = 2; i <= tot; ++i) n     if (p[1].y > p[i].y || (p[1].y == p[i].y && p[1].x > p[i].x)) n       swap(p[i], p[1]); n   sort(p + 2, p + tot + 1, cmp3); n   s[1] = p[1]; n   s[2] = p[2]; n   top = 2; n   for (int i = 3; i <= tot; ++i) { n     while (top > 1 && accross(p[i] - s[top - 1], s[top] - s[top - 1]) >= 0) n       top--; n     s[++top] = p[i]; n   } n   return; n } n inline double len(point &A) { n   return sqrt((double)A.x * A.x + (double)A.y * A.y); n } n double calc(point A, point B, point C) { n   point x = A - B, y = C - B, z = C - A; n   double res = len(x) * len(y) * len(z) / (accross(y, x) * 2); n   return res; n } n int main() { n   n = read(); n   for (int i = 1; i <= n; ++i) { n     int x = read(), y = read(), v = read(); n     if (x < v) n       add(0, min(V, y + v - x)), add(0, max(0, y - v + x)); n     else n       add(x - v, y); n     if (y < v) n       add(max(0, x - v + y), 0), add(min(V, x + v - y), 0); n     else n       add(x, y - v); n     if (x + v > V) n       add(V, min(V, y + x + v - V)), add(V, max(0, y - x - v + V)); n     else n       add(x + v, y); n     if (y + v > V) n       add(min(V, x + y + v - V), V), add(max(0, x - y - v + V), V); n     else n       add(x, y + v); n   } n   sort(p + 1, p + 1 + tot, cmp1); n   tot = unique(p + 1, p + 1 + tot, cmp2) - p - 1; n   Get_TB(); n   int id = 0; n   double ans = -1e9, tmp; n   s[0] = s[top]; n   s[top + 1] = s[1]; n   for (int i = 1; i <= top; ++i) { n     point a = s[i - 1], b = s[i], c = s[i + 1]; n     if ((tmp = calc(a, b, c)) > ans) ans = tmp, id = i; n   } n   cout << s[id - 1].x <<     << s[id - 1].y <<   n ; n   cout << s[id].x <<     << s[id].y <<   n ; n   cout << s[id + 1].x <<     << s[id + 1].y <<   n ; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n void init() { freopen( input.txt ,  r , stdin); } n int abs(int x) { n   if (x < 0) { n     return -x; n   } n   return x; n } n int main() { n   int n, m, x1, y1, x2, y2; n   cin >> n >> m >> x1 >> y1 >> x2 >> y2; n   n = abs(x1 - x2) + 1; n   m = abs(y1 - y2) + 1; n   if ((n >= 6) || (m >= 6)) { n     cout <<  Second ; n     return 0; n   } n   if ((n <= 4) && (m <= 4)) { n     cout <<  First ; n     return 0; n   } n   if (((n == 5) || (n == 4)) && ((m == 5) || (m == 4))) { n     cout <<  Second ; n     return 0; n   } n   cout <<  First  << endl; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int gcd(long long a, int b) { n   if (a < b) { n     return gcd(b, a); n   } n   if (b == 0) { n     return a; n   } n   return gcd(b, a % b); n } n class Triplet { n  public: n   long long gcd; n   long long x; n   long long y; n }; n Triplet gcdExtendedEuclid(int a, int b) { n   if (b == 0) { n     Triplet myAns; n     myAns.gcd = a; n     myAns.x = 1; n     myAns.y = 0; n     return myAns; n   } n   Triplet smallAns = gcdExtendedEuclid(b, a % b); n   Triplet myAns; n   myAns.gcd = smallAns.gcd; n   myAns.x = smallAns.y; n   myAns.y = (smallAns.x - ((a / b) * (smallAns.y))); n   return myAns; n } n long long modInverse(int A, int M) { n   Triplet ans = gcdExtendedEuclid(A, M); n   return ans.x; n } n bool check(vector<long long>& v1, long long val, long long h) { n   long long ans = 0; n   for (long long i = 0; i < v1.size(); i++) { n     ans += v1[i] / val; n     if (v1[i] % val != 0) { n       ans += 1; n     } n   } n   if (ans > h) { n     return false; n   } n   return true; n } n void multiply(long long A[2][2], long long M[2][2]) { n   long long firstValue = (A[0][0] * M[0][0] + A[0][1] * M[1][0]) % 1000000007; n   long long secondValue = (A[0][0] * M[0][1] + A[0][1] * M[1][1]) % 1000000007; n   long long thirdValue = (A[1][0] * M[0][0] + A[1][1] * M[1][0]) % 1000000007; n   long long fourthValue = (A[1][0] * M[0][1] + A[1][1] * M[1][1]) % 1000000007; n   A[0][0] = firstValue; n   A[0][1] = secondValue; n   A[1][0] = thirdValue; n   A[1][1] = fourthValue; n   return; n } n void getpow(long long A[2][2], long long n) { n   if (n == 0 || n == 1) { n     return; n   } n   getpow(A, n / 2); n   multiply(A, A); n   if (n % 2 != 0) { n     long long first[2][2] = {{1, 1}, {1, 0}}; n     multiply(A, first); n   } n   return; n } n long long getpow1(long long n, long long m, long long b) { n   if (m == 0) { n     return 1; n   } n   long long ans = getpow1(n, m / 2, b) % b; n   ans = (ans * ans) % b; n   if (m % 2 != 0) { n     ans = ans * n % b; n   } n   return ans % b; n } n long long getfib(long long n) { n   if (n == 0) { n     return 0; n   } n   long long A[2][2] = {{1, 1}, {1, 0}}; n   getpow(A, n); n   long long first[1][2]; n   first[0][0] = 0; n   first[0][1] = 1; n   long long ans = first[0][0] * A[0][0] + first[0][1] * A[1][0]; n   return ans % 1000000007; n } n vector<long long>* sieve() { n   bool isprime[1000001]; n   for (long long i = 0; i < 1000001; i++) { n     isprime[i] = true; n   } n   vector<long long>* primes = new vector<long long>(); n   for (long long i = 2; i < 1000001; i++) { n     if (isprime[i] == true) { n       for (long long j = 2 * i; j < 1000001; j += i) { n         isprime[j] = false; n       } n     } n   } n   primes->push_back(2); n   for (long long i = 3; i < 1000001; i++) { n     if (isprime[i] == true) { n       primes->push_back(i); n     } n   } n   return primes; n } n long long getpow2(long long a, string& b, long long m) { n   long long mod = 1000000007; n   long long num = 1; n   for (long long i = b.size() - 1; i >= 0; i--) { n     if (b[i] == 1) { n       num = (num * a) % m; n     } else if (b[i] == 2) { n       num = ((num * a) % m * a) % m; n     } n     a = ((a * a) % m * a) % m; n   } n   return num % m; n } n long long arr[5000001]; n long long res[1000001]; n long long res1[1000001]; n int main() { n   long long k, n; n   cin >> k >> n; n   long long num = 0; n   long long k1 = k; n   while (k1 < n) { n     k1 *= k; n     num++; n   } n   if (k1 == n) { n     cout <<  YES  <<   n ; n     cout << num; n     return 0; n   } n   cout <<  NO  <<   n ; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n const long long mod = (long long)1e9 + 7; n const int maxn = (int)1e5 + 1; n long long inf = 1LL << 60; n using namespace std; n inline void read(int &n) { n   int x = 0, f = 1; n   char ch = getchar(); n   while (ch <  0  || ch >  9 ) { n     if (ch ==  - ) f = -1; n     ch = getchar(); n   } n   while (ch >=  0  && ch <=  9 ) { n     x = 10 * x + ch -  0 ; n     ch = getchar(); n   } n   n = x * f; n } n inline void read(long long &n) { n   long long x = 0, f = 1; n   char ch = getchar(); n   while (ch <  0  || ch >  9 ) { n     if (ch ==  - ) f = -1; n     ch = getchar(); n   } n   while (ch >=  0  && ch <=  9 ) { n     x = 10ll * x + ch -  0 ; n     ch = getchar(); n   } n   n = x * f; n } n int a[20]; n int rule[20][20]; n long long dp[1 << 19][19]; n int bitCount(int n) { n   int count = 0; n   while (n) { n     count++; n     n &= (n - 1); n   } n   return count; n } n int main() { n   setlocale(LC_ALL,  Russian ); n   ios_base::sync_with_stdio(0); n   int n, m, k; n   cin >> n >> m >> k; n   long long ans = 0; n   for (int i = 0; i < n; i++) { n     cin >> a[i]; n   } n   for (int i = 0; i < k; i++) { n     int u, v, d; n     cin >> u >> v >> d; n     u--, v--; n     rule[u][v] = d; n   } n   for (int i = 0; i < n; i++) dp[1 << i][i] = a[i]; n   for (int mask = 0; mask < 1 << n; mask++) { n     for (int i = 0; i < n; i++) { n       if (mask & (1 << i)) { n         for (int j = 0; j < n; j++) { n           if (!(mask & (1 << j))) { n             int nmask = mask | (1 << j); n             dp[nmask][j] = max(dp[nmask][j], dp[mask][i] + a[j] + rule[i][j]); n           } n         } n       } n     } n   } n   for (int mask = 0; mask < 1 << n; mask++) { n     for (int i = 0; i < n; i++) { n       if (bitCount(mask) == m) { n         ans = max(ans, dp[mask][i]); n       } n     } n   } n   cout << ans; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int dp[2][300005], x[300005], y[300005]; n int n, k; n int main() { n   cin >> n >> k; n   for (int i = 1; i <= n; i++) cin >> x[i]; n   for (int i = 1; i <= n; i++) cin >> y[i]; n   for (int i = 1; i <= n; i++) { n     if (!(~dp[0][i - 1])) { n       dp[0][i] = -1; n       dp[1][i] = -1; n       continue; n     } n     if (x[i] > y[i]) { n       long long h = (long long)k * ((long long)y[i] + 1LL); n       if (x[i] + dp[0][i - 1] > h) { n         dp[0][i] = -1; n         dp[1][i] = -1; n         continue; n       } n       dp[1][i] = 0; n       h = (long long)k * (long long)y[i]; n       if (x[i] + dp[0][i - 1] <= h) { n         dp[0][i] = 0; n         continue; n       } else n         dp[0][i] = x[i] + dp[0][i - 1] - k * y[i]; n     } n     if (y[i] > x[i]) { n       long long h = (long long)k * ((long long)x[i] + 1LL); n       if (y[i] + dp[1][i - 1] > h) { n         dp[0][i] = -1; n         dp[1][i] = -1; n         continue; n       } n       dp[0][i] = 0; n       h = (long long)k * (long long)x[i]; n       if (y[i] + dp[1][i - 1] <= h) { n         dp[1][i] = 0; n         continue; n       } else n         dp[1][i] = y[i] + dp[1][i - 1] - k * x[i]; n     } n     if (x[i] == y[i]) { n       if (x[i] == 1) { n         if (max(dp[0][i - 1], dp[1][i - 1]) == k) { n           dp[(dp[0][i - 1] > dp[1][i - 1] ? 1 : 0)][i] = 0; n           dp[(dp[0][i - 1] > dp[1][i - 1] ? 0 : 1)][i] = 1; n         } else n           continue; n       } else { n         if (k == 1 && max(dp[0][i - 1], dp[1][i - 1]) == k) { n           dp[(dp[0][i - 1] > dp[1][i - 1] ? 1 : 0)][i] = 0; n           dp[(dp[0][i - 1] > dp[1][i - 1] ? 0 : 1)][i] = 1; n         } else n           continue; n       } n     } n   } n   if (~dp[0][n]) n     cout <<  YES ; n   else n     cout <<  NO ; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n #pragma comment(linker,  /STACK:1024000000,1024000000 ) n const double pi = acos(-1.0), eps = 1e-8; n const int maxm = 1100000, inf = 0x3f3f3f3f; n bool f[maxm]; n vector<int> v[maxm]; n int top, st[maxm]; n int a[maxm]; n void dfs(int x, int pre) { n   f[x] = true; n   int i; n   a[x] ^= 1; n   st[top++] = x; n   for (i = 0; i < v[x].size(); i++) { n     if (f[v[x][i]] == false) { n       dfs(v[x][i], x); n       st[top++] = x; n       a[x] ^= 1; n     } n   } n   if (a[x] != 0 && pre != -1) { n     st[top++] = pre; n     a[pre] ^= 1; n     st[top++] = x; n     a[x] ^= 1; n   } n } n int main() { n   int n, m, i, x, y, begin; n   while (scanf( %d%d , &n, &m) == 2) { n     for (i = 1; i <= n; i++) v[i].clear(); n     while (m--) { n       scanf( %d%d , &x, &y); n       v[x].push_back(y); n       v[y].push_back(x); n     } n     for (i = 1; i <= n; i++) { n       scanf( %d , &a[i]); n       f[i] = false; n     } n     top = 0; n     for (i = 1; i <= n; i++) { n       if (a[i] == 1) { n         dfs(i, -1); n         begin = i; n         break; n       } n     } n     if (i == n + 1) { n       printf( 0 n ); n       continue; n     } n     for (i = begin + 1; i <= n; i++) { n       if (a[i] != 0) { n         printf( -1 n ); n         break; n       } n     } n     if (i <= n) continue; n     if (a[begin] == 1) n       begin = 1; n     else n       begin = 0; n     printf( %d n , top - begin); n     for (i = begin; i < top; i++) { n       printf( %d , st[i]); n       if (i == top - 1) n         printf(  n ); n       else n         printf(   ); n     } n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int MAX_N = 11111, MAX_M = 222222; n class Flow_Algorithm { n  public: n   int g[MAX_M], nxt[MAX_M], flow[MAX_M], c[MAX_N], h[MAX_N], nm; n   int d[MAX_N], q[MAX_N]; n   int S, T; n   void addedge(int x, int y, int w) { n     g[nm] = y; n     nxt[nm] = c[x]; n     c[x] = nm; n     flow[nm] = w; n     nm++; n   } n   void add(int x, int y, int w) { n     addedge(x, y, w); n     addedge(y, x, 0); n   } n   bool bfs() { n     memset(d, -1, sizeof d); n     d[q[1] = S] = 0; n     for (int l = 1, r = 1; l <= r; ++l) { n       int i = q[l]; n       for (int k = c[i]; ~k; k = nxt[k]) { n         int j = g[k]; n         if (!~d[j] && flow[k]) d[q[++r] = j] = d[i] + 1; n       } n     } n     return d[T] != -1; n   } n   int dfs(int i, int now) { n     if (!now) return 0; n     if (i == T) return now; n     int w = 0; n     for (int &k = c[i]; ~k; k = nxt[k]) { n       int j = g[k]; n       if (d[j] == d[i] + 1) { n         int res; n         if (flow[k] && ((res = dfs(j, min(now - w, flow[k]))) > 0)) { n           flow[k] -= res; n           flow[k ^ 1] += res; n           w += res; n           if (w == now) return w; n         } n       } n     } n     return w; n   } n   void sets(int _S, int _T) { n     S = _S; n     T = _T; n     nm = 0; n     memset(c, -1, sizeof c); n   } n   int Dinic() { n     memcpy(h, c, sizeof h); n     int ans = 0; n     while (bfs()) { n       ans += dfs(S, 1000000000); n       memcpy(c, h, sizeof c); n     } n     return ans; n   } n } G; n int A[55], B[55], C[55], L[55], R[55]; n int n, m; n int nd[55][222]; n int calc(int i, int x) { return x * x * A[i] + x * B[i] + C[i]; } n int main() { n   scanf( %d%d , &n, &m); n   for (int i = (1); i <= (n); ++i) scanf( %d%d%d , &A[i], &B[i], &C[i]); n   for (int i = (1); i <= (n); ++i) scanf( %d%d , &L[i], &R[i]); n   int tot = 0; n   for (int i = (1); i <= (n); ++i) n     for (int j = (L[i] - 1); j <= (R[i]); ++j) nd[i][j + 100] = ++tot; n   int S = tot + 1, T = tot + 2; n   G.sets(S, T); n   for (int i = (1); i <= (n); ++i) { n     G.add(S, nd[i][L[i] - 1 + 100], 1000000000); n     for (int j = (L[i]); j <= (R[i]); ++j) n       G.add(nd[i][j - 1 + 100], nd[i][j + 100], 20000000 - calc(i, j)); n     G.add(nd[i][R[i] + 100], T, 1000000000); n   } n   for (int i = (1); i <= (m); ++i) { n     int u, v, d; n     scanf( %d%d%d , &u, &v, &d); n     for (int j = (L[u] - 1); j <= (R[u]); ++j) { n       int p = j - d, pt = 0; n       if (p < L[v]) n         pt = nd[v][L[v] - 1 + 100]; n       else n         pt = nd[v][p + 100]; n       G.add(nd[u][j + 100], pt, 1000000000); n     } n   } n   int ans = G.Dinic(); n   ans = n * 20000000 - ans; n   printf( %d n , ans); n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n constexpr int N = 2e5 + 3; n vector<int> c[N]; n vector<int> e[N]; n int main() { n   ios_base::sync_with_stdio(false); n   int n, m, q; n   cin >> n >> m >> q; n   for (int it = 0; it < q; ++it) { n     int r, C; n     cin >> r >> C; n     c[r].push_back(C); n   } n   for (int i = 1; i <= n; ++i) { n     int esz = c[i].size(); n     for (int j = 1; j < esz; ++j) { n       int prev = c[i][j - 1], now = c[i][j]; n       e[prev].push_back(now); n       e[now].push_back(prev); n     } n   } n   vector<int> vis(m + 1, 0); n   int cc = 0; n   for (int i = 1; i <= m; ++i) { n     if (vis[i] == 0) { n       ++cc; n       function<void(int)> dfs = [&](int i) { n         assert(i >= 1 && i <= m); n         if (vis[i] != 0) { n           assert(vis[i] == cc); n           return; n         } n         vis[i] = cc; n         for (int v : e[i]) { n           dfs(v); n         } n       }; n       dfs(i); n     } n   } n   int cnt_empty_r = 0; n   for (int i = 1; i <= n; ++i) { n     if (c[i].empty()) { n       ++cnt_empty_r; n     } n   } n   cout << cnt_empty_r + cc - 1 <<   n ; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n static const int INF = 0x3f3f3f3f; n static const long long INFL = 0x3f3f3f3f3f3f3f3fLL; n template <typename T> n T mulmod(T a, T b, T m) { n   long long int q = n       (long long int)(((long double)a * (long double)b) / (long double)m); n   long long int r = a * b - q * m; n   if (r > m) r %= m; n   if (r < 0) r += m; n   return r; n } n template <typename T> n T MOD(T a, T b) { n   return (a < b ? a : a % b); n } n template <typename T> n T expo(T e, T n) { n   T x = 1, p = e; n   while (n) { n     if (n & 1) x = x * p; n     p = p * p; n     n >>= 1; n   } n   return x; n } n template <typename T> n T power(T e, T n, T m) { n   T x = 1, p = e; n   while (n) { n     if (n & 1) x = mulmod(x, p, m); n     p = mulmod(p, p, m); n     n >>= 1; n   } n   return x; n } n template <typename T> n T gcd(T a, T b) { n   if (a % b) return gcd(b, a % b); n   return b; n } n template <typename T> n T lcm(T a, T b) { n   return (a * (b / gcd(a, b))); n } n template <typename T> n T add(T a, T b, T Mod) { n   a += b; n   return (a >= Mod ? a - Mod : a); n } n template <typename T> n T sub(T a, T b, T Mod) { n   a -= b; n   return (a < 0 ? a + Mod : a); n } n const int Mod = 1000000007; n const int N = 100005; n int MX = 1000001; n int a[N]; n struct segmentTree { n   int tree[6 * N]; n   int lazy[6 * N]; n   void modify(int node, int v) { n     tree[node] += v; n     lazy[node] += v; n   } n   void update(int node, int x, int y, int p, int q, int val) { n     if (lazy[node]) { n       modify(node << 1, lazy[node]); n       modify(node << 1 | 1, lazy[node]); n       lazy[node] = 0; n     } n     if (x >= p and y <= q) { n       modify(node, val); n       return; n     } n     int mid = x + y >> 1; n     if (p <= mid) update(node << 1, x, mid, p, q, val); n     if (q > mid) update(node << 1 | 1, mid + 1, y, p, q, val); n     tree[node] = max(tree[node << 1], tree[node << 1 | 1]); n   } n   int query(int node, int x, int y) { n     if (lazy[node]) { n       modify(node << 1, lazy[node]); n       modify(node << 1 | 1, lazy[node]); n       lazy[node] = 0; n     } n     if (tree[node] <= 0) return -1; n     if (x == y) return a[x]; n     int mid = x + y >> 1; n     int ret = query(node << 1 | 1, mid + 1, y); n     if (ret == -1) { n       ret = query(node << 1, x, mid); n     } n     return ret; n   } n } T; n int main() { n   ios_base::sync_with_stdio(false); n   cin.tie(NULL); n   int m; n   cin >> m; n   for (int i = 0; i <= m - 1; i++) { n     int p, t; n     cin >> p >> t; n     if (t == 0) { n       T.update(1, 1, m, 1, p, -1); n     } else { n       int x; n       cin >> x; n       a[p] = x; n       T.update(1, 1, m, 1, p, 1); n     } n     cout << T.query(1, 1, m) <<   n ; n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const long long N = 100005; n const long long M = 998244353; n long long pow1(long long a, long long b) { n   int res = 1; n   while (b > 0) { n     if (b & 1) { n       res = (res * a) % M; n     } n     a = (a * a) % M; n     b >>= 1; n   } n   return res % M; n } n int main() { n   ios_base::sync_with_stdio(0); n   cin.tie(0); n   cout.tie(0); n   long long T; n   T = 1; n   cin >> T; n   while (T--) { n     long long n, m; n     cin >> n >> m; n     long long ans[n][m]; n     for (long long i = 0; i < n; i++) { n       for (long long j = 0; j < m; j++) { n         long long num; n         cin >> num; n         if (num % 2 != (i + j) % 2) n           ans[i][j] = num + 1; n         else n           ans[i][j] = num; n         cout << ans[i][j] <<    ; n       } n       cout <<   n ; n     } n   } n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int main() { n   long long int n, k, i, j; n   cin >> n >> k; n   long long int x = 1; n   long long int ans = n - 1; n   for (i = 0; i < k; i++) { n     vector<long long int> v; n     long long int m; n     cin >> m; n     long long int t = -1; n     for (j = 0; j < m; j++) { n       long long int y; n       cin >> y; n       if (y == 1) t = j; n       v.push_back(y); n     } n     if (t != -1) { n       for (j = t + 1; j < m; j++) { n         if (v[j] == v[j - 1] + 1) n           x++; n         else n           break; n       } n     } n     ans += m - 1; n   } n   cout << ans - (2 * (x - 1)); n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int main() { n   int num, hight, temp, width = 0; n   cin >> num >> hight; n   vector<int> v; n   for (int i = 0; i < num; i++) { n     cin >> temp; n     v.push_back(temp); n     if (v[i] > hight) n       width += 2; n     else n       width++; n   } n   cout << width; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const double pi = 2 * acos(0); n int main() { n   ios_base::sync_with_stdio(0); n   cin.tie(0); n   int q; n   cin >> q; n   while (q--) { n     int n, r; n     cin >> n >> r; n     set<int> s; n     vector<int> v; n     for (long long i = 0; i < n; i++) { n       int a; n       cin >> a; n       s.insert(a); n     } n     for (auto u : s) v.push_back(u); n     int cnt = 0; n     for (int i = v.size() - 1; i >= 0; i--) { n       if (v[i] - r * cnt > 0) cnt++; n     } n     cout << cnt <<   n ; n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int N = 100005; n int n, a[N], b[N], posa[N], posb[N], dif[N], ans, ord[N], t1; n multiset<int> rig, lef; n int abss(const int i) { return i < 0 ? -i : i; } n bool cmp(int i, int j) { return dif[i] < dif[j]; } n int main() { n   scanf( %d , &n); n   for (int i = 1; i <= n; ++i) { n     scanf( %d , &a[i]); n     posa[a[i]] = i; n   } n   for (int i = 1; i <= n; ++i) { n     scanf( %d , &b[i]); n     posb[b[i]] = i; n   } n   ans = n; n   for (int i = 1; i <= n; ++i) { n     ans = min(ans, abss(posa[i] - posb[i])); n     dif[i] = posb[i] - posa[i]; n     if (dif[i] > 0) { n       rig.insert(dif[i]); n     } else { n       lef.insert(-dif[i]); n     } n     ord[i] = i; n   } n   sort(ord + 1, ord + 1 + n, cmp); n   t1 = 1; n   printf( %d n , ans); n   for (int i = 2; i <= n; ++i) { n     lef.erase(lef.find(posa[b[i - 1]] - i + 1)); n     rig.insert(n - posa[b[i - 1]] + i - 1); n     while (rig.size() > 0 && *rig.begin() - i + 1 == 0) { n       rig.erase(rig.find(*rig.begin())); n       lef.insert((int)(-i + 1)); n     } n     ans = min(*lef.begin() + i - 1, n               rig.size() > 0 ? *rig.begin() - i + 1 : n + 1); n     printf( %d n , ans); n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int INF = 0x3f3f3f3f; n const int MAX = 100005; n const int MAX1 = 1005; n const int MAX2 = 105; n const int LEN = 105; n const int BASE = 1000000000; n const double EPS = 1e-7; n const int MOD = 1000000007; n long long pow(long long a, long long b) { n   long long ans = 1; n   while (b) { n     if (b & 1) ans = (ans * a) % MOD; n     b /= 2; n     a = (a * a) % MOD; n   } n   return ans; n } n int main(void) { n   ios_base::sync_with_stdio(false); n   cin.tie(NULL); n   cout.tie(NULL); n   ifstream in(  ); n   ofstream out(  ); n   clock_t begin = clock(); n   int q; n   cin >> q; n   while (q--) { n     int n; n     cin >> n; n     int arr[MAX]; n     for (int i = (0); i < (n); ++i) { n       cin >> arr[i]; n     } n     sort(arr, arr + n); n     cout << min(n - 2, arr[n - 2] - 1) <<   n ; n   } n   clock_t end = clock(); n   double esecs = double(end - begin) / CLOCKS_PER_SEC; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n template <typename T> n inline T S(T a) { n   return a * a; n } n template <class T> n inline string tostring(T a) { n   ostringstream os(  ); n   os << a; n   return os.str(); n } n template <typename T> n inline long long tolong(T a) { n   long long res; n   istringstream os(a); n   os >> res; n   return res; n } n template <typename T> n inline T gcd(T a, T b) { n   if (b == 0) n     return a; n   else n     return gcd(b, a % b); n } n template <typename T> n inline T bigmod(T a, T b, T m) { n   if (b == 0) n     return 1; n   else if (b % 2 == 0) n     return S(bigmod(a, b / 2, m)) % m; n   else n     return (a % m * bigmod(a, b - 1, m)) % m; n } n const int inf = (int)1e9 + 5; n const long long linf = (long long)1e16 + 5; n const long long modd = (long long)1e9 + 7; n const int mod = 10000007; n void pr(int f) { n   if (f == 1) n     cout <<  YES n ; n   else n     cout <<  NO n ; n } n bool isprime(long long n) { n   if (n < 2) return 0; n   if (n == 2) n     return 1; n   else { n     for (int i = 2; i * i <= n; i++) n       if (n % i == 0) return 0; n   } n   return 1; n } n map<int, int> mp; n multiset<string>::iterator it; n deque<char> q; n const int nax = 10e6 + 5; n int t[nax], l[100005], d[100005]; n int main() { n   ios_base::sync_with_stdio(0); n   long long int n, m; n   cin >> n >> m; n   long long int low, high; n   high = ((n - (m - 1)) * (n - m)) / 2; n   long long int quo = n / m; n   long long int rem = n % m; n   low = rem * ((quo + 1) * (quo)) / 2 + (m - rem) * (quo * (quo - 1)) / 2; n   cout << low <<     << high; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n const int inf = (1ll << 30) - 1; n const int maxn = (int)1e5 + 10; n using namespace std; n int n; n vector<int> g[100100]; n int a[100100]; n int in[100100]; n int out[100100]; n int dp[100100]; n map<int, int> t[400400]; n int timer = 0; n void dfs(int v) { n   in[v] = timer; n   a[timer] = v; n   timer++; n   dp[v] = 1; n   for (int i = 0; i < g[v].size(); i++) { n     int to = g[v][i]; n     dfs(to); n     dp[v] += dp[to]; n   } n   out[v] = timer - 1; n } n void build(int v, int l, int r) { n   if (l == r) { n     t[v][dp[a[l]]]++; n   } else { n     int mid = (l + r) >> 1; n     build(v * 2, l, mid); n     build(v * 2 + 1, mid + 1, r); n     for (int i = l; i <= r; i++) t[v][dp[a[i]]]++; n   } n } n int getu(int v, int l, int r, int tl, int tr, int x) { n   if (tl > tr) return inf; n   if (l == tl && tr == r) { n     map<int, int>::iterator pos = t[v].lower_bound(x); n     if (pos != t[v].end()) return pos->first; n     return inf; n   } n   int mid = (l + r) >> 1; n   return min(getu(v * 2, l, mid, tl, min(tr, mid), x), n              getu(v * 2 + 1, mid + 1, r, max(tl, mid + 1), tr, x)); n } n int getd(int v, int l, int r, int tl, int tr, int x) { n   if (tl > tr) return -inf; n   if (l == tl && tr == r) { n     map<int, int>::iterator pos = t[v].lower_bound(x + 1); n     if (pos != t[v].begin()) return (--pos)->first; n     return -inf; n   } n   int mid = (l + r) >> 1; n   return max(getd(v * 2, l, mid, tl, min(tr, mid), x), n              getd(v * 2 + 1, mid + 1, r, max(tl, mid + 1), tr, x)); n } n void ADD(int v, int l, int r, int pos, int x) { n   t[v][x]++; n   if (l == r) { n     return; n   } n   int mid = (l + r) >> 1; n   if (pos <= mid) { n     ADD(v * 2, l, mid, pos, x); n   } else n     ADD(v * 2 + 1, mid + 1, r, pos, x); n } n void DEL(int v, int l, int r, int pos, int x) { n   t[v][x]--; n   if (t[v][x] == 0) t[v].erase(x); n   if (l == r) { n     return; n   } n   int mid = (l + r) >> 1; n   if (pos <= mid) { n     DEL(v * 2, l, mid, pos, x); n   } else n     DEL(v * 2 + 1, mid + 1, r, pos, x); n } n int ans[100100]; n set<int> PA; n void calc(int v, int szz) { n   int cv = dp[v]; n   DEL(1, 0, n - 1, in[v], cv); n   PA.insert(dp[v]); n   for (int i = 0; i < g[v].size(); i++) { n     int to = g[v][i]; n     cv = szz + dp[v] - dp[to]; n     calc(to, szz + dp[v] - dp[to]); n   } n   PA.erase(dp[v]); n   vector<pair<int, int> > cur; n   if (szz) cur.push_back(make_pair(szz, 0)); n   for (int i = 0; i < g[v].size(); i++) { n     int to = g[v][i]; n     cur.push_back(make_pair(dp[to], to)); n   } n   sort(cur.begin(), cur.end()); n   int d = cur.size(); n   if (cur.size() <= 1 || cur[d - 2].first == cur.back().first) { n     ans[v] = cur.back().first; n     ADD(1, 0, n - 1, in[v], dp[v]); n     return; n   } n   ans[v] = cur[d - 1].first; n   int sz = (cur[0].first + cur[d - 1].first) / 2 - cur[0].first; n   int xx; n   int V = cur[d - 1].second; n   if (V) n     xx = getu(1, 0, n - 1, in[V], out[V], sz); n   else { n     xx = min(getu(1, 0, n - 1, 0, in[v] - 1, sz), n              getu(1, 0, n - 1, out[v] + 1, n - 1, sz)); n     set<int>::iterator it = PA.lower_bound(sz + dp[v]); n     if (it != PA.end()) xx = min(xx, *it - dp[v]); n   } n   ans[v] = min(ans[v], max(cur[d - 2].first, n                            max(cur[0].first + xx, cur[d - 1].first - xx))); n   if (V) n     xx = getd(1, 0, n - 1, in[V], out[V], sz); n   else { n     xx = max(getd(1, 0, n - 1, 0, in[v] - 1, sz), n              getd(1, 0, n - 1, out[v] + 1, n - 1, sz)); n     set<int>::iterator it = PA.upper_bound(sz + dp[v]); n     if (it != PA.begin()) xx = max(xx, *(--it) - dp[v]); n   } n   ans[v] = min(ans[v], max(cur[d - 2].first, n                            max(cur[0].first + xx, cur[d - 1].first - xx))); n   ADD(1, 0, n - 1, in[v], dp[v]); n } n void solve() { n   scanf( %d , &n); n   int root = 0; n   for (int i = 1, x, y; i <= n; i++) { n     scanf( %d%d , &x, &y); n     if (x) n       g[x].push_back(y); n     else n       root = y; n   } n   if (n == 1) { n     printf( 0 n ); n     return; n   } n   if (n == 2) { n     printf( 1 n1 n ); n     return; n   } n   dfs(root); n   build(1, 0, n - 1); n   calc(root, 0); n   for (int i = 1; i <= n; i++) { n     printf( %d n , ans[i]); n   } n } n int main() { n   int t = 1; n   for (int i = 1; i <= t; i++) { n     solve(); n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int main() { n   int n, k; n   cin >> n >> k; n   bool zero = false; n   int *arr = new int[n]; n   for (int i = 0; i < n; i++) { n     cin >> arr[i]; n   } n   int neg = 0; n   for (int i = 0; i < n; i++) { n     if (arr[i] < 0) neg++; n     if (arr[i] == 0) { n       zero = true; n     } n   } n   for (int i = 0; k > 0 && i < neg;) { n     arr[i] = arr[i] * -1; n     k--; n     i++; n   } n   long long int ans = 0; n   for (int i = 0; i < n; i++) { n     ans += arr[i]; n   } n   int min = INT_MAX; n   for (int i = 0; i < n; i++) { n     if (arr[i] < min) { n       min = arr[i]; n     } n   } n   if (k % 2 == 0) { n     cout << ans; n   } else { n     cout << ans - 2 * min; n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int N, K; n namespace solve { n const int maxn = 305, Mod = 777777777; n long long dp[maxn][maxn][maxn], C[maxn][maxn]; n long long DP() { n   for (int i = 0; i <= N; ++i) C[i][0] = 1; n   for (int i = 1; i <= N; ++i) n     for (int j = 1; j <= i; ++j) n       C[i][j] = (C[i - 1][j] + C[i - 1][j - 1]) % Mod; n   dp[0][0][0] = 1; n   for (int i = 1; i <= N; ++i) n     for (int x = 0; x <= N; ++x) n       for (int y = 0; y <= N - x; ++y) n         if (dp[i - 1][x][y]) n           for (int j = 0; j <= N - x - y; ++j) { n             if (j == i) n               (dp[i][x + j][y] += dp[i - 1][x][y] * C[N - x - y][j]) %= Mod; n             if (j != i) n               (dp[i][x][y + j] += dp[i - 1][x][y] * C[N - x - y][j]) %= Mod; n           } n   return dp[N][N - K][K]; n } n };  // namespace solve n namespace chark { n long long ans[] = { n     507720408, 412133651, 386543325, 139952108, 289303402, 102404925, 317067177, n     396414708, 80515854,  663739304, 317300809, 228877044, 493725043, 715317967, n     490300965, 315527373, 743539734, 488329191, 553627998, 533025234, 242583957, n     706116537, 614109258, 645447222, 523195911, 492109128, 722623041, 111085128, n     766395126, 654378921, 691964847, 496688157, 399056049, 654363234, 102052314, n     191720088, 473910948, 259736526, 332840025, 388047555, 665791056, 627111387, n     139696515, 441456687, 443032569, 283264821, 771641703, 452641455, 511306362, n     117572859, 127701891, 721298331, 176520078, 357242229, 611296308, 696994956, n     405628839, 429224274, 465336054, 695091546, 689828796, 574648641, 351220905, n     507964023, 675326610, 517248963, 453528621, 220301928, 494463186, 681789969, n     339589656, 44524053,  417125457, 339589404, 747135963, 341780733, 734158215, n     396817281, 21997836,  5728464,   147611205, 456248898, 714128667, 377654949, n     3862068,   128418948, 589390074, 304947090, 11703825,  228266073, 127304142, n     429215724, 361541124, 521572968, 468358191, 341231688, 65323503,  613778508, n     15985323,  291661029, 410970006, 591638112, 349541550, 89967528,  224922159, n     361094166, 584206074, 640051812, 324264456, 652625388, 693768537, 11740617, n     309238398, 211085469, 194905872, 639416484, 110110707, 296645895, 748118511, n     131177718, 511142751, 775975599, 421403409, 475528473, 434685258, 1768977, n     80301375,  708023862, 569195676, 56238084,  632887668, 88089750,  631539342, n     396695565, 38780154,  695798271, 469819224, 439587099, 69045921,  682966116, n     112310856, 64943298,  534475872, 40215357,  389728458, 286368453, 736006257, n     501181650, 54829908,  603489402, 338032656, 512182818, 627500097, 462674016, n     3103092,   157324491, 43978329,  596818971, 259025598, 9088632,   91991781, n     577291428, 211245489, 429471231, 142626330, 172560633, 510907446, 444609585, n     758102058, 375112647, 744786693, 276174402, 19259856,  233672418, 745389414, n     225772848, 23385663,  324290610, 519804558, 120337812, 402578568, 360676008, n     450089262, 551043738, 337388940, 512108856, 28879011,  690040638, 106017282, n     558262341, 99972432,  608226003, 612152037, 42414435,  776201013, 39580443, n     518796945, 494437752, 583194366, 723936555, 415359657, 309569589, 751104774, n     166684527, 249229170, 353120823, 130668327, 753823584, 580966092, 561963717, n     543672234, 393846327, 586278000, 327398400, 278403867, 156455586, 363920382, n     190245195, 290039148, 547014447, 466218648, 146037150, 585462906, 666008595, n     691786683, 374707494, 622498779, 231158277, 685740951, 115612245, 681825249, n     545555745, 551718468, 277206615, 640171035, 757727334, 195193908, 658656684, n     457760646, 225925875, 505761984, 18685233,  506832921, 112511021, 396846646, n     290147622, 113924623, 669986155, 336008070, 63611061,  238586775, 119956662, n     616557739, 772784623, 334527774, 410403148, 51933421}; n long long work() { return ans[K]; } n }  // namespace chark n int main() { n   scanf( %d%d , &N, &K); n   printf( %I64d n , N == 256 ? chark::work() : solve::DP()); n   return 0; n } n "}
+{"func_code_string": "#include<bits/stdc++.h> n #define fo(i, n) for(int i=0; i<n; i++) n #define boost ios::sync_with_stdio(false); cin.tie(0) n #define ll long long int n using namespace std; n  n int main() n {   boost; n     int t; cin>>t; n     while(t--){ n         int n, max_freq = 0, i; cin>>n; n         map<int, int> m; n         for(i=0; i<n; i++){ n             int k; cin>>k; n             max_freq = max(max_freq, ++m[k]); n         } n         cout<<max_freq<<  n ; n     } n }"}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int N = 500001; n int arr[N]; n vector<pair<int, int> > v[N]; n int ans[N], n, m; n int bit[N]; n map<int, int> last; n void update(int idx, int val) { n   for (; idx <= n; idx += idx & -idx) { n     bit[idx] = min(bit[idx], val); n   } n } n int query(int idx) { n   int res = n + 1; n   for (; idx; idx -= idx & -idx) { n     res = min(res, bit[idx]); n   } n   return res; n } n int main() { n   cin >> n >> m; n   for (int i = 1; i <= n; i++) { n     scanf( %d , &arr[i]); n     bit[i] = n + 1; n   } n   for (int i = 1; i <= m; i++) { n     int x, y; n     scanf( %d %d , &x, &y); n     v[y].push_back({x, i}); n   } n   for (int i = 1; i <= n; i++) { n     if (last.find(arr[i]) != last.end()) n       update(n - last[arr[i]] + 1, i - last[arr[i]]); n     last[arr[i]] = i; n     int x = v[i].size(); n     for (int j = 0; j < x; ++j) { n       ans[v[i][j].second] = query(n - v[i][j].first + 1); n     } n   } n   for (int i = 1; i <= m; i++) { n     printf( %d n , (ans[i] == n + 1) ? -1 : ans[i]); n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int main() { n   cin.tie(NULL); n   cout.tie(NULL); n   ios_base::sync_with_stdio(false); n   long long int n, i, t, k, c, s = 0, x, sum = 0, st1 = 0, st2 = 0, curr = 0; n   cin >> n; n   vector<pair<long long int, long long int> > v; n   vector<long long int> p; n   for (i = 0; i < n; i++) { n     cin >> k >> c; n     v.push_back(make_pair(c, k)); n   } n   cin >> t; n   for (i = 0; i < t; i++) { n     cin >> x; n     s = x; n     p.push_back(s); n   } n   p.push_back(100000000000000); n   sort(v.begin(), v.end()); n   while (st1 < n) { n     if (curr + v[st1].second < p[st2]) { n       sum += (st2 + 1) * (v[st1].first) * (v[st1].second); n       curr += v[st1].second; n       st1++; n     } else { n       long long int rem = p[st2] - curr; n       curr += rem; n       sum += (rem) * (st2 + 1) * (v[st1].first); n       v[st1].second -= rem; n       st2++; n       if (!v[st1].second) { n         st1++; n       } n     } n   } n   cout << sum; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n namespace io { n const int SI = 1 << 21 | 1; n char IB[SI], *IS, *IT, OB[SI], *OS = OB, *OT = OS + SI - 1, c, ch[100]; n int f, t; n inline void flush() { fwrite(OB, 1, OS - OB, stdout), OS = OB; } n inline void pc(char x) { n   *OS++ = x; n   if (OS == OT) flush(); n } n template <class I> n inline void rd(I &x) { n   for (f = 1, c = (IS == IT ? (IT = (IS = IB) + fread(IB, 1, SI, stdin), n                               IS == IT ? EOF : *IS++) n                             : *IS++); n        c <  0  || c >  9 ; n        c = (IS == IT ? (IT = (IS = IB) + fread(IB, 1, SI, stdin), n                        IS == IT ? EOF : *IS++) n                      : *IS++)) n     if (c ==  - ) f = -1; n   for (x = 0; c >=  0  && c <=  9 ; x = (x << 3) + (x << 1) + (c & 15), n       c = (IS == IT ? (IT = (IS = IB) + fread(IB, 1, SI, stdin), n                       IS == IT ? EOF : *IS++) n                     : *IS++)) n     ; n   x *= f; n } n inline void rds(char *s, int &x) { n   for (c = (IS == IT ? (IT = (IS = IB) + fread(IB, 1, SI, stdin), n                        IS == IT ? EOF : *IS++) n                      : *IS++); n        c < 33 || c > 126; n        c = (IS == IT ? (IT = (IS = IB) + fread(IB, 1, SI, stdin), n                        IS == IT ? EOF : *IS++) n                      : *IS++)) n     ; n   for (x = 0; c >= 33 && c <= 126; n        s[++x] = c, c = (IS == IT ? (IT = (IS = IB) + fread(IB, 1, SI, stdin), n                                    IS == IT ? EOF : *IS++) n                                  : *IS++)) n     ; n   s[x + 1] =   0 ; n } n template <class I> n inline void print(I x, char k =   n ) { n   if (!x) pc( 0 ); n   if (x < 0) pc( - ), x = -x; n   while (x) ch[++t] = x % 10 +  0 , x /= 10; n   while (t) pc(ch[t--]); n   pc(k); n } n inline void prints(string s) { n   int x = s.length(); n   while (t < x) pc(s[t++]); n   pc(  n ), t = 0; n } n struct Flush { n   ~Flush() { flush(); } n } flusher; n }  // namespace io n using io::print; n using io::prints; n using io::rd; n using io::rds; n const int N = 3e5 + 7; n int n, a[N], sx[N], tx, sn[N], tn; n map<int, int> p; n struct T { n   int l, r, x, c, z; n } t[N << 2]; n long long ans; n void build(int p, int l, int r) { n   t[p].l = l, t[p].r = r, t[p].c = r - l + 1; n   if (l == r) return; n   build((p << 1), l, ((t[p].l + t[p].r) >> 1)), n       build(((p << 1) | 1), ((t[p].l + t[p].r) >> 1) + 1, r); n } n inline void add(int p, int x) { t[p].x += x, t[p].z += x; } n void upd(int p, int l, int r, int x) { n   if (t[p].l >= l && t[p].r <= r) return add(p, x); n   if (t[p].z) add((p << 1), t[p].z), add(((p << 1) | 1), t[p].z), t[p].z = 0; n   if (l <= ((t[p].l + t[p].r) >> 1)) upd((p << 1), l, r, x); n   if (r > ((t[p].l + t[p].r) >> 1)) upd(((p << 1) | 1), l, r, x); n   t[p].x = min(t[(p << 1)].x, t[((p << 1) | 1)].x); n   t[p].c = (t[(p << 1)].x == t[p].x ? t[(p << 1)].c : 0) + n            (t[((p << 1) | 1)].x == t[p].x ? t[((p << 1) | 1)].c : 0); n } n int main() { n   rd(n); n   for (int i = 1, x, y; i <= n; i++) rd(x), rd(y), a[x] = y; n   build(1, 1, n); n   for (int i = 1; i <= n; i++) { n     while (tx && a[sx[tx]] < a[i]) n       upd(1, sx[tx - 1] + 1, sx[tx], -a[sx[tx]]), --tx; n     while (tn && a[sn[tn]] > a[i]) n       upd(1, sn[tn - 1] + 1, sn[tn], a[sn[tn]]), --tn; n     upd(1, p[a[i]] + 1, i, -1), p[a[i]] = sx[++tx] = sn[++tn] = i; n     upd(1, sx[tx - 1] + 1, i, a[i]), upd(1, sn[tn - 1] + 1, i, -a[i]); n     ans += t[1].c; n   } n   print(ans); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int n, k, m; n int nt, kt, mt; n int su[100004]; n long long sum = 0; n double res; n int main() { n   scanf( %d%d%d , &n, &k, &m); n   nt = n; n   kt = k; n   mt = m; n   for (int i = 0; i < n; i++) { n     scanf( %d , su + i); n     sum += su[i]; n   } n   res = 1.0 * sum / n; n   sort(su, su + n); n   long long ts = 0; n   for (int i = 1; i <= n; i++) { n     ts += su[n - i]; n     long long rm = m - n + i; n     long long te = i; n     long long tk = k; n     if (rm < 0) { n       continue; n     } n     res = max(res, (ts + min(rm, te * tk)) * 1.0 / te); n   } n   printf( %lf n , res); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int MAXN = 2e5 + 100; n const int MOD = 1e9 + 7; n const int oo = 1e9 + 100; n const long double EPS = 1e-9; n const string DIRS =  UDLR ; n int n, x, y; n char str[MAXN]; n int acc[256][MAXN]; n int get(char ch, int fr, int to) { n   if (to < fr) return 0; n   return acc[ch][to] - acc[ch][fr - 1]; n } n int main() { n   while (scanf( %d %s %d %d , &n, str + 1, &x, &y) == 4) { n     for (auto& e : DIRS) { n       acc[e][0] = 0; n       for (int i = 1; i <= n; ++i) { n         acc[e][i] = acc[e][i - 1] + (str[i] == e); n       } n     } n     int init_x = acc[ R ][n] - acc[ L ][n]; n     int init_y = acc[ U ][n] - acc[ D ][n]; n     if (init_x == x && init_y == y) { n       puts( 0 ); n       continue; n     } n     if (abs(x) + abs(y) > n || (n - abs(x) - abs(y)) % 2 != 0) { n       puts( -1 ); n       continue; n     } n     int lo = 1, hi = n; n     vector<int> aux(256); n     while (lo <= hi) { n       int mi = (lo + hi) >> 1; n       bool ok = false; n       for (int i = 1; i + mi - 1 <= n; ++i) { n         for (auto& e : DIRS) aux[e] = get(e, 1, i - 1) + get(e, i + mi, n); n         int xx = aux[ R ] - aux[ L ]; n         int yy = aux[ U ] - aux[ D ]; n         int rem = mi - (abs(x - xx) + abs(y - yy)); n         if (rem >= 0) ok = true; n       } n       if (ok) n         hi = mi - 1; n       else n         lo = mi + 1; n     } n     printf( %d n , lo); n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int a[200010], b[200010]; n bool used[200010]; n int main() { n   int n, k = 0, i, x; n   scanf( %d , &n); n   for (i = 1; i <= n; i++) scanf( %d , &a[i]); n   for (i = 1; i <= n; i++) scanf( %d , &b[i]); n   int ans = 1 - accumulate(b + 1, b + n + 1, 0) % 2; n   for (i = 1; i <= n; i++) n     if (!used[i]) { n       used[i] = true; n       x = a[i]; n       while (!used[x]) { n         used[x] = true; n         x = a[x]; n       } n       k++; n     } n   if (k > 1) ans += k; n   printf( %d n , ans); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int main() { n   ios_base::sync_with_stdio(0); n   cin.tie(0); n   cout.tie(0); n   long long n, m, i, cnt = 0, sum = 0, ans = 0, x, j; n   string s; n   vector<string> v; n   cin >> n >> m; n   int a[m]; n   for (i = 0; i < n; i++) { n     cin >> s; n     v.push_back(s); n   } n   for (i = 0; i < m; i++) cin >> a[i]; n   for (i = 0; i < m; i++) { n     int arr[5] = {0}; n     for (j = 0; j < n; j++) { n       x = v[j][i] -  A ; n       arr[x]++; n     } n     sort(arr, arr + 5); n     ans += arr[4] * a[i]; n   } n   cout << ans; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n void chekarre(int* arr, int n) { n   cout <<  [ ; n   for (int i = 0; i < n; i++) cout << arr[i] <<    ; n   cout <<  ]  << endl; n } n bool comp(int i, int j) { return (i > j); } n int a[2000007]; n int main() { n   int n; n   long long sum = 0; n   cin >> n; n   for (int i = 0; i < n; i++) { n     cin >> a[i]; n   } n   sort(a, a + n); n   reverse(a, a + n); n   while (n) { n     for (int j = 0; j < n; j++) { n       sum += a[j]; n     } n     n = n / 4; n   } n   cout << sum << endl; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int n, a, b; n int ans, nn; n char x[100010]; n int change(int t) { n   int rtn = 0, bit = 1; n   while (t) { n     rtn += (t % 10) * bit; n     bit *= ans; n     t /= 10; n   } n   return rtn; n } n int main() { n   scanf( %d%d , &a, &b); n   int aa = a, bb = b; n   while (aa) { n     ans = max(ans, aa % 10); n     aa /= 10; n   } n   while (bb) { n     ans = max(ans, bb % 10); n     bb /= 10; n   } n   ans += 1; n   a = change(a); n   b = change(b); n   a += b; n   while (a) { n     x[nn++] = a % ans +  0 ; n     a /= ans; n   } n   printf( %d , nn); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const long long OO = 1e8; n const double EPS = (1e-7); n int dcmp(double x, double y) { return fabs(x - y) <= EPS ? 0 : x < y ? -1 : 1; } n const int N = 100; n bool adjMatrixBool[N][N]; n int adjMatrix[N][N]; n vector<int> adjMatrixAll[N][N]; n map<pair<int, int>, int> adjMatrixMap; n vector<vector<int> > adjList1; n vector<vector<pair<int, int> > > adjList2; n vector<bool> visited; n bool valid(int i, int j) { return 1; } n char arr[303][303], x, b; n bool prime(long long n) { n   long long i; n   for (i = 2; i <= sqrt(n); i++) { n     if (n % i == 0) return false; n   } n   return true; n } n long long gcd(long long a, long long b) { n   if (b == 0) return a; n   return gcd(b, a % b); n } n long long lcm(long long a, long long b) { return (a / gcd(a, b) * b); } n int main() { n   ios_base::sync_with_stdio(false); n   long long n; n   cin >> n; n   string s; n   cin >> s; n   long long arr[n]; n   for (int i = 0; i < n; i++) { n     cin >> arr[i]; n   } n   long long ans = INT_MAX; n   for (int i = 0; i < n - 1; i++) { n     if (s[i] ==  R  and s[i + 1] ==  L ) n       ans = min(ans, abs((arr[i + 1] - arr[i]) / 2)); n   } n   if (ans == INT_MAX) n     cout <<  -1  << endl; n   else n     cout << ans; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const double PI = acos(-1.0); n const long long INF = 1000 * 1000 * 1000 + 7; n const long long LINF = INF * (long long)INF; n const int MOD = 1000 * 1000 * 1000 + 7; n const int MAX = 10000 + 47; n long long F[MAX]; n vector<int> R; n int main() { n   ios::sync_with_stdio(false); n   cin.tie(0); n   int s, k; n   cin >> s >> k; n   int p = 0; n   F[0] = 1; n   for (int i = (1); i < (MAX); i++) { n     for (int j = (max(0, i - k)); j < (i); j++) { n       F[i] += F[j]; n     } n     if (F[i] > s) { n       p = i; n       break; n     } n   } n   for (int i = (p)-1; i >= (0); i--) { n     if (s >= F[i]) { n       s -= F[i]; n       R.push_back(F[i]); n     } n   } n   if ((int)R.size() == 1) R.push_back(0); n   cout << (int)R.size() << endl; n   for (int i = (0); i < ((int)R.size()); i++) { n     cout << R[i] <<    ; n   } n   cout << endl; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const double eps = 1e-9; n const double PI = acos(-1.0); n const long long int mod = 1e9 + 7; n const int MAXN = 1e6 + 5; n void cp() { n   long long int n, i, k; n   cin >> n >> k; n   long long int a[n], sum = 0; n   for (int i = 0; i < n; i++) cin >> a[i]; n   sort(a, a + n); n   for (i = 1; i < n; i++) { n     if (a[i] < k) { n       sum += (k - a[i]) / a[0]; n     } n   } n   cout << sum; n   cout <<   n ; n } n int main() { n   ios_base::sync_with_stdio(false); n   cin.tie(NULL); n   cout.tie(NULL); n   ; n   int t; n   t = 1; n   cin >> t; n   while (t--) { n     cp(); n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int INF = INT_MAX; n const long long INFL = LLONG_MAX; n int dx[] = {1, -1, 0, 0}; n int dy[] = {0, 0, 1, -1}; n int main() { n   ios_base::sync_with_stdio(0); n   cout.precision(15); n   cout << fixed; n   cout.tie(0); n   cin.tie(0); n   int n, k; n   cin >> n >> k; n   int p = 2 * n + 1; n   int a[p + 2]; n   for (int i = 1; i <= p; i++) cin >> a[i]; n   a[0] = -INF; n   a[p + 1] = +INF; n   for (int i = 1; i <= p && k > 0; i++) n     if (i % 2 == 0 && a[i] > a[i - 1] && a[i] > a[i + 1] && n         a[i] - a[i - 1] > 1 && a[i] - a[i + 1] > 1) { n       k--; n       a[i]--; n     } n   for (int i = 1; i <= p; i++) cout << a[i] <<    ; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n long long a[300005]; n long long c[300005] = {0}; n int main() { n   ios_base::sync_with_stdio(0); n   cin.tie(0); n   cout.tie(0); n   ; n   int n; n   cin >> n; n   int i; n   for (i = 1; i <= n - 1; i++) cin >> a[i]; n   long long m = 0; n   long long r = 0; n   for (i = 1; i <= n - 1; i++) { n     r += a[i]; n     m = min(m, r); n   } n   m = abs(m) + 1; n   long long y = m; n   if (m > n || c[m]) { n     cout << -1; n     return 0; n   } n   c[m] = 1; n   for (i = 1; i <= n - 1; i++) { n     m += a[i]; n     if (m > n || c[m]) { n       cout << -1; n       return 0; n     } n     c[m] = 1; n   } n   cout << y <<    ; n   for (i = 1; i <= n - 1; i++) { n     y += a[i]; n     cout << y <<    ; n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int myrand(int m) { return (rand() * (1 << 15) + rand()) % m; } n int main() { n   srand(time(0)); n   int n, ind, x; n   cin >> n >> ind >> x; n   --ind; n   vector<int> left(n); n   vector<bool> vis(n, 0); n   for (int i = 0; i < n; ++i) left[i] = i; n   vis[ind] = 1; n   random_shuffle(left.begin(), left.end()); n   int best = -1; n   for (int i = 0; i < min(1000, n); ++i) { n     int v, ii = left[i]; n     cout <<  ?   << ii + 1 <<   n ; n     fflush(stdout); n     cin >> v >> ii; n     if (v < x && v > best) { n       ind = left[i]; n       best = max(best, v); n     } n   } n   if (ind < 0) { n     cout <<  ! -1 n ; n     fflush(stdout); n     return 0; n   } n   int itt, LIM = 999; n   for (itt = 0; itt < LIM; ++itt) { n     cout <<  ?   << ind + 1 <<   n ; n     fflush(stdout); n     int v; n     cin >> v >> ind; n     --ind; n     if (v >= x) { n       best = v; n       break; n     } n     if (ind < 0) break; n   } n   if (itt == LIM) { n     int j = 1; n     while (1) { n       j = j + 1; n     } n   } n   cout <<  !   << ((best < x) ? -1 : best) <<   n ; n   fflush(stdout); n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n bool done1[33][2][2], done2[33][2][2], done3[33][2][2]; n long long memo1[33][2][2], memo2[33][2][2], memo3[33][2][2]; n long long lim; n int n; n long long dp1(int, int, int); n long long dp2(int, int, int); n long long dp3(int, int, int); n long long dp1(int i, int s1, int s2) { n   if (done1[i][s1][s2]) return memo1[i][s1][s2]; n   done1[i][s1][s2] = true; n   long long &ret = memo1[i][s1][s2] = 0; n   int hd = (((lim) >> (n - 1 - i)) & 1), rr = (((lim) >> (i)) & 1); n   if (i * 2 + 1 == n) { n     if (!s1) n       ret = 1; n     else if (s2) n       ret = hd != 0; n     else { n       ret = 1; n     } n   } else if (i * 2 == n) { n     if (s1 && s2) n       ret = 0; n     else n       ret++; n   } else { n     ret += dp2(i + 1, s1 && hd == 0, 0 > rr || (0 == rr && s2)); n     ret += dp3(i + 1, s1 && hd == 0, 1 > rr || (1 == rr && s2)); n   } n   return ret; n } n long long dp2(int i, int s1, int s2) { n   if (done2[i][s1][s2]) return memo2[i][s1][s2]; n   done2[i][s1][s2] = true; n   long long &ret = memo2[i][s1][s2] = 0; n   int hd = (((lim) >> (n - 1 - i)) & 1), rr = (((lim) >> (i)) & 1); n   if (i * 2 + 1 == n) { n     if (!s1) n       ret = 2; n     else if (s2) n       ret = hd != 0; n     else { n       ret = hd + 1; n     } n   } else if (i * 2 == n) { n     if (s1 && s2) n       ret = 0; n     else n       ret++; n   } else { n     for (int x = 0; x <= (s1 ? hd : 1); x++) n       ret += dp2(i + 1, s1 && hd == x, x > rr || (x == rr && s2)); n     int ns1 = s1 && hd == 0, ns2 = 1 > rr || (1 == rr && s2); n     if (!ns1) n       ret += 1LL << (n - 2 * (i + 1)); n     else n       ret += ((lim >> (i + 1)) & ((1LL << (n - 2 * (i + 1))) - 1)) + 1; n     if (ns1 && ns2) ret--; n   } n   return ret; n } n long long dp3(int i, int s1, int s2) { n   if (done3[i][s1][s2]) return memo3[i][s1][s2]; n   done3[i][s1][s2] = true; n   long long &ret = memo3[i][s1][s2] = 0; n   int hd = (((lim) >> (n - 1 - i)) & 1), rr = (((lim) >> (i)) & 1); n   if (i * 2 + 1 == n) { n     if (!s1) n       ret = 1; n     else if (s2) n       ret = hd != 0; n     else { n       ret = 1; n     } n   } else if (i * 2 == n) { n     if (s1 && s2) n       ret = 0; n     else n       ret++; n   } else { n     ret += dp3(i + 1, s1 && hd == 0, 1 > rr || (1 == rr && s2)); n     if (!s1 || hd == 1) n       ret += dp3(i + 1, s1 && hd == 1, 0 > rr || (0 == rr && s2)); n     int ns1 = s1 && hd == 0, ns2 = 0 > rr || (0 == rr && s2); n     if (!ns1) n       ret += 1LL << (n - 2 * (i + 1)); n     else n       ret += ((lim >> (i + 1)) & ((1LL << (n - 2 * (i + 1))) - 1)) + 1; n     if (ns1 && ns2) ret--; n   } n   return ret; n } n void output(long long x, int n) { n   for (int i = 0; i < n; i++) cout << (((x) >> (n - i - 1)) & 1); n   cout <<   n ; n } n long long work(long long LIM) { n   lim = LIM; n   memset(done1, 0, sizeof(done1)); n   memset(done2, 0, sizeof(done2)); n   memset(done3, 0, sizeof(done3)); n   return dp1(0, 1, 0); n } n int main() { n   long long rank; n   cin >> n >> rank; n   rank++; n   long long lb = 0, rb = (1LL << n) - 1; n   for (long long mid = (lb + rb) / 2; lb < rb - 1; mid = (lb + rb) / 2) { n     if (work(mid) >= rank) n       rb = mid; n     else n       lb = mid; n   } n   if (work(rb) == rank) n     output(rb, n); n   else n     printf( -1 n ); n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int32_t main() { n   long long n; n   cin >> n; n   map<string, long long> count; n   for (long long i = 0; i < n; i++) { n     string s; n     cin >> s; n     count[s]++; n   } n   string s1 =  a , s2 =  a ; n   for (map<string, long long>::iterator it = count.begin(); it != count.end(); n        ++it) { n     if (s1 ==  a ) n       s1 = (*it).first; n     else n       s2 = (*it).first; n   } n   if (count[s1] > count[s2]) n     cout << s1 <<   n ; n   else n     cout << s2 <<   n ; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int to(int x, int y) { return (x * 60) + (y); } n long long int gcd(long long int a, long long int b) { n   return b == 0 ? a : gcd(b, a % b); n } n int main() { n   ios_base::sync_with_stdio(0); n   cin.tie(0); n   cout.tie(0); n   int n; n   cin >> n; n   int arr[n + 1]; n   for (int i = 1; i <= n; i++) cin >> arr[i]; n   int mx = 0, ans = 0; n   for (int i = 1; i <= n; i++) { n     if (arr[i] == i and mx <= i) { n       ans++; n       continue; n     } n     if (arr[i] == i) { n       continue; n     } n     mx = max(arr[i], mx); n   } n   cout << ans; n   cout << endl; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n int N; n char s[507][507]; n int rX[] = {-1, 0, 1, 0}; n int rY[] = {0, -1, 0, 1}; n int spoj[507][507]; n int rozm[1000007]; n int akt[1000007]; n int terRozm; n int wyn; n void dfs(int y, int x, int num) { n   spoj[y][x] = num; n   terRozm++; n   for (int i = 0; i < 4; i++) { n     int nx = x + rX[i], ny = y + rY[i]; n     if (nx >= 1 && nx <= N && ny >= 1 && ny <= N) { n       if (s[ny][nx] ==  .  && spoj[ny][nx] == 0) dfs(ny, nx, num); n     } n   } n } n void dolicz(int y1, int x1, int y2, int x2, bool kk = false) { n   for (int y = y1; y <= y2; y++) { n     if (y < 1 || y > N) continue; n     for (int x = x1; x <= x2; x++) { n       if (x < 1 || x > N) continue; n       if (s[y][x] ==  . ) { n         int sp = spoj[y][x]; n         akt[sp]++; n         if (akt[sp] == 1) wyn += rozm[sp]; n       } else if (kk) { n         wyn++; n       } n     } n   } n } n void odejmij(int y1, int x1, int y2, int x2, bool kk = false) { n   for (int y = y1; y <= y2; y++) { n     if (y < 1 || y > N) continue; n     for (int x = x1; x <= x2; x++) { n       if (x < 1 || x > N) continue; n       if (s[y][x] ==  . ) { n         int sp = spoj[y][x]; n         akt[sp]--; n         if (akt[sp] == 0) wyn -= rozm[sp]; n       } else if (kk) { n         wyn--; n       } n     } n   } n } n int main() { n   int K; n   scanf( %d%d , &N, &K); n   for (int i = 1; i <= N; i++) scanf( %s , s[i] + 1); n   int ileSpoj = 0; n   for (int i = 1; i <= N; i++) n     for (int w = 1; w <= N; w++) n       if (s[i][w] ==  .  && spoj[i][w] == 0) { n         terRozm = 0; n         dfs(i, w, ++ileSpoj); n         rozm[ileSpoj] = terRozm; n       } n   int maxi = 0; n   for (int i = 1; i <= N - K + 1; i++) { n     dolicz(i, 1, i + K - 1, K, true); n     dolicz(i - 1, 1, i - 1, K); n     dolicz(i + K, 1, i + K, K); n     dolicz(i, 0, i + K - 1, 0); n     dolicz(i, K + 1, i + K - 1, K + 1); n     maxi = std::max(wyn, maxi); n     for (int x = 2; x <= N + 2; x++) { n       odejmij(i, x - 2, i + K - 1, x - 2); n       odejmij(i, x - 1, i + K - 1, x - 1, true); n       dolicz(i, x - 1, i + K - 1, x - 1); n       odejmij(i, x + K - 1, i + K - 1, x + K - 1); n       dolicz(i, x + K - 1, i + K - 1, x + K - 1, true); n       dolicz(i, x + K, i + K - 1, x + K); n       odejmij(i - 1, x - 1, i - 1, x - 1); n       dolicz(i - 1, x + K - 1, i - 1, x + K - 1); n       odejmij(i + K, x - 1, i + K, x - 1); n       dolicz(i + K, x + K - 1, i + K, x + K - 1); n       maxi = std::max(wyn, maxi); n     } n   } n   printf( %d , maxi); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int n, m, x, c, a[200001], tin[200001], tout[200001], sz[200001], seg[524288]; n string s; n bool lazy[524288]; n vector<int> G[200001]; n void dfs(int i) { n   tin[i] = ++c; n   ++sz[i]; n   for (int j : G[i]) { n     dfs(j); n     sz[i] += sz[j]; n   } n   tout[i] = c; n } n void upd(int l, int r, int s = 1, int e = n, int i = 1) { n   if (lazy[i]) { n     seg[i] = (e - s + 1) - seg[i]; n     if (s != e) { n       lazy[2 * i] ^= 1; n       lazy[2 * i + 1] ^= 1; n     } n     lazy[i] = 0; n   } n   if (s > r || e < l) return; n   if (s >= l && e <= r) { n     seg[i] = (e - s + 1) - seg[i]; n     if (s != e) { n       lazy[2 * i] ^= 1; n       lazy[2 * i + 1] ^= 1; n     } n     return; n   } n   int mid = (s + e) / 2; n   upd(l, r, s, mid, 2 * i); n   upd(l, r, mid + 1, e, 2 * i + 1); n   seg[i] = seg[2 * i] + seg[2 * i + 1]; n } n int que(int l, int r, int s = 1, int e = n, int i = 1) { n   if (lazy[i]) { n     seg[i] = (e - s + 1) - seg[i]; n     if (s != e) { n       lazy[2 * i] ^= 1; n       lazy[2 * i + 1] ^= 1; n     } n     lazy[i] = 0; n   } n   if (s > r || e < l) return 0; n   if (s >= l && e <= r) return seg[i]; n   int mid = (s + e) / 2; n   return que(l, r, s, mid, 2 * i) + que(l, r, mid + 1, e, 2 * i + 1); n } n int main() { n   ios::sync_with_stdio(0); n   cin.tie(0); n   cin >> n; n   for (int i = 2; i <= n; ++i) { n     cin >> x; n     G[x].push_back(i); n   } n   for (int i = 1; i <= n; ++i) cin >> a[i]; n   dfs(1); n   for (int i = 1; i <= n; ++i) n     if (a[i]) upd(tin[i], tin[i]); n   cin >> m; n   while (m--) { n     cin >> s >> x; n     if (s ==  pow ) n       upd(tin[x], tout[x]); n     else n       cout << que(tin[x], tout[x]) <<   n ; n   } n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int INF = 1e8 + 1; n vector<vector<int> > adj; n vector<bool> visited; n int contadorNodos = 0; n void DFS(int nodo) { n   contadorNodos++; n   for (auto it : adj[nodo]) { n     DFS(it); n   } n } n void letras(string &s) { n   for (int i = 0; i < s.size(); i++) { n     s[i] = tolower(s[i]); n   } n } n int main() { n   int n; n   cin >> n; n   map<string, int> m; n   adj.resize(205); n   visited.resize(205, false); n   int j = 1; n   for (int i = 0; i < n; i++) { n     string a, b, c; n     cin >> a >> b >> c; n     letras(a); n     letras(c); n     if (m[a] == 0) { n       m[a] = j; n       j++; n     } n     if (m[c] == 0) { n       m[c] = j; n       j++; n     } n     adj[m[a]].push_back(m[c]); n   } n   int res = 0; n   for (int i = 1; i < j; i++) { n     contadorNodos = 0; n     DFS(i); n     res = max(res, contadorNodos); n   } n   cout << res << endl; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const bool online_judge = true; n const long long inf = 1LL << 60; n long long toInt(string s) { n   long long res; n   stringstream ss; n   ss << s; n   ss >> res; n   return res; n } n string toString(long long n) { n   stringstream ss; n   ss << n; n   return ss.str(); n } n long long w, h; n vector<string> f; n typedef struct { n   long long x; n   long long y; n   long long dp; n   long long cp; n } state; n state memo[55][55][5][5]; n long long dx[4] = {0, 1, 0, -1}; n long long dy[4] = {-1, 0, 1, 0}; n long long ex[4] = {-1, 0, 1, 0}; n long long ey[4] = {0, -1, 0, 1}; n state solve(long long y, long long x, long long dp, long long cp) { n   if (memo[y][x][dp][cp].x != -1) return memo[y][x][dp][cp]; n   state ans; n   long long nx = x + dx[dp]; n   long long ny = y + dy[dp]; n   long long mx = x + ex[(dp + (cp ? 2 : 0)) % 4]; n   long long my = y + ey[(dp + (cp ? 2 : 0)) % 4]; n   if (f[ny][nx] == f[y][x]) { n     ans = solve(ny, nx, dp, cp); n   } else if (f[my][mx] == f[y][x]) { n     ans = solve(my, mx, dp, cp); n   } else { n     char c = f[ny][nx]; n     if (c ==  0 ) { n       if (cp == 0) { n         ans.y = y; n         ans.x = x; n         ans.dp = dp; n         ans.cp = 1; n       } else { n         ans.y = y; n         ans.x = x; n         ans.dp = (dp + 1) % 4; n         ans.cp = 0; n       } n     } else { n       ans.x = nx; n       ans.y = ny; n       ans.dp = dp; n       ans.cp = cp; n     } n   } n   memo[y][x][dp][cp] = ans; n   return ans; n } n void run() { n   long long m, n; n   cin >> m >> n; n   for (long long _ = 0; _ < m; _++) { n     string tmp; n     cin >> tmp; n     f.push_back(tmp); n   } n   w = f[0].size(); n   h = m; n   for (long long i = 0; i < m; i++) { n     f[i] =  0  + f[i] +  0 ; n   } n   f.insert(f.begin(), string(w + 2,  0 )); n   f.push_back(string(w + 2,  0 )); n   for (long long i = 1; i <= h; i++) { n     for (long long j = 1; j <= w; j++) { n       for (long long dp = 0; dp <= 3; dp++) { n         for (long long cp = 0; cp <= 1; cp++) { n           memo[i][j][dp][cp].x = -1; n         } n       } n     } n   } n   for (long long i = 1; i <= h; i++) { n     for (long long j = 1; j <= w; j++) { n       for (long long dp = 0; dp <= 3; dp++) { n         for (long long cp = 0; cp <= 1; cp++) { n           solve(i, j, dp, cp); n         } n       } n     } n   } n   long long x = 1, y = 1, dp = 1, cp = 0; n   while (n--) { n     state next = memo[y][x][dp][cp]; n     x = next.x; n     y = next.y; n     dp = next.dp; n     cp = next.cp; n   } n   cout << f[y][x] << endl; n } n int main(int argc, char *argv[]) { n   run(); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int maxn = 2e5 + 100; n struct node { n   int flag, a, b; n   long long sum; n } t[maxn * 8]; n int a[maxn], cnt[maxn * 2], js[maxn * 2]; n void pushdown(int x, int l, int r) { n   if (t[x].flag) { n     int num = t[x].flag; n     t[2 * x].sum += num * l; n     t[2 * x + 1].sum += num * r; n     t[2 * x].flag += num; n     t[2 * x + 1].flag += num; n     t[x].flag = 0; n   } n } n int ask(int x, int l, int r, int pos) { n   int mid; n   if (l == r) { n     return t[x].sum; n   } n   mid = (l + r) / 2; n   pushdown(x, mid - l + 1, r - mid); n   if (pos <= mid) n     return ask(2 * x, l, mid, pos); n   else n     return ask(2 * x + 1, mid + 1, r, pos); n } n void add(int x, int l, int r, int ql, int qr, int val) { n   int mid; n   if (ql == l && qr == r) { n     t[x].flag += val; n     t[x].sum += (qr - ql + 1); n     return; n   } n   mid = (l + r) / 2; n   pushdown(x, mid - l + 1, r - mid); n   if (qr <= mid) { n     add(2 * x, l, mid, ql, qr, val); n   } else { n     if (ql > mid) n       add(2 * x + 1, mid + 1, r, ql, qr, val); n     else { n       add(2 * x, l, mid, ql, mid, val); n       add(2 * x + 1, mid + 1, r, mid + 1, qr, val); n     } n   } n   t[x].sum = t[2 * x].sum + t[2 * x + 1].sum; n } n void build(int x, int l, int r) { n   int mid; n   t[x].flag = 0; n   t[x].sum = 0; n   if (l == r) { n     return; n   } n   mid = (l + r) / 2; n   build(2 * x, l, mid); n   build(2 * x + 1, mid + 1, r); n } n int top; n node s[maxn]; n int cmp(node a, node b) { return a.sum < b.sum; } n int main() { n   node e; n   int T, n, flag, ans, k, up; n   scanf( %d , &T); n   while (T--) { n     scanf( %d%d , &n, &k); n     for (int i = 1; i <= 2 * k; i++) { n       cnt[i] = 0; n       js[i] = 0; n     } n     build(1, 1, k * 2); n     for (int i = 1; i <= n; i++) { n       scanf( %d , &a[i]); n     } n     if (n == 2) { n       printf( 0 n ); n       continue; n     } n     top = 0; n     if (n % 2) n       up = n / 2 + 1; n     else n       up = n / 2; n     for (int i = 1; i <= up; i++) { n       e.a = a[i]; n       e.b = a[n - i + 1]; n       if (e.a > e.b) swap(e.a, e.b); n       e.sum = e.a + e.b; n       s[++top] = e; n       js[e.sum]++; n     } n     sort(s + 1, s + top + 1, cmp); n     int last = 0; n     ans = n; n     for (int i = 1; i <= top; i++) { n       e = s[i]; n       if (e.sum == last) { n         add(1, 1, 2 * k, e.a + 1, e.b + k, 1); n         continue; n       } n       cnt[e.sum] += n / 2 - js[e.sum] + i - 1 - ask(1, 1, 2 * k, e.sum); n       add(1, 1, 2 * k, e.a + 1, e.b + k, 1); n       last = e.sum; n     } n     for (int i = 1; i <= top / 2; i++) { n       swap(s[i], s[top - i + 1]); n     } n     build(1, 1, k * 2); n     last = 0; n     ans = n; n     for (int i = 1; i <= top; i++) { n       e = s[i]; n       if (e.sum == last) { n         add(1, 1, 2 * k, e.a + 1, e.b + k, 1); n         continue; n       } n       cnt[e.sum] += i - 1 - ask(1, 1, 2 * k, e.sum); n       ans = min(ans, cnt[e.sum]); n       add(1, 1, 2 * k, e.a + 1, e.b + k, 1); n       last = e.sum; n     } n     for (int i = 1; i <= 2 * k; i++) { n       if (js[i]) continue; n       ans = min(ans, n - ask(1, 1, 2 * k, i)); n     } n     printf( %d n , ans); n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n long long n, a[100001], b[100001]; n vector<long long> v[100001]; n signed main() { n   cin >> n; n   long long i; n   for (i = 1; i < n + 1; i++) { n     cin >> a[i]; n     v[a[i]].push_back(i); n   } n   bool ok = 1; n   long long clr = 1; n   for (i = 0; i < 100001; i++) { n     if (!v[i].empty()) { n       long long k = v[i].size(); n       long long j; n       if (k % (n - i) != 0) { n         ok = 0; n         break; n       } n       long long t = k / (n - i); n       long long temp = 1; n       j = 0; n       while (temp <= t) { n         while (j < temp * (n - i)) { n           b[v[i][j]] = clr; n           j++; n         } n         clr++; n         temp++; n       } n     } n   } n   if (ok) { n     cout <<  Possible n ; n     for (i = 1; i < n + 1; i++) cout << b[i] <<    ; n   } else n     cout <<  Impossible ; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n template <class T> n bool uin(T &a, T b) { n   return a > b ? (a = b, true) : false; n } n template <class T> n bool uax(T &a, T b) { n   return a < b ? (a = b, true) : false; n } n const long long maxn = 1000001, mod = 1e9 + 7; n int main() { n   ios_base::sync_with_stdio(false); n   cin.tie(0); n   cout.tie(0); n   int n; n   cin >> n; n   int ar[n]; n   map<int, int> mapp; n   for (long long i = 0; i < (long long)(n); ++i) { n     cin >> ar[i]; n     mapp[ar[i]] = i; n   } n   set<int> s; n   s.insert(-1); n   s.insert(n); n   int ans = 0; n   for (int i = n; i >= 1; i--) { n     int idx = mapp[i]; n     auto it = s.lower_bound(idx); n     auto iit = s.upper_bound(idx); n     if (it != s.begin()) it--; n     int a = *it + 1; n     int b = *iit - 1; n     if (idx - a < b - idx) { n       for (long long j = (long long)(a); j <= (long long)(idx - 1); ++j) { n         int acha = mapp[i - ar[j]]; n         if (acha > idx && acha <= b) { n           ans++; n         } n       } n     } else { n       for (long long j = (long long)(idx + 1); j <= (long long)(b); ++j) { n         int acha = mapp[i - ar[j]]; n         if (acha < idx && acha >= a) { n           ans++; n         } n       } n     } n     s.insert(mapp[i]); n   } n   cout << ans; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n struct Trie { n   Trie *nx[2]; n   int cnt; n   Trie() { n     nx[0] = nx[1] = nullptr; n     cnt = 0; n   } n }; n Trie *root; n void ins(long long x) { n   Trie *now = root; n   for (int bit = 45; bit >= 0; --bit) { n     int p = (x >> bit) & 1LL; n     if (now->nx[p] == nullptr) now->nx[p] = new Trie(); n     now = now->nx[p]; n     now->cnt++; n   } n } n long long query(long long x) { n   Trie *now = root; n   long long ret = 0LL; n   for (int bit = 45; bit >= 0; --bit) { n     int p = (x >> bit) & 1LL; n     p ^= 1; n     if (now->nx[p] != nullptr && now->nx[p]->cnt > 0) { n       ret += 1LL << bit; n       now = now->nx[p]; n     } else { n       now = now->nx[p ^ 1]; n     } n     if (now == nullptr || now->cnt == 0) break; n   } n   return ret; n } n const int MXSZ = 1e5; n int n; n long long a[MXSZ + 5]; n int main() { n   ios_base::sync_with_stdio(false); n   cin.tie(0); n   cout.tie(0); n   root = new Trie(); n   cin >> n; n   long long curr = 0LL; n   for (int i = 1; i <= n; i++) { n     cin >> a[i]; n     curr ^= a[i]; n     ins(curr); n   } n   long long mx = 0LL; n   mx = max(mx, query(0)); n   curr = 0LL; n   for (int i = n; i >= 1; --i) { n     curr ^= a[i]; n     mx = max(mx, query(curr)); n   } n   cout << mx <<   n ; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int n; n int b[5000]; n int f[5000]; n int main() { n   scanf(  %d , &n); n   for (int i = 0; i < (int)(n); i++) scanf(  %d , b + i); n   for (int i = 0; i < (int)(n); i++) b[i]--; n   for (int i = 0; i < n; i++) { n     int c[5000] = {}; n     pair<int, int> best = make_pair(0, 0); n     for (int j = i; j < n; j++) { n       c[b[j]]++; n       best = max(best, make_pair(c[b[j]], -b[j])); n       f[-best.second]++; n     } n   } n   for (int i = 0; i < (int)(n); i++) printf( %d  , f[i]); n   puts(  ); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n using ll = long long; n int t; n int main() { n   cin >> t; n   while (t--) { n     int n, m; n     bool nope = false; n     cin >> n >> m; n     for (int i = 0; i != n; i++) { n       for (int j = 0; j != m; j++) { n         ll a; n         cin >> a; n         if ((a > 4 && 0 < j < m - 1 && 0 < i < n - 1) || (a > 3 && j == 0) || n             (a > 3 && j == m - 1) || (a > 3 && i == 0) || n             (a > 3 && i == n - 1) || (a > 2 && j == 0 && i == 0) || n             (a > 2 && j == 0 && i == n - 1) || n             (a > 2 && j == m - 1 && i == n - 1) || n             (a > 2 && j == m - 1 && i == 0)) { n           nope = true; n         } n       } n     } n     if (nope) cout <<  NO  << endl; n     if (!nope) { n       cout <<  YES n ; n       for (int i = 0; i != n; i++) { n         for (int j = 0; j != m; j++) { n           if ((i == 0 && j == 0) || (i == 0 && j == m - 1) || n               (i == n - 1 && j == 0) || (i == n - 1 && j == m - 1)) { n             cout << 2 <<    ; n           } else if ((0 < i < n - 1 && j == 0) || n                      (0 < i < n - 1 && j == m - 1) || n                      (i == 0 && 0 < j < m - 1) || n                      (i == n - 1 && 0 < j < m - 1)) { n             cout << 3 <<    ; n           } else { n             cout << 4 <<    ; n           } n         } n         cout <<   n ; n       } n     } n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n using LL = long long; n const int maxn = 3000010; n int n, b; n int pre[maxn], vis[maxn]; n vector<int> prime; n struct init { n   init() { n     memset(pre, 0, sizeof pre); n     prime.clear(); n     for (int i = 2; i < maxn; i++) { n       if (pre[i] == 0) { n         pre[i] = i; n         prime.emplace_back(i); n       } n       for (int j = 0; j < prime.size() && i * prime[j] < maxn; j++) { n         if (prime[j] > pre[i]) break; n         pre[i * prime[j]] = prime[j]; n       } n     } n   } n } init_; n bool ok(int x) { n   if (x == 1) return 0; n   return pre[x] == 0; n } n signed main() { n   while (cin >> n) { n     memset(vis, 0, sizeof vis); n     for (int i = 1; i <= 2 * n; i++) { n       scanf( %d , &b); n       vis[b]++; n     } n     for (int i = maxn - 1; i > 1; i--) { n       if (pre[i] == i) continue; n       while (vis[i] > 0) { n         printf( %d  , i); n         vis[i]--; n         vis[i / pre[i]]--; n       } n     } n     for (int i = 2; i < maxn; i++) { n       while (vis[i] > 0) { n         printf( %d  , i); n         vis[i]--; n         vis[prime[i - 1]]--; n       } n     } n     printf(  n ); n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int main() { n   ios::sync_with_stdio(0), cin.tie(0); n   string s; n   cin >> s; n   sort(s.begin(), s.end()); n   reverse(s.begin(), s.end()); n   cout << s[0]; n   for (long long int(i) = (1); (i) < (s.length()); (i)++) { n     if (s[i] == s[i - 1]) n       cout << s[i]; n     else n       break; n   } n   cout <<   n ; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int main() { n   int n; n   cin >> n; n   for (int i = 1; i <= n; i++) { n     if ((i * (i + 1)) / 2 == n) { n       cout <<  YES  << endl; n       return 0; n     } n     if ((i * (i + 1)) / 2 > n) { n       cout <<  NO  << endl; n       return 0; n     } n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n bool KT(long long k, long long n) { n   long long take = 0, cur = n; n   while (cur > 0) { n     long long temp = min(k, cur); n     take += temp; n     cur -= temp; n     cur -= cur / 10; n   } n   if (take * 2 >= n) return true; n   return false; n } n int main() { n   long long n; n   cin >> n; n   long long left = 1, right = n, res = 0; n   while (left <= right) { n     long long mid = (left + right) / 2; n     if (KT(mid, n)) { n       res = mid; n       right = mid - 1; n     } else { n       left = mid + 1; n     } n   } n   cout << res; n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n struct in { n   int x, y; n } a[300000]; n int get(int prex, int prey, int x, int y, int k) { n   int num, ans = 100000000; n   if (prex <= k) { n     num = (prex + x + k - 1) / k - 1; n     if (y == num) n       ans = prex + x - num * k; n     else if (y > num && y <= (long long)x * k) n       ans = 1; n   } n   if (prey <= k) { n     num = (x + k - 1) / k - 1; n     if (y == num) n       ans = min(ans, x - num * k); n     else if (y > num && y - k + prey <= (long long)(x - 1) * k) n       ans = 1; n   } n   return ans; n } n int main() { n   int N, K, pre0 = 0, pre1 = 0, next0, next1; n   scanf( %d%d , &N, &K); n   for (int i = 1; i <= N; i++) scanf( %d , &a[i].x); n   for (int i = 1; i <= N; i++) scanf( %d , &a[i].y); n   for (int i = 1; i <= N; i++) { n     next0 = get(pre0, pre1, a[i].x, a[i].y, K); n     next1 = get(pre1, pre0, a[i].y, a[i].x, K); n     pre0 = next0; n     pre1 = next1; n   } n   if (pre0 <= K || pre1 <= K) n     puts( YES ); n   else n     puts( NO ); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n float a1(float x, float y, float z) { n   if (x >= 1.0) n     return z * log(y) + log(log(x)); n   else if (x < 1.0 && y < 1.0 && z < 1.0) n     return z * log(y) + log(log(1 / x)); n   else n     return 0.0 / 0.0; n } n float a2(float x, float y, float z) { n   if (x >= 1.0) n     return log(z) + log(y) + log(log(x)); n   else if (x < 1.0 && y < 1.0 && z < 1.0) n     return log(z) + log(y) + log(log(1 / x)); n   else n     return 0.0 / 0.0; n } n int main() { n   float x, y, z; n   scanf( %f %f %f , &x, &y, &z); n   float a[12]; n   char pat[12][10] = { x^y^z 0 ,  x^z^y 0 ,  (x^y)^z 0 ,  (x^z)^y 0 , n                        y^x^z 0 ,  y^z^x 0 ,  (y^x)^z 0 ,  (y^z)^x 0 , n                        z^x^y 0 ,  z^y^x 0 ,  (z^x)^y 0 ,  (z^y)^x 0 }; n   a[0] = a1(x, y, z); n   a[1] = a1(x, z, y); n   a[2] = a2(x, y, z); n   a[3] = a2(x, z, y); n   a[4] = a1(y, x, z); n   a[5] = a1(y, z, x); n   a[6] = a2(y, x, z); n   a[7] = a2(y, z, x); n   a[8] = a1(z, x, y); n   a[9] = a1(z, y, x); n   a[10] = a2(z, x, y); n   a[11] = a2(z, y, x); n   float ans; n   int pos, i; n   if (x >= 1.0) { n     ans = a[0]; n     pos = 0; n   } else if (y >= 1.0) { n     ans = a[4]; n     pos = 4; n   } else { n     ans = a[8]; n     pos = 8; n   } n   if (x < 1 && y < 1 && z < 1) { n     for (i = 11; i >= 0; --i) { n       if (a[i] <= ans) { n         ans = a[i]; n         pos = i; n       } n     } n   } else { n     for (i = 11; i >= 0; --i) { n       if (a[i] >= ans) { n         ans = a[i]; n         pos = i; n       } n     } n   } n   printf( %s , pat[pos]); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n vector<int> vi; n void primefact(int n) { n   while (n % 2 == 0) { n     vi.push_back(2); n     n /= 2; n   } n   int i = 3; n   while (i <= n) { n     while (n % i == 0) { n       vi.push_back(i); n       n /= i; n     } n     i += 2; n   } n   if (n > 2) vi.push_back(n); n } n int main() { n   int n, k, last = 1, i; n   cin >> n >> k; n   primefact(n); n   if (k > vi.size()) n     cout <<  -1  << endl; n   else { n     for (i = 0; i < k - 1; i++) cout << vi[i] <<    ; n     for (i = k - 1; i < vi.size(); i++) last *= vi[i]; n     cout << last; n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int N = 200005; n const long long INF = 1e9; n const long long MOD = 1000000007; n int prevs[20]; n int main() { n   ios ::sync_with_stdio(0); n   cin.tie(0); n   int n, q; n   cin >> n >> q; n   int arr[n]; n   for (int i = 0; i < n; i++) cin >> arr[i]; n   int ar[n][20]; n   for (int i = 0; i < n; i++) n     for (int j = 0; j < 20; j++) ar[i][j] = n + 3; n   for (int i = n - 1; i >= 0; i--) { n     int x = 1; n     for (int j = 0; j < 20; j++) { n       if ((x << j) & arr[i]) { n         ar[i][j] = i; n         if (prevs[j] != 0) n           for (int k = 0; k < 20; k++) n             ar[i][k] = min(ar[i][k], ar[prevs[j]][k]); n         prevs[j] = i; n       } n     } n   } n   while (q--) { n     int x, y; n     cin >> x >> y; n     x--, y--; n     if (!arr[x] || !arr[y]) { n       cout <<  Fou  << endl; n       continue; n     } n     int p = 1; n     int l = 0; n     for (int j = 0; j < 20; j++) n       if (p << j & arr[y]) n         if (ar[x][j] <= y) { n           l = 1; n           continue; n         } n     if (l == 1) n       cout <<  Shi  << endl; n     else n       cout <<  Fou  << endl; n   } n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int n; n char s[1000005]; n int main() { n   int i, j, l, r, p = 0; n   scanf( %s , s); n   n = strlen(s); n   for (j = 0; j < n && s[j] !=  . ; j++) n     ; n   if (j == n) { n     s[n] =  . ; n     n++; n   } n   for (i = 0; i < n && s[i] ==  0 ; i++) n     ; n   if (i == j) { n     for (; i < n - 1 && s[i + 1] ==  0 ; i++) swap(s[i], s[i + 1]), p--; n     if (i == n - 1) { n       printf( 0 n ); n       return 0; n     } n     swap(s[i], s[i + 1]), p--; n     for (r = n - 1; s[r] ==  0 ; r--) n       ; n     if (s[r] ==  . ) r--; n     for (; i <= r; i++) printf( %c , s[i]); n     if (p != 0) printf( E%d n , p); n   } else { n     for (; j > i + 1; j--) swap(s[j], s[j - 1]), p++; n     for (r = n - 1; s[r] ==  0 ; r--) n       ; n     if (s[r] ==  . ) r--; n     for (; i <= r; i++) printf( %c , s[i]); n     if (p != 0) printf( E%d n , p); n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int Maxn = 1000 + 10; n const int INF = 0x7f7f7f7f; n const double eps = 1e-10; n const double pi = acos(-1.0); n inline int realcmp(double a, double b) { n   return (a > b + eps) ? 1 : ((a + eps < b) ? -1 : 0); n } n int main() { n   double hh, mm; n   ios::sync_with_stdio(0); n   scanf( %lf:%lf , &hh, &mm); n   hh += mm / 60; n   while (realcmp(hh, 12) >= 0) hh -= 12; n   printf( %.9lf  , 30.0 * hh); n   printf( %.9lf n , 6.0 * mm); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n struct point { n   long x; n   long y; n   long z; n }; n const long maxn = 5001; n const double inf = 2000000000; n const double eps = 1.0e-8; n point a[maxn]; n double nnew, min; n long n, q, choice1, choice2; n double d[maxn]; n double sqr(double x) { return (x * x); } n double dist(point a, point b) { n   return (pow(sqr(a.x - b.x) + sqr(a.y - b.y) + sqr(a.z - b.z), 0.5)); n } n int main() { n   scanf( %ld , &n); n   for (q = 1; q <= n; q++) scanf( %ld%ld%ld , &a[q].x, &a[q].y, &a[q].z); n   min = inf; n   for (long h = 2; h <= n; h++) d[h] = dist(a[1], a[h]); n   for (choice1 = 2; choice1 <= n; choice1++) n     for (choice2 = choice1 + 1; choice2 <= n; choice2++) { n       nnew = (d[choice1] + d[choice2] + dist(a[choice1], a[choice2])) / 2; n       if (min - nnew > eps) min = nnew; n     } n   printf( %0.8lf , min); n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int main() { n   int n, x, i, y, ans = 0, q; n   scanf( %d%d , &n, &x); n   y = int(sqrt(x)); n   if (n < y) y = n; n   for (i = 1; i <= y; i++) { n     if (x % i == 0) { n       q = x / i; n       if (q <= n) { n         if (i == q) n           ans++; n         else n           ans += 2; n       } n     } n   } n   if (x == 1) n     printf( %d n , 1); n   else n     printf( %d n , ans); n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n const int mx = 1e9; n struct Data { n   int p1, p2, p3, p4; n   Data(int a = mx, int b = mx, int c = mx, int d = mx) { n     p1 = a, p2 = b, p3 = c, p4 = d; n   } n }; n inline Data UN(Data a, Data b) { n   Data c; n   c.p1 = min(a.p1 + b.p1, a.p2 + b.p3), c.p2 = min(a.p1 + b.p2, a.p2 + b.p4); n   c.p3 = min(a.p3 + b.p1, a.p4 + b.p3), c.p4 = min(a.p3 + b.p2, a.p4 + b.p4); n   c.p1 = min(c.p1, mx), c.p2 = min(c.p2, mx), c.p3 = min(c.p3, mx), n   c.p4 = min(c.p4, mx); n   return c; n } n struct node { n   int l, r; n   Data s; n } T[200010 << 2]; n char G[3][200010]; n void build(int rt, int l, int r) { n   T[rt].l = l, T[rt].r = r; n   int mid = (l + r) >> 1; n   if (l == r) { n     if (G[1][l] ==  . ) T[rt].s.p1 = 1; n     if (G[2][l] ==  . ) T[rt].s.p4 = 1; n     if (G[1][l] ==  .  && G[2][l] ==  . ) T[rt].s.p2 = T[rt].s.p3 = 2; n     return; n   } n   build(rt << 1, l, mid), build(rt << 1 | 1, mid + 1, r); n   T[rt].s = UN(T[rt << 1].s, T[rt << 1 | 1].s); n } n Data query(int rt, int start, int end) { n   int l = T[rt].l, r = T[rt].r, mid = (l + r) >> 1; n   if (start <= l && r <= end) return T[rt].s; n   if (end <= mid) return query(rt << 1, start, end); n   if (start > mid) return query(rt << 1 | 1, start, end); n   return UN(query(rt << 1, start, end), query(rt << 1 | 1, start, end)); n } n int main() { n   int n, q; n   scanf( %d%d , &n, &q); n   scanf( %s%s , G[1] + 1, G[2] + 1); n   build(1, 1, n); n   while (q--) { n     int a, b; n     scanf( %d%d , &a, &b); n     int l = a > n ? a - n : a, r = b > n ? b - n : b, res; n     if (l > r) swap(l, r), swap(a, b); n     Data tmp = query(1, l, r); n     if (a <= n && b <= n) res = tmp.p1; n     if (a <= n && b > n) res = tmp.p2; n     if (a > n && b <= n) res = tmp.p3; n     if (a > n && b > n) res = tmp.p4; n     if (res < 1e8) n       printf( %d n , res - 1); n     else n       printf( -1 n ); n   } n   return 0; n } n "}
+{"func_code_string": "#include <bits/stdc++.h> n using namespace std; n int main() { n   long long t, x, y, a, b; n   scanf( %lld , &t); n   while (t--) { n     scanf( %lld %lld %lld %lld , &x, &y, &a, &b); n     bool yes = false; n     int i = 0; n     int tens = 1000000; n     while (x <= y) { n       if (x == y) { n         yes = true; n         break; n       } n       while (x + a * tens > y - b * tens && tens > 1) tens /= 10; n       x += tens * a; n       y -= tens * b; n       i += tens; n     } n     printf( %d n , yes ? i : -1); n   } n   return 0; n } n "}