cpp_dataset/validation/validation.jsonl

{"func_code_string": "#include <bits/stdc++.h>\n using namespace std;\n const double PI = acos(-1.0);\n const double EPS = 1e-7;\n const long long BIG_PRIME7 = 1000000007;\n const long long BIG_PRIME9 = 1000000009;\n int gcd(int x, int y) { return y ? gcd(y, x % y) : x; }\n char ch = 'a';\n int j, n, m, L, i;\n int N, C;\n int x, y, z, k;\n string f, s;\n int a[101], b[101];\n int main() {\n   cin >> x;\n   for (i = 0; i < x; i++) {\n     cin >> k;\n     if (k & 1) z++;\n   }\n   if (!(z & 1))\n     cout << (x - z);\n   else\n     cout << z;\n   return 0;\n }\n "}
{"func_code_string": "#include <bits/stdc++.h>\n using namespace std;\n const int N = 111111;\n int last[3 * N], pre[3 * N], v[3 * N], cnt[3 * N], cur = 0;\n inline void add(int a, int b) {\n   pre[cur] = last[a];\n   v[cur] = b;\n   last[a] = cur;\n   cur++;\n }\n set<int>* who[N];\n inline set<int>* merge(set<int>*& a, set<int>*& b) {\n   if (a->size() < b->size()) {\n     return merge(b, a);\n   } else {\n     for (set<int>::iterator it = b->begin(); it != b->end(); it++) {\n       if (a->find(-*it) != a->end()) {\n         a->erase(-*it);\n       } else {\n         a->insert(*it);\n       }\n     }\n     b->clear();\n     return a;\n   }\n }\n int used[N];\n void dfs(int u) {\n   used[u] = true;\n   for (int i = last[u]; i >= 0; i = pre[i])\n     if (!used[v[i]]) {\n       dfs(v[i]);\n       cnt[i ^ 1] = cnt[i] = who[v[i]]->size();\n       who[u] = merge(who[u], who[v[i]]);\n     }\n }\n set<int>* mem[N];\n int main() {\n   memset(last, -1, sizeof(last));\n   int n;\n   scanf( %d , &n);\n   for (int i = (0); i <= ((n - 1) - 1); i++) {\n     int u, v;\n     scanf( %d%d , &u, &v);\n     u--;\n     v--;\n     add(u, v);\n     add(v, u);\n   }\n   for (int i = (0); i <= ((n)-1); i++) mem[i] = who[i] = new set<int>();\n   int k;\n   scanf( %d , &k);\n   for (int i = (1); i <= ((k)); i++) {\n     int u, v;\n     scanf( %d%d , &u, &v);\n     u--;\n     v--;\n     if (u != v) {\n       who[u]->insert(i);\n       who[v]->insert(-i);\n     }\n   }\n   dfs(0);\n   for (int i = 0; i < cur; i += 2) {\n     if (i) printf(   );\n     printf( %d , cnt[i]);\n   }\n   puts(  );\n   for (int i = (0); i <= ((n)-1); i++) delete (mem[i]);\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 INF = 1e9 + 7;\n const int base = 1e9;\n const int MAX = 1e5;\n const double EPS = 1e-9;\n const double PI = acos(-1.);\n int main() {\n   ios_base::sync_with_stdio(0);\n   cin.tie(0);\n   cout.tie(0);\n   int n, *a, *res, j = 0;\n   cin >> n;\n   a = new int[n];\n   res = new int[n];\n   set<int> cnt;\n   for (int i = 0; i < n; i++) {\n     cin >> a[i];\n   }\n   for (int i = n - 1; i >= 0; i--) {\n     if (!cnt.count(a[i])) {\n       cnt.insert(a[i]);\n       res[j] = a[i];\n       j++;\n     }\n   }\n   cout << j << endl;\n   for (int i = j - 1; i >= 0; i--) {\n     cout << res[i] << ' ';\n   }\n   return 0;\n }\n "}
{"func_code_string": "#include <bits/stdc++.h>\n using namespace std;\n string s;\n int n, m;\n int f[150][150][250][2];\n int main() {\n   cin >> s;\n   n = s.size();\n   scanf( %d , &m);\n   f[0][m][n][1] = true;\n   for (int i = 0; i < n; i++)\n     for (int j = 0; j <= m; j++)\n       for (int k = 0; k <= n * 2; k++)\n         for (int l = 0; l < 2; l++)\n           if (f[i][j][k][l])\n             if (s[i] == 'T') {\n               f[i + 1][j][k][1 - l] = true;\n               if (j != 0 && k - 1 + 2 * l >= 0)\n                 f[i + 1][j - 1][k - 1 + 2 * l][l] = true;\n             } else {\n               if (k - 1 + 2 * l >= 0) f[i + 1][j][k - 1 + 2 * l][l] = true;\n               if (j != 0) f[i + 1][j - 1][k][1 - l] = true;\n             }\n   int i = 0;\n   for (int j = 0; j <= m; j++)\n     if (j % 2 == 0)\n       for (int k = 0; k <= n * 2; k++)\n         for (int l = 0; l < 2; l++)\n           if (f[n][j][k][l]) {\n             if (k - n < 0 && n - k > i) i = n - k;\n             if (k - n > 0 && k - n > i) i = k - n;\n           }\n   printf( %d\n , i);\n   return 0;\n }\n "}
{"func_code_string": "#include <bits/stdc++.h>\n using namespace std;\n struct cell {\n   bool up, down, right, left;\n   int degree;\n   cell() { up = down = left = right = degree = 0; }\n   void reset() { up = down = left = right = degree = 0; }\n };\n struct qcell {\n   int x, y, degree;\n   qcell() {\n     x = y = -1;\n     degree = 0;\n   }\n   qcell(int xx, int yy, int deg) {\n     x = xx;\n     y = yy;\n     degree = deg;\n   }\n };\n char pitch[2001][2001];\n cell info[2001][2001];\n int n, m;\n int empty_cells = 0;\n bool update(int x, int y) {\n   int degree = 0;\n   if (x >= 0 && x < n && y >= 0 && y < m) {\n     degree = info[x][y].degree;\n     if (pitch[x][y] != '.')\n       info[x][y].reset();\n     else {\n       info[x][y].up = (x - 1 >= 0 && pitch[x - 1][y] == '.');\n       info[x][y].down = (x + 1 < n && pitch[x + 1][y] == '.');\n       info[x][y].left = (y - 1 >= 0 && pitch[x][y - 1] == '.');\n       info[x][y].right = (y + 1 < m && pitch[x][y + 1] == '.');\n       info[x][y].degree = (info[x][y].up + info[x][y].down + info[x][y].left +\n                            info[x][y].right);\n     }\n   }\n   return degree != info[x][y].degree;\n }\n void do_push(int x, int y, queue<qcell> &q) {\n   if (x >= 0 && x < n && y >= 0 && y < m)\n     if (pitch[x][y] == '.')\n       if (info[x][y].degree == 1) q.push(qcell(x, y, 1));\n }\n void occupy(int x, int y, queue<qcell> &q) {\n   int xx = x, yy = y;\n   char dir = 'U';\n   if (info[x][y].down) dir = 'D';\n   if (info[x][y].left) dir = 'L';\n   if (info[x][y].right) dir = 'R';\n   if (dir == 'U') {\n     pitch[x][y] = 'v';\n     pitch[x - 1][y] = '^';\n     xx = x - 1;\n   } else if (dir == 'D') {\n     pitch[x][y] = '^';\n     pitch[x + 1][y] = 'v';\n     xx = x + 1;\n   } else if (dir == 'L') {\n     pitch[x][y] = '>';\n     pitch[x][y - 1] = '<';\n     yy = y - 1;\n   } else {\n     pitch[x][y] = '<';\n     pitch[x][y + 1] = '>';\n     yy = y + 1;\n   }\n   update(x, y);\n   update(xx, yy);\n   if (do_push) {\n     if (update(x - 1, y)) do_push(x - 1, y, q);\n     if (update(x + 1, y)) do_push(x + 1, y, q);\n     if (update(x, y - 1)) do_push(x, y - 1, q);\n     if (update(x, y + 1)) do_push(x, y + 1, q);\n     if (update(xx - 1, yy)) do_push(xx - 1, yy, q);\n     if (update(xx + 1, yy)) do_push(xx + 1, yy, q);\n     if (update(xx, yy - 1)) do_push(xx, yy - 1, q);\n     if (update(xx, yy + 1)) do_push(xx, yy + 1, q);\n   }\n   empty_cells -= 2;\n }\n int main() {\n   cin >> n >> m;\n   for (int i = 0; i < n; i++)\n     for (int j = 0; j < m; j++) {\n       cin >> pitch[i][j];\n       if (pitch[i][j] == '.') empty_cells++;\n     }\n   queue<qcell> q;\n   for (int i = 0; i < n; i++)\n     for (int j = 0; j < m; j++) {\n       update(i, j);\n       if (info[i][j].degree == 1) q.push(qcell(i, j, info[i][j].degree));\n     }\n   bool unique_sol = 1;\n   while (1) {\n     if (q.empty()) break;\n     qcell f = q.front();\n     q.pop();\n     if (info[f.x][f.y].degree == 0) {\n       if (pitch[f.x][f.y] == '.') {\n         unique_sol = false;\n         break;\n       }\n     } else\n       occupy(f.x, f.y, q);\n   }\n   if (unique_sol)\n     if (empty_cells != 0) unique_sol = 0;\n   if (!unique_sol)\n     cout <<  Not unique  << endl;\n   else\n     for (int i = 0; i < n; i++) {\n       for (int j = 0; j < m; j++) cout << pitch[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 INF = 0x3f3f3f3f;\n int main() {\n   ios::sync_with_stdio(false);\n   int t;\n   cin >> t;\n   while (t--) {\n     string s, t;\n     cin >> s >> t;\n     vector<int> each[26];\n     int n, m;\n     n = s.length();\n     m = t.length();\n     for (int i = 0; i < n; ++i) {\n       each[s[i] - 'a'].push_back(i);\n     }\n     int las = INF, res = 0;\n     for (int i = 0; i < m; ++i) {\n       if (upper_bound(each[t[i] - 'a'].begin(), each[t[i] - 'a'].end(), las) !=\n           each[t[i] - 'a'].end()) {\n         las =\n             *upper_bound(each[t[i] - 'a'].begin(), each[t[i] - 'a'].end(), las);\n       } else {\n         if (each[t[i] - 'a'].empty()) {\n           res = -1;\n           break;\n         } else {\n           res++;\n           las = each[t[i] - 'a'][0];\n         }\n       }\n     }\n     cout << res << endl;\n   }\n   return 0;\n }\n "}
{"func_code_string": "#include <bits/stdc++.h>\n using namespace std;\n int main() {\n   int n, h, a, road_width = 0;\n   cin >> n >> h;\n   for (int i = 0; i < n; i++) {\n     cin >> a;\n     if (a > h)\n       road_width += 2;\n     else\n       road_width++;\n   }\n   cout << road_width <<  \n ;\n   return 0;\n }\n "}
{"func_code_string": "#include <bits/stdc++.h>\n using namespace std;\n int abs(int a, int b) {\n   if (a > b)\n     return a - b;\n   else\n     return b - a;\n }\n int main() {\n   int n, c, i, b, count = 0, index1 = 1, index2 = 1, flag = 0;\n   cin >> n >> c;\n   char *s;\n   s = new char[n + 2];\n   for (i = 1; i <= n; i++) {\n     cin >> s[i];\n   }\n   int *d = new int[n + 1];\n   for (i = 1; i <= n / 2; i++) {\n     b = abs((int)s[i], (int)s[n - i + 1]);\n     if (b < 13)\n       d[i] = d[n - i + 1] = b;\n     else\n       d[i] = d[n - i + 1] = 26 - b;\n   }\n   if (c > n / 2) c = 1 + n - c;\n   for (i = 1; i <= n / 2; i++) {\n     if (d[i] > 0) {\n       index1 = i;\n       break;\n     }\n   }\n   for (i = n / 2; i >= 1; i--) {\n     if (d[i] > 0) {\n       index2 = i;\n       flag = 1;\n       break;\n     }\n   }\n   if (c <= index1) {\n     count = index2 - c;\n   } else if (c <= index2) {\n     if (c - index1 > index2 - c)\n       count = 2 * (index2 - c) + c - index1;\n     else\n       count = 2 * (c - index1) + index2 - c;\n   } else\n     count = c - index1;\n   for (i = index1; i <= index2; i++) {\n     count += d[i];\n   }\n   if (flag == 1)\n     cout << count;\n   else\n     cout << 0;\n   return 0;\n }\n "}
{"func_code_string": "#include <bits/stdc++.h>\n int any_table[11][11];\n struct DammedPascalNUmber {\n   int tb[13][13];\n   DammedPascalNUmber() {\n     int i, j;\n     for (i = 0; i <= 12; i++)\n       for (j = 0; j <= i; j++) {\n         int &r = tb[i][j];\n         if (j == 0 || i == 0)\n           r = 1;\n         else\n           r = tb[i - 1][j - 1] + tb[i - 1][j];\n       }\n   }\n   int count(int n, int m) { return tb[n][m]; }\n } pas;\n int any(int dig, int amo) {\n   if (dig < amo) return 0;\n   if (amo < 0) return 0;\n   if (dig == 0) return 1;\n   int &r = any_table[dig][amo];\n   int i;\n   if (r >= 0) return r;\n   r = 1;\n   for (i = 0; i < amo; i++) r *= 2;\n   for (; i < dig; i++) r *= 8;\n   r *= pas.count(dig, amo);\n   return r;\n }\n int check(int m, int n) {\n   int i, j, t, r = 0;\n   for (i = 1; i <= m; i++) {\n     char str[15];\n     t = 0;\n     sprintf(str,  %d , i);\n     for (j = 0; str[j]; j++)\n       if (str[j] == '4' || str[j] == '7') t++;\n     if (t == n) r++;\n   }\n   return r;\n }\n int a[13];\n int dfs(int party, int quta) {\n   int r = 0, i;\n   if (party == 6) {\n     return 1;\n   }\n   for (i = quta; i >= 0; i--)\n     if (a[i] > 0) {\n       int t = a[i];\n       a[i]--;\n       r = (1LL * r + 1LL * t * 1LL * dfs(party + 1, quta - i) +\n            1LL * 1000000007) %\n           1000000007;\n       a[i]++;\n     }\n   return r;\n }\n void test(int n, int m) { printf( any(%d,%d)=%d\n , n, m, any(n, m)); }\n void test2(int m, int n) {\n   printf( (%d,%d)=%d a[%d]=%d\n , m, n, check(m, n), n, a[n]);\n }\n int main() {\n   memset(any_table, -1, sizeof(any_table));\n   int m, s, i, j, k, sn, lucked;\n   while (~scanf( %d , &m)) {\n     memset(a, 0, sizeof(a));\n     char str[15];\n     sprintf(str,  %d , m);\n     for (sn = 0; str[sn]; sn++)\n       ;\n     for (j = sn; j > 0; j--) {\n       a[j] = 0;\n       lucked = 0;\n       for (i = 0; i < sn; i++) {\n         int p = 0, q = 0;\n         k = str[i] - '0' - 1;\n         for (; k >= 0; k--)\n           if (k == 4 || k == 7)\n             q++;\n           else\n             p++;\n         if (p) a[j] += p * any(sn - i - 1, j - lucked);\n         if (q) a[j] += q * any(sn - i - 1, j - lucked - 1);\n         if (str[i] == '4' || str[i] == '7') {\n           lucked++;\n         }\n         if (i == sn - 1 && lucked == j) a[j]++;\n       }\n     }\n     a[0] = m;\n     for (i = 1; i <= sn; i++) a[0] -= a[i];\n     int ans = 0;\n     for (i = 1; i <= sn; i++)\n       if (a[i]) {\n         ans = (1LL * ans + 1LL * a[i] * dfs(0, i - 1) + 1LL * 1000000007) %\n               1000000007;\n       }\n     printf( %d\n , ans);\n   }\n }\n "}
{"func_code_string": "#include <bits/stdc++.h>\n using namespace std;\n const int maxn = 1e5 + 10;\n const double pi = acos(-1);\n const int inf = 1 << 30;\n const int mod = 1e9 + 9;\n struct point {\n   int x, flag;\n   bool operator<(const point &a) const { return flag > a.flag; }\n } s, q;\n bool check(long long a[], int n, long long h, int x) {\n   priority_queue<int, vector<int>, less<int> > qwe;\n   for (int i = 1; i <= min(n, x); i++) qwe.push(a[i]);\n   int f = 1, pos;\n   while (!qwe.empty()) {\n     pos = qwe.top();\n     qwe.pop();\n     if (f) h -= pos;\n     f ^= 1;\n   }\n   if (h >= 0ll)\n     return true;\n   else\n     return false;\n }\n int main() {\n   int n;\n   long long h, a[maxn];\n   scanf( %d %lld , &n, &h);\n   for (int i = 1; i <= n; i++) scanf( %lld , &a[i]);\n   int l = 0, r = n, ans = 0;\n   while (l <= r) {\n     int mid = (l + r) >> 1;\n     if (check(a, n, h, mid))\n       l = mid + 1, ans = mid;\n     else\n       r = mid - 1;\n   }\n   printf( %d\n , ans);\n   return 0;\n }\n "}
{"func_code_string": "#include <bits/stdc++.h>\n const int64_t mod = 998244353;\n int gcd(int64_t a, int64_t b) {\n   while (a != 0 && b != 0) {\n     if (a >= b)\n       a = a % b;\n     else\n       b = b % a;\n   }\n   return a + b;\n }\n struct Fraction {\n   int64_t numerator;\n   int64_t devider;\n   Fraction(int64_t n = 0, int64_t d = 1) : numerator(n), devider(d){};\n   const Fraction& operator+(const Fraction& rv) {\n     if (rv.devider == devider) {\n       numerator += rv.numerator;\n       numerator %= mod;\n       return *this;\n     } else {\n       numerator *= rv.devider;\n       numerator %= mod;\n       numerator += rv.numerator * devider;\n       numerator %= mod;\n       devider *= rv.devider;\n       devider %= mod;\n       return *this;\n     }\n   }\n   const Fraction& operator*(const Fraction& rv) {\n     numerator *= rv.numerator;\n     devider *= rv.devider;\n     numerator %= mod;\n     devider %= mod;\n     return *this;\n   }\n };\n struct Item {\n   Item(Fraction f, int64_t s, int64_t v) : possibility(f), sum(s), val(v){};\n   Fraction possibility;\n   int64_t sum;\n   int64_t val;\n };\n void extended_euclid(int64_t a, int64_t b, int64_t& x, int64_t& y, int64_t& d) {\n   int64_t q, r, x1, x2, y1, y2;\n   if (b == 0) {\n     d = a, x = 1, y = 0;\n     return;\n   }\n   x2 = 1, x1 = 0, y2 = 0, y1 = 1;\n   while (b > 0) {\n     q = a / b, r = a - q * b;\n     x = x2 - q * x1, y = y2 - q * y1;\n     a = b, b = r;\n     x2 = x1, x1 = x, y2 = y1, y1 = y;\n   }\n   d = a, x = x2, y = y2;\n }\n int main() {\n   int64_t n, m;\n   std::cin >> n >> m;\n   std::vector<std::pair<int64_t, bool>> data;\n   int64_t posWeight = 0, negWeight = 0;\n   for (int64_t i = 0; i < n; ++i) {\n     int64_t a;\n     std::cin >> a;\n     if (a == 0)\n       data.push_back(std::make_pair(-1, false));\n     else\n       data.push_back(std::make_pair(-1, true));\n   }\n   for (auto& i : data) {\n     int64_t w;\n     std::cin >> w;\n     i.first = w;\n     if (i.second)\n       posWeight += w;\n     else\n       negWeight += w;\n   }\n   std::vector<Item> posVec{\n       Item(Fraction(1, 1), posWeight + negWeight, posWeight)},\n       negVec{Item(Fraction(1, 1), posWeight + negWeight, negWeight)};\n   for (int64_t i = 0; i < m; ++i) {\n     std::vector<Item> newPos, newNeg;\n     for (auto j : posVec) {\n       if (!newPos.size()) {\n         Fraction f(j.val, j.sum);\n         f = f * j.possibility;\n         newPos.push_back(Item(f, j.sum + 1, j.val + 1));\n       } else {\n         Fraction f(j.val, j.sum);\n         f = f * j.possibility;\n         newPos.rbegin()->possibility = newPos.rbegin()->possibility + f;\n       }\n       if (j.sum > j.val) {\n         Fraction f(j.sum - j.val, j.sum);\n         f = f * j.possibility;\n         newPos.push_back(Item(f, j.sum - 1, j.val));\n       }\n     }\n     for (auto j : negVec) {\n       if (!newNeg.size() && j.val > 1) {\n         Fraction f(j.val, j.sum);\n         f = f * j.possibility;\n         newNeg.push_back(Item(f, j.sum - 1, j.val - 1));\n       } else if (j.val > 1) {\n         Fraction f(j.val, j.sum);\n         f = f * j.possibility;\n         newNeg.rbegin()->possibility = newNeg.rbegin()->possibility + f;\n       }\n       Fraction f(j.sum - j.val, j.sum);\n       f = f * j.possibility;\n       newNeg.push_back(Item(f, j.sum + 1, j.val));\n     }\n     posVec = newPos;\n     negVec = newNeg;\n   }\n   Fraction pos, neg;\n   for (auto i : posVec) pos = pos + Fraction(i.val, 1) * i.possibility;\n   for (auto i : negVec) neg = neg + Fraction(i.val, 1) * i.possibility;\n   for (auto i : data) {\n     Fraction res;\n     if (i.second)\n       res = Fraction(i.first, posWeight) * pos;\n     else\n       res = Fraction(i.first, negWeight) * neg;\n     int64_t g = gcd(res.numerator, res.devider);\n     res.numerator /= g;\n     res.devider /= g;\n     int64_t d, x, y;\n     extended_euclid(res.devider, mod, x, y, d);\n     std::cout << (((x % mod + mod) % mod) * res.numerator) % mod << std::endl;\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, m, x, y, f[N], fa[N], ch[N][2];\n char op[5];\n long long a[N], siz[N], ssiz[N], ans[N], sans[N], sqsiz[N], all[N];\n bool isroot(int u) { return ch[fa[u]][0] != u && ch[fa[u]][1] != u; }\n int which(int u) { return u == ch[fa[u]][1]; }\n void pushup(int o) {\n   int lc = ch[o][0], rc = ch[o][1];\n   siz[o] = siz[lc] + siz[rc] + ssiz[o];\n   all[o] = all[lc] + all[rc] + a[o] * ssiz[o];\n   ans[o] = ans[lc] + ans[rc] + sans[o];\n   ans[o] += (ssiz[o] * ssiz[o] - sqsiz[o]) * a[o];\n   ans[o] += 2 * siz[rc] * ssiz[o] * a[o];\n   ans[o] += 2 * all[lc] * (siz[o] - siz[lc]);\n }\n void rotate(int x) {\n   int y = fa[x], z = fa[y], md = which(x);\n   if (!isroot(y)) {\n     ch[z][which(y)] = x;\n   }\n   fa[x] = z;\n   ch[y][md] = ch[x][!md];\n   fa[ch[y][md]] = y;\n   ch[x][!md] = y;\n   fa[y] = x;\n   pushup(y);\n   pushup(x);\n }\n void splay(int u) {\n   while (!isroot(u)) {\n     if (!isroot(fa[u])) {\n       rotate(which(u) == which(fa[u]) ? fa[u] : u);\n     }\n     rotate(u);\n   }\n }\n void access(int u) {\n   for (int v = 0; u; v = u, u = fa[u]) {\n     splay(u);\n     int rc = ch[u][1];\n     ssiz[u] += siz[rc];\n     sans[u] += ans[rc];\n     sqsiz[u] += siz[rc] * siz[rc];\n     ch[u][1] = v;\n     ssiz[u] -= siz[v];\n     sans[u] -= ans[v];\n     sqsiz[u] -= siz[v] * siz[v];\n     pushup(u);\n   }\n }\n void link(int u, int v) {\n   access(v);\n   splay(v);\n   access(u);\n   splay(u);\n   fa[u] = v;\n   ssiz[v] += siz[u];\n   sans[v] += ans[u];\n   sqsiz[v] += siz[u] * siz[u];\n   pushup(v);\n }\n void cut(int u, int v) {\n   access(u);\n   access(v);\n   splay(v);\n   splay(u);\n   fa[u] = 0;\n   ssiz[v] -= siz[u];\n   sans[v] -= ans[u];\n   sqsiz[v] -= siz[u] * siz[u];\n   pushup(v);\n }\n bool check(int u, int v) {\n   access(v);\n   splay(v);\n   splay(u);\n   if (isroot(v)) {\n     return false;\n   }\n   return true;\n }\n int main() {\n   scanf( %d , &n);\n   for (int i = 2; i <= n; i++) {\n     scanf( %d , &f[i]);\n   }\n   for (int i = 1; i <= n; i++) {\n     scanf( %lld , &a[i]);\n     ans[i] = all[i] = a[i];\n   }\n   for (int i = 1; i <= n; i++) {\n     siz[i] = 1;\n     ssiz[i] = 1;\n   }\n   for (int i = 2; i <= n; i++) {\n     link(i, f[i]);\n   }\n   access(1);\n   splay(1);\n   printf( %.10lf\n , 1.0 * ans[1] / n / n);\n   scanf( %d , &m);\n   while (m--) {\n     scanf( %s%d%d , op, &x, &y);\n     if (op[0] == 'P') {\n       if (check(x, y)) {\n         swap(x, y);\n       }\n       cut(x, f[x]);\n       f[x] = y;\n       link(x, f[x]);\n       access(1);\n       splay(1);\n       printf( %.10lf\n , 1.0 * ans[1] / n / n);\n     } else {\n       access(x);\n       splay(x);\n       a[x] = y;\n       pushup(x);\n       printf( %.10lf\n , 1.0 * ans[x] / n / n);\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(NULL);\n   long long x, y, n, m, t, q, a, b, count = 0;\n   cin >> n >> m;\n   long long arr[n];\n   for (x = 0; x < n; x++) cin >> arr[x];\n   a = 0;\n   for (x = 0; x < n; x++) {\n     a = a + arr[x];\n     cout << a / m <<    ;\n     a = a % m;\n   }\n }\n "}
{"func_code_string": "#include <bits/stdc++.h>\n using namespace std;\n int qread() {\n   char c;\n   int s = 0, f = 1;\n   while ((c = getchar()) < '0' || c > '9') (c == '-') && (f = -1);\n   do s = s * 10 + c - '0';\n   while ((c = getchar()) >= '0' && c <= '9');\n   return s * f;\n }\n int n, m;\n const int mod = 1e9 + 7;\n int a[100011], pos[100011], bin[100011], inv[100011], sum[100011],\n     lp = 0, val[100011], vv[100011], svv[100011];\n struct Ques {\n   int l, r, id;\n   bool operator<(const Ques &b) const { return r < b.r; }\n } q[100011];\n int ans[100011];\n int WWW(long long v) { return v > 2000000001 ? 2000000001 : v; }\n int main() {\n   n = qread();\n   m = qread();\n   bin[0] = inv[0] = 1;\n   for (int i = 1; i <= n; i++)\n     a[i] = qread(), bin[i] = (bin[i - 1] << 1) % mod,\n     inv[i] = 1ll * inv[i - 1] * ((mod + 1) >> 1) % mod,\n     sum[i] = ((sum[i - 1] + 1ll * a[i] * bin[i]) % mod + mod) % mod;\n   for (int i = 1; i <= m; i++) {\n     q[i].l = qread();\n     q[q[i].id = i].r = qread();\n   }\n   sort(q + 1, q + 1 + m);\n   pos[lp = 1] = 1;\n   int j = 1;\n   val[1] = a[1] * 2;\n   vv[1] = svv[1] = ((a[1] * 2) % mod + mod) % mod;\n   while (j <= m && q[j].r == 1) ans[q[j].id] = (a[1] + mod) % mod, j++;\n   for (int i = 2; i <= n; i++) {\n     if (a[i] <= 0)\n       pos[++lp] = i, val[lp] = 2 * a[i],\n       vv[lp] = (a[i] * 2ll % mod + mod) % mod,\n       svv[lp] = (svv[lp - 1] + vv[lp]) % mod;\n     else {\n       int cur =\n           WWW(0ll + val[lp] + bin[pos[lp] - pos[lp - 1] + 1] * 1ll * a[i]);\n       int cvv = (vv[lp] + bin[pos[lp] - pos[lp - 1] + 1] * 1ll * a[i]) % mod;\n       lp--;\n       while (lp && cur > 0) {\n         cur = WWW(0ll + val[lp] +\n                   (pos[lp] - pos[lp - 1] > 31 ? 2000000001\n                                               : bin[pos[lp] - pos[lp - 1]]) *\n                       1ll * cur);\n         cvv = (vv[lp] + bin[pos[lp] - pos[lp - 1]] * 1ll * cvv) % mod;\n         lp--;\n       }\n       val[++lp] = cur;\n       pos[lp] = i;\n       vv[lp] = cvv;\n       svv[lp] = (svv[lp - 1] + vv[lp]) % mod;\n     }\n     while (j <= m && q[j].r == i) {\n       if (q[j].l == q[j].r) {\n         ans[q[j].id] = (a[i] + mod) % mod;\n         j++;\n         continue;\n       }\n       int l = q[j].l + 1, Ans = (a[q[j].l] + mod) % mod;\n       int L = 1, R = lp;\n       while (L < R) {\n         int mid = (L + R) >> 1;\n         if (pos[mid] >= l)\n           R = mid;\n         else\n           L = mid + 1;\n       }\n       Ans = (Ans + svv[lp] - svv[L]) % mod;\n       Ans = (Ans + mod) % mod;\n       Ans = (Ans + (sum[pos[L]] - sum[l - 1] + mod) * 1ll * inv[l - 1]) % mod;\n       ans[q[j].id] = Ans;\n       j++;\n     }\n   }\n   for (int i = 1; i <= m; i++) printf( %d\n , ans[i]);\n   return 0;\n }\n "}
{"func_code_string": "#include <bits/stdc++.h>\n using namespace std;\n const long long mod = 1000000007;\n const long long inf = 1000000000000000000;\n int main() {\n   long long t;\n   cin >> t;\n   while (t--) {\n     long long n;\n     cin >> n;\n     vector<pair<long long, long long> > p(n);\n     for (auto& x : p) cin >> x.first >> x.second;\n     sort(p.begin(), p.end());\n     pair<long long, long long> now = {0, 0};\n     bool f = 1;\n     string ans =   ;\n     for (int i = 0; i < n; i++) {\n       if (p[i].first >= now.first && p[i].second >= now.second) {\n         long long r = p[i].first - now.first, u = p[i].second - now.second;\n         while (r--) ans += 'R';\n         while (u--) ans += 'U';\n         now = p[i];\n       } else {\n         f = 0;\n         break;\n       }\n     }\n     if (f)\n       cout <<  YES\n  << ans << endl;\n     else\n       cout <<  NO\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   scanf( %d %d , &n, &m);\n   for (int i = 0; i < n; i++) {\n     if (i % 2 == 0) {\n       for (int j = 1; j <= m; j++) {\n         printf( # );\n       }\n     } else if (i % 4 == 1) {\n       for (int j = 1; j < m; j++) {\n         printf( . );\n       }\n       printf( # );\n     } else if (i % 4 == 3) {\n       printf( # );\n       for (int j = 1; j < m; j++) {\n         printf( . );\n       }\n     }\n     printf( \n );\n   }\n   return 0;\n }\n "}
{"func_code_string": "#include <bits/stdc++.h>\n using namespace std;\n const int N = 2e5 + 65, mod = 1e9 + 7;\n vector<int> g[N];\n int w[N];\n int col[N], pr[N];\n int sz[N][2];\n long long ans = 0;\n void dfs(int v, int par = -1, int c = 0) {\n   pr[v] = par;\n   ++sz[v][c];\n   col[v] = c;\n   for (int u : g[v])\n     if (u != par) {\n       dfs(u, v, c ^ 1);\n       sz[v][0] += sz[u][0];\n       sz[v][1] += sz[u][1];\n     }\n }\n int main() {\n   int n;\n   scanf( %d , &n);\n   for (int i = 0; i < n; ++i) scanf( %d , w + i);\n   for (int i = 1; i < n; ++i) {\n     int u, v;\n     scanf( %d %d , &u, &v);\n     --u, --v;\n     g[u].push_back(v);\n     g[v].push_back(u);\n   }\n   ans = 0;\n   dfs(0);\n   for (int v = 0; v < n; ++v) {\n     vector<pair<int, int> > vs;\n     for (int u : g[v])\n       if (u != pr[v]) vs.emplace_back(sz[u][0], sz[u][1]);\n     if (pr[v] != -1) vs.emplace_back(sz[0][0] - sz[v][0], sz[0][1] - sz[v][1]);\n     long long cnt = n;\n     if (col[v]) {\n       for (pair<int, int> e : vs) {\n         cnt = (cnt + 1LL * e.second * (n - e.first - e.second)) % mod;\n         cnt = (cnt - 1LL * e.first * (n - e.first - e.second)) % mod;\n       }\n     } else {\n       for (pair<int, int> e : vs) {\n         cnt = (cnt - 1LL * e.second * (n - e.first - e.second)) % mod;\n         cnt = (cnt + 1LL * e.first * (n - e.first - e.second)) % mod;\n       }\n     }\n     cnt %= mod;\n     if (cnt < 0) cnt += mod;\n     ans = (ans + cnt * w[v]) % mod;\n   }\n   ans %= mod;\n   if (ans < 0) ans += mod;\n   cout << ans << endl;\n   return 0;\n }\n "}
{"func_code_string": "#include <bits/stdc++.h>\n using namespace std;\n const int inf = 1 << 28;\n const double INF = 1e12, EPS = 1e-9;\n int n, m, k;\n bool star[600][600];\n int sum[600][600];\n char in[600][600];\n void run() {\n   cin >> n >> m >> k;\n   for (int i = 0; i < n; i++) cin >> in[i];\n   for (int i = 0; i < n; i++)\n     for (int j = 0; j < m; j++) {\n       if (in[i][j] == '1' && in[i + 1][j] == '1' && in[i + 2][j] == '1' && j &&\n           in[i + 1][j - 1] == '1' && in[i + 1][j + 1] == '1')\n         star[i][j] = 1;\n     }\n   long long ans = 0;\n   for (int i = 0; i < n; i++)\n     for (int j = 0; j < m; j++)\n       sum[i + 1][j + 1] =\n           star[i][j] + sum[i][j + 1] + sum[i + 1][j] - sum[i][j];\n   for (int a = 0; a < n; a++)\n     for (int b = a + 3; b <= n; b++) {\n       int l = 0, r = 2, cnt = 0;\n       for (; l < m; l++) {\n         while (r <= m && cnt < k) {\n           r++;\n           cnt += sum[b - 2][r - 1] - sum[a][r - 1] -\n                  (sum[b - 2][r - 2] - sum[a][r - 2]);\n         }\n         if (cnt < k || r > m) break;\n         ans += m - r + 1;\n         cnt -= sum[b - 2][l + 2] - sum[a][l + 2] -\n                (sum[b - 2][l + 1] - sum[a][l + 1]);\n       }\n     }\n   cout << ans << endl;\n }\n int main() { run(); }\n "}
{"func_code_string": "#include <bits/stdc++.h>\n using namespace std;\n void readi(int &x) {\n   int v = 0, f = 1;\n   char c = getchar();\n   while (!isdigit(c) && c != '-') c = getchar();\n   if (c == '-')\n     f = -1;\n   else\n     v = v * 10 + c - '0';\n   while (isdigit(c = getchar())) v = v * 10 + c - '0';\n   x = v * f;\n }\n void readll(long long &x) {\n   long long v = 0ll, f = 1ll;\n   char c = getchar();\n   while (!isdigit(c) && c != '-') c = getchar();\n   if (c == '-')\n     f = -1;\n   else\n     v = v * 10 + c - '0';\n   while (isdigit(c = getchar())) v = v * 10 + c - '0';\n   x = v * f;\n }\n void readc(char &x) {\n   char c;\n   while ((c = getchar()) == ' ')\n     ;\n   x = c;\n }\n void writes(string s) { puts(s.c_str()); }\n void writeln() { writes(  ); }\n void writei(int x) {\n   if (!x) putchar('0');\n   char a[25];\n   int top = 0;\n   while (x) {\n     a[++top] = (x % 10) + '0';\n     x /= 10;\n   }\n   while (top) {\n     putchar(a[top]);\n     top--;\n   }\n }\n void writell(long long x) {\n   if (!x) putchar('0');\n   char a[25];\n   int top = 0;\n   while (x) {\n     a[++top] = (x % 10) + '0';\n     x /= 10;\n   }\n   while (top) {\n     putchar(a[top]);\n     top--;\n   }\n }\n inline long long inc(int &x) { return ++x; }\n inline long long inc(long long &x) { return ++x; }\n inline long long inc(int &x, long long y) { return x += y; }\n inline long long inc(long long &x, long long y) { return x += y; }\n inline double inc(double &x, double y) { return x += y; }\n inline long long dec(int &x) { return --x; }\n inline long long dec(long long &x) { return --x; }\n inline long long dec(int &x, long long y) { return x -= y; }\n inline long long dec(long long &x, long long y) { return x -= y; }\n inline double dec(double &x, double y) { return x -= y; }\n inline long long mul(int &x) { return x = ((long long)x) * x; }\n inline long long mul(long long &x) { return x = x * x; }\n inline long long mul(int &x, long long y) { return x *= y; }\n inline long long mul(long long &x, long long y) { return x *= y; }\n inline double mul(double &x, double y) { return x *= y; }\n inline long long divi(const int &x) {\n   long long ans, l, r, mid;\n   ans = 0;\n   l = 0;\n   r = 0x3fffffff;\n   while (l < r) {\n     mid = (l + r) / 2;\n     if (mid * mid <= x) {\n       ans = mid;\n       l = mid + 1;\n     } else\n       r = mid;\n   }\n   return ans;\n }\n inline long long divi(const long long &x) {\n   long long ans, l, r, mid;\n   ans = 0;\n   l = 0;\n   r = 0x3fffffff;\n   while (l < r) {\n     mid = (l + r) / 2;\n     if (mid * mid <= x) {\n       ans = mid;\n       l = mid + 1;\n     } else\n       r = mid;\n   }\n   return ans;\n }\n inline long long divi(int &x, long long y) { return x /= y; }\n inline long long divi(long long &x, long long y) { return x /= y; }\n inline double divi(double &x, double y) { return x /= y; }\n inline long long mod(int &x, long long y) { return x %= y; }\n inline long long mod(long long &x, long long y) { return x %= y; }\n int n, m, i, j, ct[100005], x, y, vis[100005];\n vector<int> e[100005];\n struct vt {\n   int id, deg;\n } a[100005];\n bool cmp(vt x, vt y) { return x.deg > y.deg; }\n bool dfs(int x) {\n   if (vis[x] == 1) return 1;\n   if (vis[x] == 2) return 0;\n   vis[x] = 1;\n   for (__typeof((e[x]).begin()) it = (e[x]).begin(); it != (e[x]).end(); it++)\n     if (dfs(*it)) return 1;\n   vis[x] = 2;\n   return 0;\n }\n bool check(int x) {\n   memset(vis, 0, sizeof(vis));\n   vis[x] = 2;\n   int i;\n   for (i = 1; i <= n; i++) {\n     if (!vis[i] && dfs(i)) {\n       for (i = 1; i <= n; i++)\n         if (vis[i] != 1) ct[i] = 1;\n       return 0;\n     }\n   }\n   return 1;\n }\n int main() {\n   double st = clock();\n   ios_base::sync_with_stdio(false);\n   ;\n   cin >> n >> m;\n   if ((1) <= ((m)))\n     for (((i)) = (1); ((i)) <= ((m)); ((i))++) {\n       cin >> x >> y;\n       e[x].push_back(y);\n     }\n   if ((1) <= ((n)))\n     for (((i)) = (1); ((i)) <= ((n)); ((i))++) {\n       a[i].id = i;\n       a[i].deg = e[i].size();\n     }\n   stable_sort(a + 1, a + n + 1, cmp);\n   if ((1) <= ((n)))\n     for (((i)) = (1); ((i)) <= ((n)); ((i))++) {\n       if ((clock() - st) / CLOCKS_PER_SEC > 0.9) break;\n       x = a[i].id;\n       if (ct[x] || !check(x)) continue;\n       cout << x;\n       return 0;\n     }\n   cout <<  -1 ;\n   return 0;\n }\n "}
{"func_code_string": "#include <bits/stdc++.h>\n using namespace std;\n const long long mxn = 1003, inf = 1e18 + 18;\n int n, m, lcp[mxn][mxn], rk[mxn][mxn], ri[mxn], tot;\n long long k, f[mxn];\n string s;\n struct S {\n   int l, r;\n } a[mxn * mxn];\n inline bool cmp(S a, S b) {\n   int p = a.l + lcp[a.l][b.l], q = b.l + lcp[a.l][b.l];\n   if (p > a.r or q > b.r) return a.r - a.l < b.r - b.l;\n   return s[p] < s[q];\n }\n inline long long add(long long a, long long b) {\n   return a + b > inf ? inf : a + b;\n }\n inline long long calc(int md) {\n   for (int i = 1; i <= n; ++i) {\n     ri[i] = i;\n     for (; ri[i] <= n and rk[i][ri[i]] < md;) ++ri[i];\n   }\n   memset(f, 0, sizeof(f)), f[n + 1] = 1;\n   for (int i = 1; i <= m; ++i) {\n     for (int j = n; j; --j) f[j] = add(f[j], f[j + 1]);\n     for (int j = 1; j <= n; ++j) f[j] = ri[j] <= n ? f[ri[j] + 1] : 0;\n     f[n + 1] = 0;\n   }\n   return f[1];\n }\n int main() {\n   cin >> n >> m >> k >> s, s = ' ' + s;\n   for (int i = n; i; --i)\n     for (int j = n; j; --j)\n       if (s[i] == s[j]) lcp[i][j] = lcp[i + 1][j + 1] + 1;\n   for (int i = 1; i <= n; ++i)\n     for (int j = i; j <= n; ++j) a[++tot] = (S){i, j};\n   sort(a + 1, a + tot + 1, cmp);\n   for (int i = 1; i <= tot; ++i) rk[a[i].l][a[i].r] = i;\n   int l = 1, r = tot, md;\n   for (; l <= r;) {\n     md = l + r >> 1;\n     if (calc(md) >= k)\n       l = md + 1;\n     else\n       r = md - 1;\n   }\n   for (int i = a[r].l; i <= a[r].r; ++i) putchar(s[i]);\n }\n "}
{"func_code_string": "#include <algorithm>\n #include <cmath>\n #include <cstdio>\n #include <cstring>\n #include <iostream>\n #include <map>\n #include <set>\n #include <unordered_map>\n \n using namespace std;\n typedef long long LL;\n const int N = 3e5 + 10, mod = 998244353;\n string g[N];\n int dp[N];\n \n int fastPow(int a, int k) {\n     int res = 1;\n     while (k) {\n         if (k & 1) res = (LL)res * a % mod;\n         k >>= 1;\n         a = (LL)a * a % mod;\n     }\n     return res;\n }\n \n int main() {\n     ios::sync_with_stdio(false);\n     int n, m, sum = 0, res = 0;\n     n = 300000;\n     for (int i = 2; i <= n; i++) {\n         if (i & 1) sum = (sum + 1) % mod;\n         dp[i] = ((LL)dp[i - 1] * 2 % mod + sum + !(i & 1)) % mod;\n         sum = (sum << 1) % mod;\n     }\n     sum = 0;\n     cin >> n >> m;\n     for (int i = 0; i < n; i++) {\n         cin >> g[i];\n         for (auto c : g[i])\n             if (c == 'o') sum++;\n     }\n     for (int i = 0; i < n; i++) {\n         int cnt = 0, len = 0;\n         while (cnt <= m) {\n             if (cnt == m || g[i][cnt] == '*') {\n                 if (len) {\n                     res = (res + (LL)dp[len] *\n                                      fastPow(2, sum - len) % mod) %\n                           mod;\n                     len = 0;\n                 }\n             } else {\n                 len++;\n             }\n             cnt++;\n         }\n     }\n     for (int i = 0; i < m; i++) {\n         int cnt = 0, len = 0;\n         while (cnt <= n) {\n             if (cnt == n || g[cnt][i] == '*') {\n                 if (len) {\n                     res = (res + (LL)dp[len] *\n                                      fastPow(2, sum - len) % mod) %\n                           mod;\n                     len = 0;\n                 }\n             } else {\n                 len++;\n             }\n             cnt++;\n         }\n     }\n     cout << res << endl;\n     return 0;\n }"}
{"func_code_string": "#include <bits/stdc++.h>\n using namespace std;\n const int maxn = 100 + 10;\n char s[maxn];\n int f(char ch) {\n   if (ch == 'A') return 1;\n   if (ch == 'B') return 2;\n   if (ch == 'C') return 4;\n   return 0;\n }\n int main() {\n   scanf( %s , s + 1);\n   int l = strlen(s + 1);\n   for (int i = 1; i <= l - 2; ++i) {\n     int t = f(s[i]) | f(s[i + 1]) | f(s[i + 2]);\n     if (t == 7) {\n       cout <<  Yes  << endl;\n       return 0;\n     }\n   }\n   cout <<  No ;\n   return 0;\n }\n "}
{"func_code_string": "#include <bits/stdc++.h>\n using namespace std;\n vector<int> tree[500001];\n bool intree[500001];\n vector<int> tmp(0);\n bool isleaf(int node) {\n   if (tree[node].size() == 1 && intree[(tree[node])[0]]) return true;\n   return false;\n }\n void DFS(int lvl, int node) {\n   intree[node] = true;\n   if (isleaf(node)) {\n     tmp.push_back(lvl);\n   }\n   for (int i = 0; i < tree[node].size(); i++) {\n     if (!intree[(tree[node])[i]]) {\n       DFS(lvl + 1, (tree[node])[i]);\n     }\n   }\n }\n int main() {\n   ios_base::sync_with_stdio(false);\n   int N;\n   cin >> N;\n   for (int i = 1; i <= N; i++) intree[i] = false;\n   int x, y;\n   for (int i = 0; i < N - 1; i++) {\n     cin >> x >> y;\n     tree[x].push_back(y);\n     tree[y].push_back(x);\n   }\n   intree[1] = true;\n   int ans = 0, c;\n   for (int i = 0; i < (tree[1]).size(); i++) {\n     tmp.clear();\n     DFS(0, (tree[1])[i]);\n     sort(tmp.begin(), tmp.end());\n     c = tmp.size();\n     for (int j = 0; j < c; j++) {\n       ans = max(ans, tmp[j] + c - j);\n     }\n   }\n   cout << ans << endl;\n }\n "}
{"func_code_string": "#include <bits/stdc++.h>\n using namespace std;\n int main() {\n   ios_base::sync_with_stdio(false);\n   int n;\n   cin >> n;\n   vector<string> v(n);\n   for (int i = 0; i < n; i++) cin >> v[i];\n   for (int i = 1; i < n - 1; i++) {\n     for (int j = 1; j < n - 1; j++) {\n       if (v[i][j] == '#' and v[i + 1][j] == '#' and v[i][j + 1] == '#' and\n           v[i][j - 1] == '#' and v[i - 1][j] == '#') {\n         v[i][j] = 'a';\n         v[i + 1][j] = 'a';\n         v[i][j + 1] = 'a';\n         v[i][j - 1] = 'a';\n         v[i - 1][j] = 'a';\n       }\n     }\n   }\n   int c = 0;\n   for (int i = 0; i < n; i++)\n     for (int j = 0; j < n; j++)\n       if (v[i][j] == '#') {\n         c = 1;\n         break;\n       }\n   if (c)\n     cout <<  NO  << endl;\n   else\n     cout <<  YES  << endl;\n   return 0;\n }\n "}
{"func_code_string": "#include <bits/stdc++.h>\n using namespace std;\n const long long N = 1e5 + 5;\n int32_t main() {\n   ios::sync_with_stdio(0);\n   cin.tie(0);\n   cout.tie(0);\n   ;\n   long long n;\n   cin >> n;\n   long long con = -1;\n   long long a[n + 5];\n   for (long long i = 1; i <= n; i++) {\n     cin >> a[i];\n   }\n   long long i = 1;\n   for (i = 1; i < n; i++) {\n     if (a[i + 1] == a[i]) {\n       con = i;\n       break;\n     }\n   }\n   if (con == -1) {\n     for (con = 1; con < n; con++) {\n       if (a[con] > a[con + 1]) {\n         break;\n       }\n     }\n   }\n   for (i = 1; i < con; i++) {\n     if (a[i + 1] < a[i]) {\n       cout <<  NO \n            <<  \n ;\n       return 0;\n     }\n   }\n   while (a[con] == a[con + 1]) {\n     con++;\n   }\n   for (i = con; i < n; i++) {\n     if (a[i + 1] >= a[i]) {\n       cout <<  NO \n            <<  \n ;\n       return 0;\n     }\n   }\n   cout <<  YES \n        <<  \n ;\n }\n "}
{"func_code_string": "#include <bits/stdc++.h>\n using ll = long long;\n using namespace std;\n int main() {\n   ios::sync_with_stdio(false);\n   int N, K;\n   cin >> N >> K;\n   ll total = N + 1;\n   total += N;\n   total += min(2 * (K - 1) + (N - K), 2 * (N - K) + K - 1);\n   cout << total <<  \n ;\n   return 0;\n }\n "}
{"func_code_string": "#include <bits/stdc++.h>\n using namespace std;\n int k, n[20], a[20][5010], g[32768], f[32768], hsh[301781], ps[301781],\n     ans1[20], ans2[20], vis[20], TMS;\n pair<int, int> md[32768];\n long long sm[20];\n int get(int x) {\n   int y = (x + 1000000001) % 301781;\n   while (hsh[y] && hsh[y] ^ x + 1000000001) y = (y + 1) % 301781;\n   return y;\n }\n void dg(int x, int s1, int s2) {\n   if (x == k) {\n     f[s2 + s1] |= f[s1] * g[s2];\n     return;\n   }\n   dg(x + 1, s1, s2);\n   dg(x + 1, s1, s2 + (1 << x));\n   dg(x + 1, s1 + (1 << x), s2);\n }\n int main() {\n   scanf( %d , &k);\n   long long S = 0;\n   for (int i = 0; i < k; ++i) {\n     scanf( %d , n + i);\n     for (int j = 0; j < n[i]; ++j) {\n       int x;\n       scanf( %d , &x);\n       a[i][j] = x;\n       sm[i] += x;\n       S += x;\n       int w = get(x);\n       ps[w] = i;\n       hsh[w] = x + 1000000001;\n     }\n   }\n   if (S % k != 0) {\n     printf( No );\n     return 0;\n   }\n   S /= k;\n   for (int i = 0; i < k; ++i)\n     for (int j = 0; j < n[i]; ++j) {\n       int st = 1 << i, nw = i;\n       long long c = S - (sm[i] - a[i][j]);\n       int P = 1;\n       ++TMS;\n       for (;;) {\n         vis[nw] = TMS;\n         if (abs(c) > 1000000000) {\n           P = 0;\n           break;\n         }\n         int w = get(c);\n         if (!hsh[w]) {\n           P = 0;\n           break;\n         }\n         st |= 1 << ps[w];\n         if (ps[w] == i) {\n           P = c == a[i][j];\n           break;\n         }\n         c = S - (sm[ps[w]] - c);\n         nw = ps[w];\n         if (vis[nw] == TMS) {\n           P = 0;\n           break;\n         }\n       }\n       if (P) {\n         md[st] = make_pair(i, j);\n         g[st] = 1;\n       }\n     }\n   f[0] = 1;\n   dg(0, 0, 0);\n   if (f[(1 << k) - 1]) {\n     printf( Yes\n );\n     int ST = (1 << k) - 1;\n     while (ST) {\n       for (int _ = ST; _; _ = (_ - 1) & ST)\n         if (g[_] * f[ST - _]) {\n           int i = md[_].first, j = md[_].second, nw = i;\n           long long c = S - (sm[i] - a[i][j]), ls = a[i][j];\n           for (;;) {\n             int w = get(c);\n             ans1[ps[w]] = c;\n             ans2[ps[w]] = nw;\n             if (ps[w] == i) break;\n             ls = c;\n             nw = ps[w];\n             c = S - (sm[ps[w]] - c);\n           }\n           ST -= _;\n           break;\n         }\n     }\n     for (int i = 0; i < k; ++i) printf( %d %d\n , ans1[i], ans2[i] + 1);\n   } else {\n     printf( No );\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 int test = 1;\n   for (; test > 0; --test) {\n     long long int n, a, b, c, d, c1 = 1, c2, c3, c4;\n     cin >> n >> a >> b >> c >> d;\n     c2 = c1 + b - c;\n     c3 = c2 + a - d;\n     c4 = c3 + c - b;\n     long long int m = 1 - min(min(c1, c2), min(c3, c4)),\n                   m1 = max(max(c1, c2), max(c3, c4));\n     if (m1 + abs(m) > n)\n       cout << 0 << endl;\n     else\n       cout << (n - (m1 + abs(m)) + 1) * n << endl;\n   }\n   return (0);\n }\n "}
{"func_code_string": "#include <bits/stdc++.h>\n using namespace std;\n const long long int MAX = 1000000007;\n const long long int MAXN = 100010;\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, k;\n     cin >> n >> k;\n     if (n % 2 == 0 && k % 2 == 1)\n       cout <<  NO  << endl;\n     else if (n % 2 == 1 && k % 2 == 0)\n       cout <<  NO  << endl;\n     else {\n       if (k * k <= n)\n         cout <<  YES  << endl;\n       else\n         cout <<  NO  << endl;\n     }\n   }\n   return 0;\n }\n "}
{"func_code_string": "#include <bits/stdc++.h>\n using namespace std;\n int d[250003];\n int main() {\n   int i, j, k, n, m, t, a[501][501], b[501][501];\n   cin >> t;\n   while (t--) {\n     cin >> n >> m;\n     for (i = 0; i < n; i++)\n       for (j = 0; j < m; j++) cin >> a[i][j], d[a[i][j]] = i;\n     for (i = 0; i < m; i++)\n       for (j = 0; j < n; j++) cin >> b[i][j];\n     for (i = 0; i < n; i++) {\n       for (j = 0; j < m; j++) {\n         cout << a[d[b[0][i]]][j] <<    ;\n       }\n       cout << endl;\n     }\n   }\n }\n "}
{"func_code_string": "#include <bits/stdc++.h>\n using namespace std;\n vector<pair<long long int, pair<long long int, long long int> > > P;\n int level[1007];\n double ans = 0;\n bool contains(pair<long long int, pair<long long int, long long int> > A,\n               pair<long long int, pair<long long int, long long int> > B) {\n   return (A.second.first - B.second.first) * (A.second.first - B.second.first) +\n              (A.second.second - B.second.second) *\n                  (A.second.second - B.second.second) <\n          (A.first) * (A.first);\n }\n int main() {\n   long long int i, j, k, l, m, n, x, y, z, a, b, r;\n   scanf( %lld , &n);\n   for (i = 0; i < n; i++) {\n     scanf( %lld , &x);\n     scanf( %lld , &y);\n     scanf( %lld , &r);\n     P.push_back(make_pair(r, make_pair(x, y)));\n   }\n   sort(P.begin(), P.end());\n   for (i = n - 1; i >= 0; i--) {\n     for (j = n - 1; j > i; j--) {\n       if (contains(P[j], P[i])) {\n         level[i] = max(level[i], level[j] + 1);\n       }\n     }\n     if (level[i] == 0) level[i] = 1;\n   }\n   for (i = 0; i < n; i++) {\n     if (level[i] <= 2)\n       ans += (P[i].first * P[i].first);\n     else {\n       if (level[i] % 2 == 1)\n         ans -= (P[i].first * P[i].first);\n       else\n         ans += (P[i].first * P[i].first);\n     }\n   }\n   printf( %.10lf\n , ans * 3.14159265358979);\n   return 0;\n }\n "}
{"func_code_string": "#include <bits/stdc++.h>\n using namespace std;\n inline long long power(long long a, long long b) {\n   long long x = 1;\n   a = a % 1000000007ULL;\n   while (b) {\n     if (b & 1) x = (x * a) % 1000000007ULL;\n     a = (a * a) % 1000000007ULL;\n     b >>= 1;\n   }\n   return x;\n }\n inline long long inv(long long a) { return power(a, 1000000007ULL - 2); }\n long long gcd(long long a, long long b) { return a ? gcd(b % a, a) : b; }\n const int N = 2e5 + 5;\n vector<int> adj[N];\n int n, dis[N];\n bool vis[N];\n int cnt[N], p[N];\n int tdis[N];\n vector<int> d[N];\n void dfs(int u, int dd, int par) {\n   vis[u] = true;\n   if (dd < 3)\n     tdis[u] = dd;\n   else\n     tdis[u] = N;\n   dis[u] = dd;\n   d[dd].push_back(u);\n   p[u] = par;\n   for (auto v : adj[u]) {\n     if (!vis[v]) dfs(v, dd + 1, u);\n   }\n }\n int main() {\n   ios_base::sync_with_stdio(false);\n   cin >> n;\n   int u, v;\n   for (int i = 1; i < n; i++) {\n     cin >> u >> v;\n     adj[u].push_back(v);\n     adj[v].push_back(u);\n   }\n   dfs(1, 0, 0);\n   int maxx = 0;\n   for (int i = 0; i < n; i++) {\n     if (d[i].size() == 0) break;\n     maxx = i;\n   }\n   int ans = 0;\n   for (int i = maxx; i > 1; i--) {\n     for (auto v : d[i]) {\n       if (dis[v] < 2 || tdis[v] == 2) continue;\n       ans++;\n       tdis[p[v]] = 2;\n       for (auto j : adj[p[v]]) tdis[j] = 2;\n     }\n   }\n   cout << ans << endl;\n   return 0;\n }\n "}
{"func_code_string": "#include <bits/stdc++.h>\n using namespace std;\n int mod = 998244353;\n long long a[300001];\n long long n, m, k;\n int b[300001];\n void solve() {\n   cin >> n;\n   for (int i = 0; i < n; ++i) {\n     int x;\n     cin >> x;\n     a[x]++;\n     b[a[x]] += a[x];\n     k = (b[a[x]] >= i && b[a[x]] != n) ? b[a[x]] : k;\n   }\n   cout << k + 1;\n }\n int 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   return 0;\n }\n "}
{"func_code_string": "#include <bits/stdc++.h>\n using namespace std;\n int main() {\n   char str[2020];\n   long l;\n   cin >> l;\n   cin >> str;\n   int i, j, hs = 0, ts = 0;\n   for (i = 0; i < l; i++) {\n     if (str[i] == 'H')\n       hs++;\n     else\n       ts++;\n     str[l + i] = str[i];\n   }\n   int res = 1000000000;\n   int t;\n   for (i = 0; i < l; i++) {\n     t = 0;\n     for (j = 0; j < hs; j++) {\n       if (str[i + j] == 'T') t++;\n     }\n     if (t < res) res = t;\n     t = 0;\n     for (j = 0; j < ts; j++) {\n       if (str[i + j] == 'H') t++;\n     }\n     if (t < res) res = t;\n   }\n   cout << res;\n   return 0;\n }\n "}
{"func_code_string": "#include <bits/stdc++.h>\n using namespace std;\n long long a[1000000 + 100], f2, x1, x2, b[1000000 + 100], razl, sol, pok1, pok2;\n double f1;\n int main() {\n   for (int i = 1; i <= 4; i++) cin >> a[i];\n   f1 = sqrt(1 + 8 * a[1]) * 1.0;\n   f2 = sqrt(1 + 8 * a[1]);\n   if (f1 != f2) {\n     printf( Impossible\n );\n     return 0;\n   }\n   f1 = sqrt(1 + 8 * a[4]) * 1.0;\n   f2 = sqrt(1 + 8 * a[4]);\n   if (f1 != f2) {\n     printf( Impossible\n );\n     return 0;\n   }\n   x1 = 1 + sqrt(1 + 8 * a[1]);\n   x1 /= 2;\n   x2 = 1 + sqrt(1 + 8 * a[4]);\n   x2 /= 2;\n   if (a[1] == 0 && a[2] == 0 && a[3] == 0) x1 = 0;\n   if (a[4] == 0 && a[2] == 0 && a[3] == 0) x2 = 0;\n   if (a[2] + a[3] != x1 * x2) {\n     printf( Impossible\n );\n     return 0;\n   }\n   for (int i = 1; i <= x1; i++) b[i] = 0;\n   for (int i = x1 + 1; i <= x1 + x2; i++) b[i] = 1;\n   sol = x1 * x2;\n   pok1 = x1;\n   pok2 = x1 + x2;\n   while (sol != a[2]) {\n     if (sol - x2 > a[2])\n       swap(b[pok1], b[pok2]), pok1--, pok2--, sol -= x2;\n     else {\n       swap(b[pok1], b[pok1 + sol - a[2]]);\n       break;\n     }\n   }\n   if (x1 + x2 == 0) printf( 0 );\n   for (int i = 1; i <= x1 + x2; i++) cout << b[i];\n   printf( \n );\n   return 0;\n }\n "}
{"func_code_string": "#include <bits/stdc++.h>\n using namespace std;\n void mohammed() {\n   ios::sync_with_stdio(0);\n   ios_base::sync_with_stdio(0);\n   cin.tie(0), cout.tie(0);\n }\n int main() {\n   mohammed();\n   int n, x, y;\n   cin >> n;\n   map<int, int> mp;\n   map<int, int>::iterator it;\n   for (int i = 0; i < n; i++) {\n     cin >> x >> y;\n     mp[x]++;\n     mp[y + 1]--;\n   }\n   x = 0;\n   for (it = mp.begin(); it != mp.end(); it++) {\n     it->second += x;\n     if (it->second > 2) {\n       cout <<  NO ;\n       return 0;\n     }\n     x = it->second;\n   }\n   cout <<  YES ;\n   return 0;\n }\n "}
{"func_code_string": "#include <bits/stdc++.h>\n using namespace std;\n const double pi = acos(-1.0);\n template <typename T, typename U>\n inline void amin(T &x, U y) {\n   if (y < x) x = y;\n }\n template <typename T, typename U>\n inline void amax(T &x, U y) {\n   if (x < y) x = y;\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 }\n template <class T>\n ostream &operator<<(ostream &os, set<T> V) {\n   os <<  [ ;\n   for (auto vv : V) os << vv <<  ,  ;\n   return os <<  \b\b]\n ;\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 <<  \b\b]\n ;\n }\n template <class K, class X>\n ostream &operator<<(ostream &os, map<K, X> V) {\n   os <<  [ ;\n   for (auto vv : V) os << vv <<  ,  ;\n   return os <<  \b\b]\n ;\n }\n long int ceildiv(long int n, long int f) {\n   if (n % f) {\n     return n / f + 1;\n   } else\n     return n / f;\n }\n string checkTicket(vector<long> first, vector<long> second) {\n   int n = first.size();\n   if (first[0] < second[0]) {\n     for (int i = 0; i < n; i += 1) {\n       if (first[i] >= second[i]) {\n         return  NO\n ;\n       }\n     }\n   } else if (first[0] > second[0]) {\n     for (int i = 0; i < n; i += 1) {\n       if (first[i] <= second[i]) {\n         return  NO\n ;\n       }\n     }\n   } else {\n     return  NO\n ;\n   }\n   return  YES\n ;\n }\n int main() {\n   long int n;\n   cin >> n;\n   string s;\n   cin >> s;\n   vector<long> first, second;\n   for (int i = 0; i < n; i++) {\n     first.push_back(s[i] - '0');\n   }\n   for (int i = n; i < 2 * n; i++) {\n     second.push_back(s[i] - '0');\n   }\n   sort(first.begin(), first.end());\n   sort(second.begin(), second.end());\n   cerr << first << second;\n   cout << checkTicket(first, second);\n   return 0;\n }\n "}
{"func_code_string": "#include <bits/stdc++.h>\n using namespace std;\n const int N = 200005;\n int t[N];\n int p[N];\n int p2[N];\n int main() {\n   std::ios::sync_with_stdio(0);\n   cin.tie(0);\n   cout.tie(0);\n   int n;\n   long long sum = 0;\n   cin >> n;\n   for (int i = 0; i <= n; i++) {\n     cin >> t[i];\n     sum += t[i];\n   }\n   bool amb = 0;\n   for (int i = 1; i <= n; i++) {\n     if (t[i] > 1 && t[i - 1] > 1) amb = 1;\n   }\n   if (!amb) {\n     cout <<  perfect ;\n     return 0;\n   }\n   cout <<  ambiguous  << '\n';\n   long long par = 1, k = 2;\n   p[1] = 0;\n   p2[1] = 0;\n   for (int i = 1; i <= n; i++) {\n     long long temp = k;\n     for (int j = 0; j < t[i]; j++) {\n       p[k] = par;\n       p2[k] = par;\n       k++;\n     }\n     par = temp;\n   }\n   k = 2;\n   for (int i = 1; i <= n; i++) {\n     if (t[i] > 1 && t[i - 1] > 1) {\n       p2[k]++;\n       break;\n     } else\n       k += t[i];\n   }\n   for (int i = 1; i <= sum; i++) cout << p[i] <<    ;\n   cout << '\n';\n   for (int i = 1; i <= sum; i++) cout << p2[i] <<    ;\n }\n "}
{"func_code_string": "#include <bits/stdc++.h>\n using namespace std;\n int main() {\n   int n;\n   cin >> n;\n   long long sum1 = 0, sum2 = 0;\n   long temp;\n   for (int i = 0; i < n; i++) {\n     cin >> temp;\n     sum1 += temp;\n   }\n   for (int i = 0; i < n - 1; i++) {\n     cin >> temp;\n     sum2 += temp;\n   }\n   cout << sum1 - sum2 <<  \n ;\n   for (int i = 0; i < n - 2; i++) {\n     cin >> temp;\n     sum2 -= temp;\n   }\n   cout << sum2;\n   return (0);\n }\n "}
{"func_code_string": "#include <bits/stdc++.h>\n using namespace std;\n const int N = (1 << 20) + 15;\n long long dp[N];\n pair<int, int> id[100];\n int bit[100], c[100], st[N];\n int main() {\n   int u, a, mi, n, m, i, j, b, x, p = 0, idd;\n   long long k, temp;\n   long long ret = 4e18;\n   scanf( %d%d%d , &n, &m, &b);\n   for (i = 0; i < n; ++i) {\n     scanf( %d%d%d , &c[i], &id[i].first, &mi);\n     a = 0;\n     for (j = 0; j < mi; ++j) scanf( %d , &u), a |= 1 << (u - 1);\n     bit[i] = a;\n     id[i].second = i;\n   }\n   memset(dp, -1, sizeof(dp));\n   sort(id, id + n);\n   dp[0] = 0;\n   ++p;\n   for (i = 0; i < n; ++i) {\n     k = id[i].first, idd = id[i].second;\n     if (dp[bit[idd]] != -1 && dp[bit[idd]] <= c[idd]) continue;\n     x = p;\n     for (j = 0; j < p; ++j) {\n       u = st[j] | bit[idd];\n       if (dp[u] == -1 && u != (1 << m) - 1) st[x++] = u;\n       if (dp[u] == -1 || dp[u] > dp[st[j]] + c[idd]) dp[u] = dp[st[j]] + c[idd];\n     }\n     if (dp[(1 << m) - 1] != -1) ret = min(ret, k * b + dp[(1 << m) - 1]);\n     p = x;\n   }\n   if (ret == 4e18) ret = -1;\n   cout << ret << endl;\n }\n "}
{"func_code_string": "#include <bits/stdc++.h>\n using namespace std;\n int cnt[1000100], a[1000100];\n int main() {\n   int n, k, ans;\n   scanf( %d , &n);\n   scanf( %d , &k);\n   for (long long i = 0; i < n; i++) scanf( %d , &a[i]);\n   int l = 0, r = 0, al, ar;\n   set<int> x;\n   cnt[a[0]]++;\n   x.insert(a[0]);\n   ans = 1;\n   al = 0, ar = 0;\n   while (l < n && r < n) {\n     r++;\n     x.insert(a[r]);\n     cnt[a[r]]++;\n     while ((long long)x.size() > k && l <= r) {\n       cnt[a[l]]--;\n       if (cnt[a[l]] == 0) x.erase(a[l]);\n       l++;\n     }\n     r = max(l, r);\n     if (r >= n) break;\n     if (r - l + 1 > ans) {\n       al = l;\n       ar = r;\n       ans = r - l + 1;\n     }\n   }\n   printf( %d %d\n , al + 1, ar + 1);\n   return 0;\n }\n "}
{"func_code_string": "#include <bits/stdc++.h>\n using namespace std;\n const int M = 105;\n int l[M], r[M], t[M], c[M], res[M], p[M];\n int main() {\n   int n, m;\n   cin >> n >> m;\n   for (int i = 0; i < m; ++i) {\n     cin >> l[i] >> r[i] >> t[i] >> c[i];\n   }\n   for (int i = 1; i <= n; ++i) p[i] = INT_MAX;\n   for (int i = 0; i < m; ++i)\n     for (int j = l[i]; j <= r[i]; ++j)\n       if (t[i] < p[j]) p[j] = t[i], res[j] = i;\n   int sum = 0;\n   for (int i = 1; i <= n; ++i)\n     if (p[i] != INT_MAX) sum += c[res[i]];\n   cout << sum << endl;\n }\n "}
{"func_code_string": "#include <bits/stdc++.h>\n using namespace std;\n const long double EPS = 1e-9, pi = acos(-1);\n const long long N = 1e5 + 5;\n long long r[N], h[N], n, F[N], dp[N];\n bool cmp(pair<long long, long long> a, pair<long long, long long> b) {\n   if (a.first == b.first) {\n     return a.second < b.second;\n   } else\n     return a.first < b.first;\n }\n void add(long long d, long long id) {\n   while (id <= n) {\n     F[id] = max(F[id], d);\n     id += (id & -id);\n   }\n }\n long long get(long long i) {\n   long long res = 0;\n   while (i) {\n     res = max(res, F[i]);\n     i -= (i & -i);\n   }\n   return res;\n }\n signed main() {\n   ios_base::sync_with_stdio(0);\n   cin.tie(0);\n   cin >> n;\n   for (long long i = 1; i <= n; ++i) cin >> r[i] >> h[i];\n   vector<pair<long long, long long> > A;\n   A.clear();\n   for (long long i = 1; i <= n; ++i) {\n     A.push_back({r[i] * r[i] * h[i], i});\n   }\n   sort(A.begin(), A.end(), cmp);\n   long long res = 0, id = 0, prev = A[0].first;\n   for (long long i = 0; i < n; ++i) {\n     if (prev != A[i].first) {\n       while (id < i) {\n         add(dp[id], A[id].second);\n         id++;\n       }\n     }\n     dp[i] = get(A[i].second) + A[i].first;\n     res = max(res, dp[i]);\n     prev = A[i].first;\n   }\n   cout << fixed << setprecision(9) << pi * res << 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   string str;\n   for (int i = 0; i < t; i++) {\n     cin >> str;\n     long long int res = 0;\n     long long int arr[str.size()];\n     if (str[0] == '+') {\n       arr[0] = 1;\n     } else {\n       arr[0] = -1;\n     }\n     for (int j = 1; j < str.size(); j++) {\n       if (str[j] == '+') {\n         arr[j] = arr[j - 1] + 1;\n       } else {\n         arr[j] = arr[j - 1] - 1;\n       }\n     }\n     int x = -1;\n     for (int j = 0; j < str.size(); j++) {\n       if (arr[j] == x) {\n         res = res + j + 1;\n         x--;\n       }\n     }\n     res = res + str.size();\n     cout << res << 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 <typename T>\n inline T CHMAX(T& a, const T b) {\n   return a = (a < b) ? b : a;\n }\n template <typename T>\n inline T CHMIN(T& a, const T b) {\n   return a = (a > b) ? b : a;\n }\n void CHECKTIME(std::function<void()> f) {\n   auto start = std::chrono::system_clock::now();\n   f();\n   auto end = std::chrono::system_clock::now();\n   auto res = std::chrono::duration_cast<std::chrono::nanoseconds>((end - start))\n                  .count();\n   std::cerr <<  [Time:  << res <<  ns  (  << res / (1.0e9) <<  s)]\n ;\n }\n template <class T>\n std::vector<std::vector<T>> VV(int n, int m, T init = T()) {\n   return std::vector<std::vector<T>>(n, std::vector<T>(m, init));\n }\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-9;\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 namespace FFT {\n const double pi = std::acos(-1);\n std::vector<std::complex<double>> tmp;\n size_t sz = 1;\n std::vector<std::complex<double>> fft(std::vector<std::complex<double>> a,\n                                       bool inv = false) {\n   size_t mask = sz - 1;\n   size_t p = 0;\n   for (size_t i = sz >> 1; i >= 1; i >>= 1) {\n     auto& cur = (p & 1) ? tmp : a;\n     auto& nex = (p & 1) ? a : tmp;\n     std::complex<double> e = std::polar(1., 2 * pi * i * (inv ? -1 : 1) / sz);\n     std::complex<double> w = 1;\n     for (size_t j = 0; j < sz; j += i) {\n       for (size_t k = 0; k < i; ++k) {\n         nex[j + k] =\n             cur[((j << 1) & mask) + k] + w * cur[(((j << 1) + i) & mask) + k];\n       }\n       w *= e;\n     }\n     ++p;\n   }\n   if (p & 1) std::swap(a, tmp);\n   if (inv)\n     for (size_t i = 0; i < sz; ++i) a[i] /= sz;\n   return a;\n }\n std::vector<ll> mul(std::vector<ll> a, std::vector<ll> b) {\n   size_t m = a.size() + b.size() - 1;\n   sz = 1;\n   while (m > sz) sz <<= 1;\n   tmp.resize(sz);\n   std::vector<std::complex<double>> A(sz), B(sz);\n   for (size_t i = 0; i < a.size(); ++i) A[i].real(a[i]);\n   for (size_t i = 0; i < b.size(); ++i) B[i].real(b[i]);\n   A = fft(A);\n   B = fft(B);\n   for (size_t i = 0; i < sz; ++i) A[i] *= B[i];\n   A = fft(A, true);\n   a.resize(m);\n   for (size_t i = 0; i < m; ++i) a[i] = std::round(A[i].real());\n   return a;\n }\n };  // namespace FFT\n signed main() {\n   std::ios::sync_with_stdio(false);\n   std::cin.tie(0);\n   ;\n   ll n, x;\n   MACRO_VAR_Scan(n, x);\n   ;\n   std::vector<ll> a(n);\n   for (auto& i : a) std::cin >> i;\n   ;\n   for (ll i = 0; i < ll(n); ++i) a[i] = a[i] < x;\n   std::vector<ll> b;\n   {\n     ll cnt = 0;\n     for (ll i = 0; i < ll(n + 1); ++i) {\n       if (i == n || a[i]) {\n         b.emplace_back(cnt);\n         cnt = 0;\n       } else {\n         ++cnt;\n       }\n     }\n   }\n   ll m = b.size();\n   {\n     ll ans = 0;\n     for (ll i = 0; i < ll(m); ++i) {\n       ans += (ll)b[i] * (b[i] + 1) / 2;\n     }\n     std::cout << (ans);\n     ;\n   }\n   {\n     for (ll i = 0; i < ll(m); ++i) ++b[i];\n     auto bb(b);\n     std::reverse((bb).begin(), (bb).end());\n     auto c = FFT::mul(b, bb);\n     std::vector<ll> ans(n, 0);\n     ll p = 0;\n     for (ll i = ll(m - 1) - 1; i >= 0; --i) {\n       ans[p++] = c[i];\n     }\n     for (ll i = 0; i < ll(n); ++i) {\n       std::cout <<    ;\n       std::cout << (ans[i]);\n       ;\n     }\n     std::cout <<  \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, k;\n   cin >> n >> k;\n   for (int i = 0; i < k; i++) {\n     if (n % 10 != 0) {\n       n = n - 1;\n     } else if (n % 10 == 0) {\n       n = n / 10;\n     }\n   }\n   cout << n;\n   return 0;\n }\n "}
{"func_code_string": "#include <bits/stdc++.h>\n using namespace std;\n const int N = 5e5 + 100;\n template <class nmsl>\n inline void read(nmsl &x) {\n   x = 0;\n   char ch = getchar(), w = 0;\n   while (!isdigit(ch)) w = (ch == '-'), ch = getchar();\n   while (isdigit(ch)) x = (x << 1) + (x << 3) + (ch ^ 48), ch = getchar();\n   x = w ? -x : x;\n }\n long long n, f[N], size[N], root[N], hd[N], bianshu, ans;\n struct abc {\n   int nxt, to;\n } qwq[N * 2];\n inline void addedg(int lai, int qu) {\n   qwq[++bianshu].nxt = hd[lai];\n   qwq[bianshu].to = qu;\n   hd[lai] = bianshu;\n }\n inline void first_dp(int u, int father) {\n   size[u] = 1;\n   for (register int i = hd[u]; i; i = qwq[i].nxt) {\n     int v = qwq[i].to;\n     if (v == father) continue;\n     first_dp(v, u);\n     size[u] += size[v];\n     f[u] += f[v];\n   }\n   f[u] += size[u];\n   return;\n }\n inline void dp(int u, int father) {\n   f[u] = 0;\n   for (register int i = hd[u]; i; i = qwq[i].nxt) {\n     int v = qwq[i].to;\n     f[u] += f[v];\n   }\n   long long tot = f[u] + n;\n   ans = max(ans, tot);\n   for (register int i = hd[u]; i; i = qwq[i].nxt) {\n     int v = qwq[i].to;\n     if (v == father) continue;\n     size[u] = n - size[v];\n     f[u] = tot - f[v] - size[v];\n     dp(v, u);\n   }\n }\n int main() {\n   read(n);\n   for (register int i = 1, qa, qb; i < n; i++)\n     read(qa), read(qb), addedg(qa, qb), addedg(qb, qa);\n   first_dp(1, 0);\n   ans = f[1];\n   dp(1, 0);\n   cout << ans;\n   return 0;\n }\n "}
{"func_code_string": "#include <bits/stdc++.h>\n using namespace std;\n const int M = 3000;\n int n, m;\n pair<pair<int, int>, int> v[M];\n map<pair<pair<int, int>, int>, vector<pair<pair<int, int>, int> > > Q;\n int gcd(int a, int b) { return !b ? a : gcd(b, a % b); }\n pair<pair<int, int>, int> get(int x1, int y1, int x2, int y2) {\n   int x = x2 - x1, y = y2 - y1;\n   if (x == 0)\n     y = 1;\n   else if (y == 0)\n     x = 1;\n   else {\n     int d = gcd(x, y);\n     x /= d, y /= d;\n   }\n   if (x < 0) x = -x, y = -y;\n   return make_pair(make_pair(x, y), y1 * x - x1 * y);\n }\n int sign(double x) {\n   if (fabs(x) < 1E-6) return 0;\n   return (x > 0) ? 1 : -1;\n }\n double dist(int x1, int y1, int x2, int y2) {\n   return sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2));\n }\n bool cmp(pair<pair<int, int>, int> a, pair<pair<int, int>, int> b) {\n   if (a.first != b.first) return a.first < b.first;\n   return a.second > b.second;\n }\n int main() {\n   Q.clear();\n   scanf( %d%d , &n, &m);\n   for (int i = 0; i < (n); i++) {\n     int x1, y1, x2, y2;\n     scanf( %d%d%d%d , &x1, &y1, &x2, &y2);\n     x1 *= 2, y1 *= 2, x2 *= 2, y2 *= 2;\n     if (make_pair(x1, y1) > make_pair(x2, y2)) {\n       swap(x1, x2);\n       swap(y1, y2);\n     }\n     pair<pair<int, int>, int> tmp = get(x1, y1, x2, y2);\n     Q[tmp].push_back(make_pair(make_pair(x1, y1), 1));\n     Q[tmp].push_back(make_pair(make_pair(x2, y2), -1));\n   }\n   for (int i = 0; i < (m); i++) {\n     scanf( %d%d%d , &v[i].first.first, &v[i].first.second, &v[i].second);\n     for (int j = 0; j < (i); j++) {\n       if (v[i].second != v[j].second) continue;\n       int x1 = v[i].first.first, y1 = v[i].first.second, r = v[i].second;\n       int x2 = v[j].first.first, y2 = v[j].first.second;\n       if (sign(2 * r - dist(x1, y1, x2, y2)) >= 0) continue;\n       int x0 = x1 + x2, y0 = y1 + y2;\n       int x = x2 * 2 - x0, y = y2 * 2 - y0;\n       pair<pair<int, int>, int> tmp = get(x0, y0, x0 - y, y0 + x);\n       if (Q.find(tmp) == Q.end()) continue;\n       Q[tmp].push_back(make_pair(make_pair(x0, y0), 0));\n     }\n   }\n   int ret = 0;\n   for (__typeof(Q.begin()) it = Q.begin(); it != Q.end(); it++) {\n     sort(it->second.begin(), it->second.end(), cmp);\n     int now = 0;\n     for (__typeof(it->second.begin()) t = it->second.begin();\n          t != it->second.end(); t++) {\n       if (t->second == 0) ret += now;\n       now += t->second;\n     }\n   }\n   printf( %d\n , ret);\n   return 0;\n }\n "}
{"func_code_string": "#include <bits/stdc++.h>\n using namespace std;\n int mpow(int base, int exp);\n void solve() {\n   long double n;\n   cin >> n;\n   long double sum = 0;\n   while (n) {\n     long double d;\n     d = (1) * 1.0 / n;\n     sum += d;\n     n--;\n   }\n   cout << sum << '\n';\n }\n int main() {\n   ios_base::sync_with_stdio(false);\n   cin.tie(NULL);\n   cout.tie(NULL);\n   ;\n   solve();\n   return 0;\n }\n int mpow(int base, int exp) {\n   base %= 1000000007;\n   int result = 1;\n   while (exp > 0) {\n     if (exp & 1) result = ((long long int)result * base) % 1000000007;\n     base = ((long long int)base * base) % 1000000007;\n     exp >>= 1;\n   }\n   return result;\n }\n "}
{"func_code_string": "#include <bits/stdc++.h>\n using namespace std;\n long long unsigned int countDivisors(long long unsigned int n) {\n   long long unsigned int cnt = 0;\n   for (long long unsigned int i = 1; i <= sqrt(n); i++) {\n     if (n % i == 0) {\n       if (n / i == i)\n         ++cnt;\n       else\n         cnt += 2;\n     }\n   }\n   return cnt;\n }\n int Search(string pat, string txt) {\n   int n = txt.size();\n   int m = pat.size();\n   for (int i = 0; i <= n - m; i++) {\n     int j;\n     for (j = 0; j < m; j++) {\n       if (txt[i + j] != pat[j]) {\n         break;\n       }\n     }\n     if (j == m) {\n       return i;\n     }\n   }\n   return -1;\n }\n int findFirst(const std::vector<long long int> &array, int key, int low,\n               int high) {\n   int ans = -1;\n   while (low <= high) {\n     int mid = low + (high - low) / 2;\n     if (key == array[mid]) {\n       ans = mid;\n       high = mid - 1;\n     } else if (key > array[mid])\n       low = mid + 1;\n     else\n       high = mid - 1;\n   }\n   return ans;\n }\n int findLast(const std::vector<long long int> &array, int key, int low,\n              int high) {\n   int ans = -1;\n   while (low <= high) {\n     int mid = low + (high - low) / 2;\n     if (key == array[mid]) {\n       ans = mid;\n       low = mid + 1;\n     } else if (key > array[mid])\n       low = mid + 1;\n     else\n       high = mid - 1;\n   }\n   return ans;\n }\n int d, x, y;\n void extendedEuclid(int a, int b) {\n   if (b == 0) {\n     d = 1;\n     x = 1;\n     y = 0;\n   } else {\n     extendedEuclid(b, a % b);\n     int temp = x;\n     x = y;\n     y = temp - (a / b) * y;\n   }\n }\n int main() {\n   std::ios::sync_with_stdio(false);\n   cin.tie(NULL);\n   cout.tie(NULL);\n   ;\n   int t;\n   t = 1;\n   for (int tc = 0; tc < t; tc++) {\n     int n;\n     cin >> n;\n     vector<int> arr(n), brr(n, 0), v;\n     for (int i1 = 0; i1 < n; i1++) cin >> arr[i1];\n     int pos = 0;\n     for (int i = 0; i < n; i++) {\n       int indx = n - arr[i];\n       brr[indx] = 1;\n       while (brr[pos] == 1 && pos < n) {\n         cout << (n - pos) <<    ;\n         pos++;\n       }\n       cout << endl;\n     }\n   }\n   return 0;\n }\n "}
{"func_code_string": "#include <bits/stdc++.h>\n using namespace std;\n long long mp[1005][1005];\n long long n, a, b;\n void output() {\n   for (long long i = 1; i <= n; i++) {\n     for (long long j = 1; j <= n; j++) {\n       if (i == j)\n         printf( 0 );\n       else\n         printf( %lld , a < b ? !mp[i][j] : mp[i][j]);\n     }\n     printf( \n );\n   }\n }\n int main() {\n   scanf( %lld%lld%lld , &n, &a, &b);\n   long long root = 2;\n   if ((a != 1 && b != 1)) {\n     printf( NO\n );\n     return 0;\n   }\n   if (n == 2 && a == 1 && b == 1) {\n     printf( NO\n );\n     return 0;\n   }\n   if (n == 3 && a == 1 && b == 1) {\n     printf( NO\n );\n     return 0;\n   }\n   printf( YES\n );\n   if (a == 1 && b == 1)\n     for (long long i = 1; i < n; i++) mp[i][i + 1] = mp[i + 1][i] = true;\n   else\n     for (long long i = 0; i < n - max(a, b); i++, root++)\n       mp[1][root] = mp[root][1] = true;\n   output();\n }\n "}
{"func_code_string": "#include <bits/stdc++.h>\n using namespace std;\n long long power(long long a, long long b) {\n   long long ans = 1;\n   while (b > 0) {\n     if (b % 2 != 0) {\n       ans = (ans * a) % 1000000007;\n     }\n     a = ((a % 1000000007) * (a % 1000000007)) % 1000000007;\n     b >>= 1;\n   }\n   return ans;\n }\n void sieve(int n) {\n   bool prime[n + 1];\n   memset(prime, true, sizeof(prime));\n   for (int p = 2; p * p <= n; p++) {\n     if (prime[p]) {\n       for (int i = p * p; i <= n; i += p) prime[i] = false;\n     }\n   }\n   for (int p = 2; p <= n; p++) {\n     if (prime[p]) cout << p <<    ;\n   }\n }\n int main() {\n   std::ios::sync_with_stdio(false);\n   cin.tie(NULL);\n   cout.tie(NULL);\n   ;\n   int t = 1;\n   cin >> t;\n   while (t--) {\n     int n, k;\n     cin >> n >> k;\n     vector<vector<int>> v;\n     for (int i = 0; i < k; i++) {\n       int c;\n       cin >> c;\n       vector<int> temp;\n       for (int j = 0; j < c; j++) {\n         int z;\n         cin >> z;\n         temp.push_back(z);\n       }\n       v.push_back(temp);\n     }\n     int l = 1, h = n;\n     int ma;\n     cout <<  ? \n          <<     << n <<    ;\n     for (int i = 1; i <= n; i++) cout << i <<    ;\n     cout << endl;\n     cin >> ma;\n     for (int i = 0; i < 10; i++) {\n       int mid = (h + l) / 2;\n       int temp;\n       cout <<  ? \n            <<     << mid - l + 1 <<    ;\n       for (int kha = l; kha <= mid; kha++) cout << kha <<    ;\n       cout << endl;\n       cin >> temp;\n       if (temp == ma)\n         h = mid;\n       else\n         l = mid;\n     }\n     int ind = h;\n     bool flag = false;\n     vector<int> ans;\n     for (int i = 0; i < v.size(); i++) {\n       sort(v[i].begin(), v[i].end());\n       for (int j = 0; j < v[i].size(); j++) {\n         if (v[i][j] == ind) {\n           flag = true;\n           cout <<  ? \n                <<    ;\n           vector<int> loa;\n           for (int lo = 1; lo <= n; lo++) {\n             if (binary_search(v[i].begin(), v[i].end(), lo) == false) {\n               loa.push_back(lo);\n             }\n           }\n           cout << loa.size() <<    ;\n           for (auto lo : loa) cout << lo <<    ;\n           cout << endl;\n           int kha;\n           cin >> kha;\n           ans.push_back(kha);\n         }\n       }\n       if (flag == false) {\n         ans.push_back(ma);\n       } else {\n         flag = false;\n       }\n     }\n     cout <<  ! \n          <<    ;\n     for (auto i : ans) cout << i <<    ;\n     cout << endl;\n     string sa;\n     cin >> sa;\n     if (sa ==  Correct ) {\n       continue;\n     } else {\n       return 0;\n     }\n   }\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 maxn = 2e6 + 10;\n int a[maxn], cnt[maxn];\n long long sum[maxn];\n int main(void) {\n   int n, x, y;\n   scanf( %d %d %d , &n, &x, &y);\n   int z = x / y;\n   for (int i = 1; i <= n; i++)\n     scanf( %d , a + i), cnt[a[i]]++, sum[a[i]] += a[i];\n   for (int i = 1; i <= 2000000; i++) cnt[i] += cnt[i - 1], sum[i] += sum[i - 1];\n   long long ans = INF;\n   for (int i = 2; i <= 1000000; i++) {\n     long long tmp = 0;\n     int zz = min(z, i - 1);\n     for (int j = 1; (j - 1) * i < 1000000; j++) {\n       if (i - zz - 2 >= 0)\n         tmp += (long long)(cnt[j * i - zz - 1] - cnt[j * i - i]) * x;\n       if (zz)\n         tmp += ((long long)i * j * (cnt[j * i - 1] - cnt[j * i - zz - 1]) -\n                 (sum[j * i - 1] - sum[j * i - zz - 1])) *\n                y;\n     }\n     ans = min(ans, tmp);\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 md = 1e9 + 7;\n int n;\n char s[111];\n int f[111][3333];\n int main() {\n   int t;\n   f[0][0] = 1;\n   for (int i = 1; i <= 100; ++i) {\n     for (int j = 0; j <= 3000; ++j) {\n       for (int c = 0; c <= min(j, 25); ++c) {\n         f[i][j] += f[i - 1][j - c];\n         f[i][j] %= md;\n       }\n     }\n   }\n   scanf( %d , &t);\n   while (t--) {\n     scanf( %s , s);\n     int sum = 0;\n     for (int i = 0; i < strlen(s); ++i) sum += s[i] - 'a';\n     printf( %d\n , (f[strlen(s)][sum] + md - 1) % md);\n   }\n   return 0;\n }\n "}
{"func_code_string": "#include <bits/stdc++.h>\n #pragma GCC optimize ( O3 )\n #pragma GCC target ( sse4 )\n  \n using namespace std;\n  \n typedef long long ll;\n typedef long double ld;\n typedef complex<ld> cd;\n  \n typedef pair<int, int> pi;\n typedef pair<ll,ll> pl;\n typedef pair<ld,ld> pd;\n  \n typedef vector<int> vi;\n typedef vector<ld> vd;\n typedef vector<ll> vl;\n typedef vector<pi> vpi;\n typedef vector<pl> vpl;\n typedef vector<cd> vcd;\n \n template<class T> using pq = priority_queue<T>;\n template<class T> using pqg = priority_queue<T, vector<T>, greater<T>>;\n  \n #define FOR(i, a, b) for (int i=a; i<(b); i++)\n #define F0R(i, a) for (int i=0; i<(a); i++)\n #define FORd(i,a,b) for (int i = (b)-1; i >= a; i--)\n #define F0Rd(i,a) for (int i = (a)-1; i >= 0; i--)\n #define trav(a,x) for (auto& a : x)\n #define uid(a, b) uniform_int_distribution<int>(a, b)(rng)\n  \n #define sz(x) (int)(x).size()\n #define mp make_pair\n #define pb push_back\n #define f first\n #define s second\n #define lb lower_bound\n #define ub upper_bound\n #define all(x) x.begin(), x.end()\n #define ins insert\n \n template<class T> bool ckmin(T& a, const T& b) { return b < a ? a = b, 1 : 0; }\n template<class T> bool ckmax(T& a, const T& b) { return a < b ? a = b, 1 : 0; }\n  \n mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());\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 \n template<typename T, typename V>\n void __print(const pair<T, V> &x) {cerr << '{'; __print(x.first); cerr <<  ,  ; __print(x.second); cerr << '}';}\n template<typename T>\n void __print(const T &x) {int f = 0; cerr << '{'; for (auto &i: x) cerr << (f++ ?  ,   :   ), __print(i); cerr <<  } ;}\n void _print() {cerr <<  ]\n ;}\n template <typename T, typename... V>\n void _print(T t, V... v) {__print(t); if (sizeof...(v)) cerr <<  ,  ; _print(v...);}\n #ifdef DEBUG\n #define dbg(x...) cerr <<  \e[91m <<__func__<< : <<__LINE__<<  [  << #x <<  ] = [ ; _print(x); cerr <<  \e[39m  << endl;\n #else\n #define dbg(x...)\n #endif\n \n \n const int MOD = 1000000007;\n const char nl = '\n';\n const int MX = 200001; \n \n int dist[MX];\n int A[MX];\n set<pi> rem;\n pqg<pi> q;\n \n void add(int p, int pre, bool ty) {\n     auto it1 = rem.lb({p, -1});\n     if (it1 != rem.end()) {\n         int v = it1->s;\n         int d = max(pre, abs(A[v]-p));\n         if (ty) {\n             d = pre + abs(A[v]-p);\n         }\n         if (d < dist[v]) {\n             dist[v] = d;\n             q.push({d, v});\n         }\n     }\n     if (it1 != rem.begin()) {\n         it1--;\n         int v = it1->s;\n         int d = max(pre, abs(A[v]-p));\n         if (ty) {\n             d = pre + abs(A[v]-p);\n         }\n         if (d < dist[v]) {\n             dist[v] = d;\n             q.push({d, v});\n         }\n     }\n }\n \n void push(int p, int K) {\n     while (rem.lb({p, -1}) != rem.end() && rem.lb({p, -1})->f <= p+K) {\n         int x = rem.lb({p, -1})->s;\n         rem.erase({A[x], x});\n         q.push({K, x});\n         dist[x] = K;\n     }\n     auto it = rem.lb({p, -1});\n     while (it != rem.begin()) {\n         it--;\n         if (it->f < p-K) break;\n         int x = it->s;\n         rem.erase({A[x], x});\n         q.push({K, x});\n         dist[x] = K;\n         it = rem.lb({p, -1});\n     }\n }\n \n \n void solve() {\n     int N, Q; cin >> N >> Q;\n     F0R(i, N) dist[i] = 100000000;\n     int S; cin >> S; S--;\n     int D; cin >> D;\n     F0R(i, N) {\n         cin >> A[i];\n         if (i != S) rem.ins({A[i], i});\n     }\n     dist[S] = 0;\n     add(A[S]+D, 0, true);\n     add(A[S]-D, 0, true);\n     bool vis[MX]; F0R(i, N) vis[i] = false;\n     while (!q.empty()) {\n         int v = q.top().s;\n         int d = q.top().f;\n         q.pop();\n         if (vis[v]) continue;\n         vis[v] = true;\n         //dbg(v, d);\n         rem.erase({A[v], v});\n         add(A[v], d, true);\n         push(A[v]+D, d);\n         push(A[v]-D, d);\n         add(A[v]+D, 0, true);\n         add(A[v]-D, 0, true);\n     }\n     /*F0R(i, N) {\n         cout << dist[i] <<    ;\n     }\n     cout << nl;*/\n \n     while(Q--) {\n         int X, V; cin >> X >> V; X--;\n         cout << (dist[X]<=V? Yes : No ) << nl;\n     }\n }\n  \n int main() {\n     cin.tie(0)->sync_with_stdio(0); \n     cin.exceptions(cin.failbit);\n \n     int T = 1;\n //    cin >> T;\n     while(T--) {\n         solve();\n     }\n \n 	return 0;\n }\n \n \n "}
{"func_code_string": "#include <bits/stdc++.h>\n using namespace std;\n long long k, b, n, t;\n int main() {\n   ios_base ::sync_with_stdio(0);\n   cin.tie(0);\n   cin >> k >> b >> n >> t;\n   long long num = 1;\n   long long step = n;\n   while (t >= num) {\n     num = num * k + b;\n     step--;\n   }\n   if (step < 0) {\n     cout << 0;\n     return 0;\n   }\n   cout << step + 1;\n   return 0;\n }\n "}
{"func_code_string": "#include <bits/stdc++.h>\n const long double pi = 3.14159265359;\n const long long N = 1e9 + 7;\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, arr[200005];\n   cin >> n >> m;\n   long long cntne = 0, cntpo = 0;\n   for (int i = 0; i < n; i++) {\n     cin >> arr[i];\n     if (arr[i] == -1)\n       cntne++;\n     else\n       cntpo++;\n   }\n   vector<long long> v;\n   for (int i = 0; i < m; i++) {\n     long long l, r;\n     cin >> l >> r;\n     r++;\n     long long ans = abs(l - r);\n     if ((ans % 2 == 0) && (cntne >= ans / 2) && (cntpo >= ans / 2))\n       v.push_back(1);\n     else\n       v.push_back(0);\n   }\n   for (int i = 0; i < ((long long)((v).size())); i++) cout << v[i] << endl;\n   return 0;\n }\n "}
{"func_code_string": "#include <iostream>\n #include <vector>\n #include <algorithm>\n #include <string>\n \n #define ll long long\n \n using namespace std;\n \n int main() {\n     ll qua;\n     cin >> qua;\n     for (int i = 0; i < qua; ++i) {\n         ll n;\n         cin >> n;\n         vector<int> vec(n);\n         for (int j = 0; j < n; ++j) {\n             cin >> vec[j];\n         }\n         cout << 0 << ' ';\n         for (int j = 1; j < n; ++j) {\n             ll r = (vec[j] | vec[j - 1]) - vec[j];\n             cout << r << ' ';\n             vec[j] += r;\n         }\n         cout << '\n';\n     }\n     return 0;\n }\n "}
{"func_code_string": "#include <bits/stdc++.h>\n using namespace std;\n const int MaxN = 100005;\n const int MaxM = MaxN * 2;\n const int oo = 0x3F3F3F3F;\n int ax[MaxM], K;\n int ret[MaxN];\n set<pair<int, int> > tr[MaxM];\n struct event {\n   int l, r, v, tp;\n   event() {}\n   event(int l, int r, int v, int tp) : l(l), r(r), v(v), tp(tp) {}\n   bool operator<(const event& e) const {\n     if (r != e.r)\n       return r > e.r;\n     else\n       return tp < e.tp;\n   }\n } e[MaxM];\n int getId(int v) { return lower_bound(ax, ax + K, v) - ax + 1; }\n void add(int k, pair<int, int> v) {\n   while (k <= K) {\n     tr[k].insert(v);\n     k += k & -k;\n   }\n }\n int read(int k, int v) {\n   pair<int, int> ret = make_pair(oo, -1);\n   while (k) {\n     set<pair<int, int> >::iterator it = tr[k].lower_bound(make_pair(v, 0));\n     if (it != tr[k].end()) ret = min(ret, *it);\n     k -= k & -k;\n   }\n   return ret.second;\n }\n int main() {\n   int N, M, en;\n   int l, r, t;\n   scanf( %d%d , &N, &M);\n   K = en = 0;\n   for (int i = 0; i < N; i++) {\n     scanf( %d%d%d , &l, &r, &t);\n     e[en++] = event(l, r, t, -i - 1);\n     ax[K++] = l;\n   }\n   for (int i = 0; i < M; i++) {\n     scanf( %d%d%d , &l, &r, &t);\n     e[en++] = event(l, r, t, i);\n     ax[K++] = l;\n   }\n   sort(ax, ax + K);\n   K = unique(ax, ax + K) - ax;\n   sort(e, e + en);\n   for (int i = 0; i < en; i++) {\n     if (e[i].tp < 0) {\n       add(getId(e[i].l), make_pair(e[i].v, -e[i].tp));\n     } else {\n       ret[e[i].tp] = read(getId(e[i].l), e[i].v);\n     }\n   }\n   for (int i = 0; i < M; i++) {\n     printf( %d  , ret[i]);\n   }\n   puts(  );\n   return 0;\n }\n "}
{"func_code_string": "#include <bits/stdc++.h>\n using namespace std;\n template <typename T, typename U>\n std::istream& operator>>(std::istream& i, pair<T, U>& p) {\n   i >> p.first >> p.second;\n   return i;\n }\n template <typename T>\n std::istream& operator>>(std::istream& i, vector<T>& t) {\n   for (auto& v : t) {\n     i >> v;\n   }\n   return i;\n }\n template <typename T, typename U>\n std::ostream& operator<<(std::ostream& o, const pair<T, U>& p) {\n   o << p.first << ' ' << p.second;\n   return o;\n }\n template <typename T>\n std::ostream& operator<<(std::ostream& o, const vector<T>& t) {\n   if (t.empty()) o << '\n';\n   for (size_t i = 0; i < t.size(); ++i) {\n     o << t[i] <<   \n [i == t.size() - 1];\n   }\n   return o;\n }\n template <typename T>\n using minheap = priority_queue<T, vector<T>, greater<T>>;\n template <typename T>\n using maxheap = priority_queue<T, vector<T>, less<T>>;\n unsigned int logceil(long long first) {\n   return first ? 8 * sizeof(long long) - __builtin_clzll(first) : 0;\n }\n namespace std {\n template <typename T, typename U>\n struct hash<pair<T, U>> {\n   hash<T> t;\n   hash<U> u;\n   size_t operator()(const pair<T, U>& p) const {\n     return t(p.first) ^ (u(p.second) << 7);\n   }\n };\n }  // namespace std\n template <typename T, typename F>\n T bsh(T l, T h, const F& f) {\n   T r = -1, m;\n   while (l <= h) {\n     m = (l + h) / 2;\n     if (f(m)) {\n       l = m + 1;\n       r = m;\n     } else {\n       h = m - 1;\n     }\n   }\n   return r;\n }\n template <typename F>\n double bshd(double l, double h, const F& f, double p = 1e-9) {\n   unsigned int r = 3 + (unsigned int)log2((h - l) / p);\n   while (r--) {\n     double m = (l + h) / 2;\n     if (f(m)) {\n       l = m;\n     } else {\n       h = m;\n     }\n   }\n   return (l + h) / 2;\n }\n template <typename T, typename F>\n T bsl(T l, T h, const F& f) {\n   T r = -1, m;\n   while (l <= h) {\n     m = (l + h) / 2;\n     if (f(m)) {\n       h = m - 1;\n       r = m;\n     } else {\n       l = m + 1;\n     }\n   }\n   return r;\n }\n template <typename F>\n double bsld(double l, double h, const F& f) {\n   unsigned int r = 200;\n   while (r--) {\n     double m = (l + h) / 2;\n     if (f(m)) {\n       h = m;\n     } else {\n       l = m;\n     }\n   }\n   return (l + h) / 2;\n }\n template <typename T>\n T gcd(T a, T b) {\n   if (a < b) swap(a, b);\n   return b ? gcd(b, a % b) : a;\n }\n template <typename T>\n class vector2 : public vector<vector<T>> {\n  public:\n   vector2() {}\n   vector2(size_t a, size_t b, T t = T())\n       : vector<vector<T>>(a, vector<T>(b, t)) {}\n };\n template <typename T>\n class vector3 : public vector<vector2<T>> {\n  public:\n   vector3() {}\n   vector3(size_t a, size_t b, size_t c, T t = T())\n       : vector<vector2<T>>(a, vector2<T>(b, c, t)) {}\n };\n template <typename T>\n class vector4 : public vector<vector3<T>> {\n  public:\n   vector4() {}\n   vector4(size_t a, size_t b, size_t c, size_t d, T t = T())\n       : vector<vector3<T>>(a, vector3<T>(b, c, d, t)) {}\n };\n template <typename T>\n class vector5 : public vector<vector4<T>> {\n  public:\n   vector5() {}\n   vector5(size_t a, size_t b, size_t c, size_t d, size_t e, T t = T())\n       : vector<vector4<T>>(a, vector4<T>(b, c, d, e, t)) {}\n };\n class GOmkarAndPies {\n  public:\n   vector<std::pair<int, int>> D;\n   int N, M, K;\n   void fix(int p) {\n     for (int i = 0; i < K; ++i) {\n       int s = p ^ 1 << i;\n       if (D[s].first > D[p].first + 1) {\n         D[s] = {D[p].first + 1, D[p].second};\n         fix(s);\n       }\n     }\n   };\n   void solve(istream& cin, ostream& cout) {\n     cin >> N >> M >> K;\n     string S, T;\n     cin >> S >> T;\n     vector<std::pair<int, int>> P(N);\n     cin >> P;\n     for (std::pair<int, int>& p : P) {\n       p.first--;\n       p.second--;\n     }\n     vector<int> X(K);\n     iota(X.begin(), X.end(), 0);\n     vector<vector<int>> W{X};\n     for (int i = 0; i < N; ++i) {\n       swap(X[P[i].first], X[P[i].second]);\n       vector<int> I(K);\n       for (int j = 0; j < K; ++j) I[X[j]] = j;\n       W.push_back(X);\n     }\n     auto apply = [&](int first, string S) {\n       int p = 0;\n       for (int i = 0; i < K; ++i) {\n         p |= (S[i] - '0') << W[first][i];\n       }\n       return p;\n     };\n     D.assign(1 << K, {K + 1, -1});\n     pair<int, std::pair<int, int>> ans{K + 1, {-1, -1}};\n     for (int i = N - M; i >= 0; --i) {\n       int TX = apply(i + M, T);\n       D[TX] = {0, i + M};\n       fix(TX);\n       int SX = apply(i, S);\n       ans = min(ans, {D[SX].first, {i + 1, D[SX].second}});\n     }\n     cout << K - ans.first << '\n' << ans.second << '\n';\n   }\n };\n int main() {\n   ios_base::sync_with_stdio(false);\n   cin.tie(nullptr);\n   cout.tie(nullptr);\n   GOmkarAndPies 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 int main() {\n   string s;\n   cin >> s;\n   cout << (regex_match(s, regex( (1|14|144)* )) ?  YES  :  NO );\n }\n "}
{"func_code_string": "#include <bits/stdc++.h>\n using namespace std;\n const int N = 3e3 + 5;\n int dw[N], up[N], E[N][2], Mn;\n vector<pair<int, int> > g[N];\n void dfs_down(int v, int p) {\n   dw[v] = 0;\n   for (pair<int, int> u : g[v])\n     if (u.first != p) dfs_down(u.first, v), dw[v] += dw[u.first] + u.second;\n }\n void dfs_up(int v, int p, int f = -1) {\n   if (f != -1) {\n     up[v] = up[p] + dw[p] - dw[v] + f - (f == 0);\n   } else\n     up[v] = 0;\n   Mn = min(Mn, dw[v] + up[v]);\n   for (pair<int, int> u : g[v])\n     if (u.first != p) dfs_up(u.first, v, u.second ^ 1);\n }\n int main() {\n   ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);\n   int n;\n   cin >> n;\n   if (n == 1) return cout <<  0\n , 0;\n   for (int i = 0; i < n - 1; i++) {\n     cin >> E[i][0] >> E[i][1];\n     g[E[i][0]].push_back({E[i][1], 0});\n     g[E[i][1]].push_back({E[i][0], 1});\n   }\n   int ans = n;\n   for (int i = 0; i < n - 1; i++) {\n     Mn = n, dfs_down(E[i][0], E[i][1]), dfs_up(E[i][0], E[i][1]);\n     int cur = Mn;\n     Mn = n, dfs_down(E[i][1], E[i][0]), dfs_up(E[i][1], E[i][0]);\n     cur += Mn;\n     ans = min(ans, cur);\n   }\n   cout << ans <<  \n ;\n }\n "}
{"func_code_string": "#include <bits/stdc++.h>\n using namespace std;\n int main() {\n   int n;\n   cin >> n;\n   cout << ceil(n / 2.0) - 1;\n }\n "}
{"func_code_string": "#include <bits/stdc++.h>\n using namespace std;\n const int N = 2e5 + 10;\n int y[N], pos[N];\n int main() {\n   int n, m, t = 0, ans = 0, cnt = 0;\n   scanf( %d %d , &n, &m);\n   for (int i = 1; i <= n; i++) scanf( %d , &y[i]);\n   for (int i = 1; i <= m; i++) {\n     int y1, y2, x;\n     scanf( %d %d %d , &y1, &y2, &x);\n     if (y1 == 1) {\n       pos[++t] = y2;\n     }\n     if (y2 == 1e9) {\n       ans++;\n     }\n   }\n   sort(y + 1, y + 1 + n);\n   sort(pos + 1, pos + 1 + t);\n   int i = 1, j = 1;\n   cnt = t, ans += n;\n   while (i <= n) {\n     while (j <= t) {\n       if (pos[j] < y[i]) {\n         j++, cnt--;\n       } else\n         break;\n     }\n     ans = min(ans, cnt + i - 1);\n     i++;\n   }\n   cout << ans;\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'), c = getchar();\n   return x * f;\n }\n const int N = 505, mod = 1e9 + 7;\n inline int inc(int x, int y) {\n   x += y - mod;\n   return x + (x >> 31 & mod);\n }\n inline int mul(int x, int y) { return 1ll * x * y % mod; }\n inline void Inc(int &x, int y) { x = inc(x, y); }\n int n, a[N], f[N][N];\n int main() {\n   n = read();\n   for (int i = 1; i <= n; i++) a[i] = read(), f[i][i] = 1;\n   for (int i = 1; i <= n + 1; i++) f[i][i - 1] = 1;\n   for (int len = 2; len < n; len++)\n     for (int l = 1; l <= n - len + 1; l++) {\n       int r = l + len - 1;\n       f[l][r] = f[l + 1][r];\n       for (int k = l + 1; k <= r; k++)\n         if (a[k] > a[l]) Inc(f[l][r], mul(f[l + 1][k - 1], f[k][r]));\n     }\n   printf( %d\n , f[2][n]);\n   return 0;\n }\n "}
{"func_code_string": "#include <bits/stdc++.h>\n using namespace std;\n const int MAXN = 2001;\n char a[MAXN][MAXN];\n int n, v[MAXN], r[MAXN], c[MAXN];\n int gao() {\n   int ret = 0;\n   memset(r, 0, sizeof(int) * n);\n   memset(c, 0, sizeof(int) * n);\n   for (int i = 0; i < n - 1; ++i) {\n     for (int j = n - 1; j > i; --j) {\n       if (a[i][j] ^ r[i] ^ c[j]) {\n         ++ret;\n         r[i] ^= 1;\n         c[j] ^= 1;\n       }\n     }\n   }\n   for (int i = 0; i < n; ++i) v[i] ^= (r[i] ^ c[i]);\n   memset(r, 0, sizeof(int) * n);\n   memset(c, 0, sizeof(int) * n);\n   for (int i = n - 1; i > 0; --i) {\n     for (int j = 0; j < i; ++j) {\n       if (a[i][j] ^ r[i] ^ c[j]) {\n         ++ret;\n         r[i] ^= 1;\n         c[j] ^= 1;\n       }\n     }\n   }\n   for (int i = 0; i < n; ++i) v[i] ^= (r[i] ^ c[i]);\n   for (int i = 0; i < n; ++i) ret += v[i];\n   return ret;\n }\n int main() {\n   while (scanf( %d , &n) != EOF) {\n     memset(v, 0, sizeof(int) * n);\n     for (int i = 0; i < n; ++i) {\n       scanf( %s , a[i]);\n       for (int j = 0; j < n; ++j) a[i][j] -= '0';\n       v[i] ^= (int)a[i][i];\n     }\n     printf( %d\n , gao());\n   }\n   return 0;\n }\n "}
{"func_code_string": "#include<bits/stdc++.h>\n using namespace std;\n typedef double db;\n typedef uint32_t u32;\n typedef uint64_t u64;\n typedef pair<int, int> pii;\n typedef pair<int, int> point;\n #define fi first\n #define se second\n #define pb(x) push_back(x)\n #define SZ(x) ((int) (x).size())\n #define all(x) (x).begin(), (x).end()\n #define rep(i, l, r) for(int i = l; i < r; i++)\n typedef long long ll;\n const int mod = 998244353;\n \n \n \n int main() {\n #ifdef local\n 	freopen( in.txt ,  r , stdin);\n #endif\n 	ios::sync_with_stdio(false);\n 	cin.tie(0), cout.tie(0);\n 	const int mod = 1e9 + 7;\n 	int n;\n 	cin >> n;\n 	vector<int> a(n);\n 	ll tot = 0;\n 	for(auto &e : a) {\n 		cin >> e;\n 		tot += e;\n 	}\n 	if(tot % n) {\n 		cout <<  0\n ;\n 		return 0;\n 	}\n 	vector<int> fac(n + 1, 1);\n 	vector<int> ifac(n + 1, 1);\n 	for(int i = 2; i <= n; i++) {\n 		fac[i] = (ll) fac[i - 1] * i % mod;\n 		ifac[i] = (ll) ifac[mod % i] * (mod - mod / i) % mod;\n 	}\n 	for(int i = 2; i <= n; i++) {\n 		ifac[i] = (ll) ifac[i] * ifac[i - 1] % mod;\n 	}\n 	auto C = [&](int n, int m) {\n 		if(n < m || m < 0) return 0ll;\n 		return (ll) fac[n] * ifac[m] % mod * ifac[n - m] % mod;\n 	};\n 	ll avg = tot / n;\n 	vector<int> l, r;\n 	int eq = 0;\n 	for(auto &e : a) {\n 		if(e > avg) {\n 			r.push_back(e);\n 		} else if(e < avg) {\n 			l.push_back(e);\n 		} else {\n 			eq++;\n 		}\n 	}\n 	int ans = 1;\n 	if(l.size() > 1 && r.size() > 1) {\n 		ans = 2;\n 	}\n 	if(l.size() == 1) {\n 		r.push_back(l[0]);\n 		l.clear();\n 	}\n 	if(r.size() == 1) {\n 		l.push_back(r[0]);\n 		r.clear();\n 	}\n 	sort(all(l));\n 	sort(all(r));\n 	int a1 = fac[l.size()];\n 	int a2 = fac[r.size()];\n 	for(int i = 0, j = 0; i < (int) l.size(); i = j) {\n 		while(j < (int) l.size() && l[j] == l[i]) {\n 			j++;\n 		}\n 		a1 = (ll) a1 * ifac[j - i] % mod;\n 	}\n 	for(int i = 0, j = 0; i < (int) r.size(); i = j) {\n 		while(j < (int) r.size() && r[j] == r[i]) {\n 			j++;\n 		}\n 		a2 = (ll) a2 * ifac[j - i] % mod;\n 	}\n 	int a3 = C(n, eq);\n 	ans = (ll) ans * a1 % mod;\n 	ans = (ll) ans * a2 % mod;\n 	ans = (ll) ans * a3 % mod;\n 	cout << ans << '\n';\n 	return 0;\n }\n "}
{"func_code_string": "#include <bits/stdc++.h>\n using namespace std;\n int main(void) {\n   int n;\n   cin >> n;\n   set<int> a, b;\n   vector<pair<int, int> > ans(n);\n   for (int i = 0; i < n; ++i) {\n     cin >> ans[i].first >> ans[i].second;\n     --ans[i].first;\n     --ans[i].second;\n     if (ans[i].first == -1) a.insert(i);\n     if (ans[i].second == -1) b.insert(i);\n   }\n   while (a.size() > 1) {\n     int node = *a.begin();\n     a.erase(a.begin());\n     int last = node;\n     while (ans[last].second != -1) last = ans[last].second;\n     auto nxt = b.begin();\n     if (*nxt == last) ++nxt;\n     ans[*nxt].second = node;\n     ans[node].first = *nxt;\n     b.erase(nxt);\n   }\n   for (int i = 0; i < n; ++i)\n     cout << 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 int main() {\n   int n;\n   cin >> n;\n   int a[n], sm = 0;\n   for (int i = 0; i < n; i++) {\n     cin >> a[i];\n     sm += a[i];\n   }\n   vector<int> ind, r;\n   int need = sm / 2;\n   if (a[0] > need) {\n     cout << 1 << endl;\n     cout << 1;\n     return 0;\n   }\n   for (int i = 1; i < n; i++) {\n     if ((2 * a[i]) <= a[0]) {\n       ind.push_back(i + 1);\n       r.push_back(a[i]);\n     }\n   }\n   bool ok;\n   int u = a[0];\n   for (auto x : r) {\n     u += x;\n   }\n   if (u > need) {\n     ok = true;\n   } else {\n     ok = false;\n   }\n   if (ok) {\n     cout << ind.size() + 1 << endl;\n     cout << 1 <<    ;\n     for (auto x : ind) {\n       cout << x <<    ;\n     }\n   } else {\n     cout << 0;\n   }\n }\n "}
{"func_code_string": "#include <bits/stdc++.h>\n using namespace std;\n int nbVoyages, coutSimple, coutLiaison, maxCartes, coutCarte;\n map<pair<string, string>, int> routes;\n int main() {\n   ios_base::sync_with_stdio(false);\n   cin >> nbVoyages >> coutSimple >> coutLiaison >> maxCartes >> coutCarte;\n   long long total = 0;\n   string derFin =   ;\n   for (int iVoyage = 0; iVoyage < nbVoyages; iVoyage++) {\n     string a, b;\n     cin >> a >> b;\n     string der = b, pre = a;\n     if (b < a) swap(a, b);\n     if (routes.find({a, b}) == routes.end()) routes[{a, b}] = 0;\n     if (derFin == pre) {\n       routes[{a, b}] += coutLiaison;\n       total += coutLiaison;\n     } else {\n       routes[{a, b}] += coutSimple;\n       total += coutSimple;\n     }\n     derFin = der;\n   }\n   vector<int> couts;\n   for (pair<pair<string, string>, int> route : routes) {\n     couts.push_back(route.second);\n   }\n   sort(couts.begin(), couts.end());\n   for (int iFois = 0; iFois < maxCartes; iFois++) {\n     if (!couts.empty() && couts.back() > coutCarte) {\n       total += coutCarte - couts.back();\n       couts.pop_back();\n     }\n   }\n   cout << total << endl;\n   return 0;\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 const int mod = 1000000007;\n int modpow(int x, int y, int md) {\n   if (y == 0) return 1;\n   int ret = modpow(x, y >> 1, md);\n   ret = (long long)ret * ret % md;\n   if (y & 1) ret = (long long)ret * x % md;\n   return ret;\n }\n int n;\n int sum[5555];\n vector<int> g[5555];\n set<pair<int, int> > ans;\n void dfs(int x, int par = 0) {\n   sum[x] = 1;\n   for (auto to : g[x])\n     if (to != par) dfs(to, x);\n   for (auto to : g[x])\n     if (to != par) sum[x] += sum[to];\n   vector<bool> ok(5555, false);\n   ok[0] = true;\n   for (auto to : g[x])\n     if (to != par) {\n       for (int i = 5005; i >= 0; i--)\n         if (ok[i] && i + sum[to] <= 5005) ok[i + sum[to]] = true;\n     }\n   for (int i = 1; i <= 5005; i++)\n     if (ok[i] && n - i - 1 >= 1)\n       ans.insert(make_pair(i, n - i - 1)), ans.insert(make_pair(n - i - 1, i));\n }\n int main() {\n   cin >> n;\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   dfs(1);\n   cout << ans.size() << endl;\n   for (auto p : ans) cout << p.first <<     << p.second << endl;\n   return 0;\n }\n "}
{"func_code_string": "#include <bits/stdc++.h>\n using namespace std;\n string s[3];\n int N, M, p[3][1000005], a[3][1000005], b[1000005];\n void genPrefix(int pat) {\n   int i, k;\n   p[pat][0] = 0;\n   k = 0;\n   i = 1;\n   while (i < M) {\n     if (s[pat][i] == s[pat][k]) {\n       k++;\n       p[pat][i] = k;\n       i++;\n     } else {\n       if (k != 0)\n         k = p[pat][k - 1];\n       else {\n         p[pat][i] = 0;\n         i++;\n       }\n     }\n   }\n }\n void KMPSearch(int txt, int pat) {\n   int i, k;\n   genPrefix(pat);\n   i = k = 0;\n   while (i < N) {\n     if (s[txt][i] == s[pat][k]) {\n       i++;\n       k++;\n       a[txt][i - k] = i - 1;\n     }\n     if (k == M) {\n       k = p[pat][k - 1];\n     } else if (i < N && s[txt][i] != s[pat][k]) {\n       if (k != 0) {\n         if (s[txt][i - 1] == s[pat][k])\n           a[txt][i - k] = max(i - 1, a[txt][k - 1]);\n         k = p[pat][k - 1];\n         if (k > 0 && s[txt][i - 1] == s[pat][k])\n           a[txt][i - k] = max(i - 1, a[txt][k - 1]);\n       } else\n         i++;\n     }\n   }\n }\n int bs(int low, int high, int v) {\n   int mid, x = -1;\n   while (low <= high) {\n     mid = (low + high) >> 1;\n     if (b[mid] >= v) {\n       x = mid;\n       high = mid - 1;\n     } else\n       low = mid + 1;\n   }\n   return x;\n }\n pair<int, int> solve() {\n   s[2] = s[0];\n   reverse(s[2].begin(), s[2].end());\n   memset(a, -1, sizeof(a));\n   KMPSearch(1, 2);\n   KMPSearch(0, 1);\n   b[0] = a[1][0];\n   int i, j = N, len, k, x;\n   int ansx = -1, ansy = -1;\n   for (i = 1; i <= N - 1; i++) b[i] = max(b[i - 1], a[1][i]);\n   for (i = 0; i <= N - 2; i++) {\n     j--;\n     if (s[0][i] != s[1][j]) break;\n     if (b[0] >= j - 1) {\n       ansx = i;\n       ansy = i + 1;\n     }\n     if (a[0][i + 1] <= 0 || i + 1 == N - 1) continue;\n     len = min(N - 2, a[0][i + 1]) - i;\n     k = bs(0, len, j - 1);\n     if (k >= 0 && ansx < i) {\n       ansx = i;\n       ansy = i + 1 + k;\n     }\n   }\n   return make_pair(ansx, ansy);\n }\n int main() {\n   std::ios_base::sync_with_stdio(0);\n   int cases, caseno = 0, n, i, j, k, cnt, m;\n   getline(cin, s[0]);\n   getline(cin, s[1]);\n   N = s[0].size();\n   M = s[1].size();\n   if (N != M) {\n     cout <<  -1 -1  << '\n';\n     return 0;\n   }\n   pair<int, int> ans = solve();\n   cout << ans.first <<     << ans.second << '\n';\n   return 0;\n }\n "}
{"func_code_string": "#include <bits/stdc++.h>\n using namespace std;\n int main() {\n   int n, x;\n   scanf( %d%d , &n, &x);\n   if (n == 1) {\n     printf( YES\n );\n     printf( %d\n , x);\n   } else if (n == 2) {\n     if (x == 0)\n       printf( NO\n );\n     else {\n       printf( YES\n );\n       printf( 0 %d\n , x);\n     }\n   } else {\n     printf( YES\n );\n     int tmp = 0;\n     int a = (1 << 17);\n     int b = (1 << 18);\n     for (int i = 0; i < n - 3; i++) {\n       printf( %d  , i);\n       tmp ^= i;\n     }\n     printf( %d %d %d\n , a, b, a ^ b ^ tmp ^ x);\n   }\n   return 0;\n }\n "}
{"func_code_string": "#include <bits/stdc++.h>\n using namespace std;\n bool psort(std::vector<long long int> p1, std::vector<long long int> p2) {\n   return p1[0] < p2[0];\n }\n int main() {\n   ios_base::sync_with_stdio(false);\n   cin.tie(NULL);\n   cout.tie(NULL);\n   long long int n, m;\n   cin >> n;\n   std::vector<vector<long long int> > v(n, vector<long long int>(3));\n   for (int i = 0; i < n; ++i) {\n     cin >> v[i][0];\n   }\n   for (int i = 0; i < n; ++i) {\n     cin >> v[i][1];\n   }\n   for (int i = 0; i < n; ++i) {\n     cin >> v[i][2];\n   }\n   sort(v.begin(), v.end(), psort);\n   cin >> m;\n   long long int start[4] = {0};\n   for (int i = 0; i < m; ++i) {\n     long long int k, t, flag = 0;\n     cin >> t;\n     while (start[t] < n) {\n       if (v[start[t]][0] != -1) {\n         if (v[start[t]][1] == t || v[start[t]][2] == t) {\n           cout << v[start[t]][0] <<    ;\n           v[start[t]][0] = -1;\n           start[t]++;\n           flag = 1;\n           break;\n         }\n       }\n       start[t]++;\n     }\n     if (flag == 0) cout << -1 <<    ;\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 fld;\n   cin >> fld;\n   int l = 1, r = 2 * n;\n   int ans = -1;\n   while (l <= r) {\n     int mid = (l + r) >> 1;\n     int posbl = 1;\n     int back = -1, flag = 0;\n     for (int i = 0; i < n; i++) {\n       if (fld[i] == '*')\n         if (i > back && flag == 0) back = i, flag = 1;\n       if (fld[i] == 'P') {\n         if (back == -1) {\n           back = i + mid;\n         } else {\n           if (i <= back) {\n             back = max(back, i + mid);\n           } else {\n             if (flag == 1) {\n               if (i - back > mid) {\n                 posbl = 0;\n                 break;\n               } else if (i - back <= mid && mid <= (2 * (i - back)))\n                 back = max(i, (mid - (i - back)) / 2 + i);\n               else {\n                 back =\n                     max(mid - (2 * (i - back)) + i, (mid - (i - back)) / 2 + i);\n               }\n             } else {\n               back = i + mid;\n             }\n           }\n         }\n         flag = 0;\n       }\n     }\n     if (flag == 1) posbl = 0;\n     if (posbl == 1) {\n       r = mid - 1;\n       ans = mid;\n     } else\n       l = mid + 1;\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 = 2e5 + 10;\n char s[N];\n char t1[7] =  twone ;\n char t2[4] =  one ;\n char t3[4] =  two ;\n int main() {\n   int T;\n   scanf( %d , &T);\n   while (T--) {\n     scanf( %s , s);\n     int ans = 0;\n     int len = strlen(s);\n     for (int i = 0; i < len; i++) {\n       if (s[i] == 't') {\n         int f = 0;\n         for (int j = i; j <= i + 4; j++) {\n           if (s[j] != t1[j - i]) {\n             f = 1;\n             break;\n           }\n         }\n         if (f == 0) {\n           s[i + 2] = '-';\n           ans++;\n         }\n       }\n     }\n     for (int i = 0; i < len; i++) {\n       if (s[i] == 't') {\n         int f = 0;\n         for (int j = i; j <= i + 2; j++) {\n           if (s[j] != t3[j - i]) {\n             f = 1;\n             break;\n           }\n         }\n         if (f == 0) {\n           s[i + 1] = '-';\n           ans++;\n         }\n       }\n     }\n     for (int i = 0; i < len; i++) {\n       if (s[i] == 'o') {\n         int f = 0;\n         for (int j = i; j <= i + 2; j++) {\n           if (s[j] != t2[j - i]) {\n             f = 1;\n             break;\n           }\n         }\n         if (f == 0) {\n           s[i + 1] = '-';\n           ans++;\n         }\n       }\n     }\n     printf( %d\n , ans);\n     for (int i = 0; i < len; i++)\n       if (s[i] == '-') printf( %d  , i + 1);\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_base::sync_with_stdio(0);\n   long long int n, m = 0, p = 0, cnt = 0, f = 0;\n   cin >> n;\n   long long int a[n];\n   for (long long int i = 0; i < n; i++) {\n     cin >> a[i];\n     if (a[i] < 0) {\n       m++;\n     }\n     if (a[i] > 0) p++;\n     if (a[i] < 0) {\n       cnt = cnt - a[i] - 1;\n     }\n     if (a[i] > 0) {\n       cnt = cnt + a[i] - 1;\n     }\n     if (a[i] == 0) {\n       cnt = cnt + 1;\n       f++;\n     }\n   }\n   if (f and m % 2 == 0) cout << cnt << endl;\n   if (f and m % 2 != 0) cout << cnt << endl;\n   if (!f and m % 2 == 0) cout << cnt << endl;\n   if (!f and m % 2 != 0) cout << cnt + 2 << endl;\n }\n "}
{"func_code_string": "#include <bits/stdc++.h>\n using namespace std;\n int n, m;\n int A[600006];\n vector<int> G[600006];\n int dfn[600006], bc[600006], clo;\n int g[600006][20], dep[600006];\n void dfs(int u) {\n   dfn[u] = ++clo, bc[clo] = u;\n   if (u == 1) dep[u] = 1;\n   for (int v : G[u]) {\n     g[v][0] = u;\n     dep[v] = dep[u] + 1;\n     for (int k = (1), kend = (18); k <= kend; ++k)\n       if (g[g[v][k - 1]][k - 1])\n         g[v][k] = g[g[v][k - 1]][k - 1];\n       else\n         break;\n     dfs(v);\n   }\n }\n int lca(int u, int v) {\n   if (dep[u] < dep[v]) swap(u, v);\n   if (dep[u] != dep[v])\n     for (int k = (18), kend = (0); k >= kend; --k)\n       if (dep[g[u][k]] >= dep[v]) u = g[u][k];\n   if (u == v) return u;\n   for (int k = (18), kend = (0); k >= kend; --k)\n     if (g[u][k] != g[v][k]) u = g[u][k], v = g[v][k];\n   return g[u][0];\n }\n int dis(int u, int v) { return dep[u] + dep[v] - 2 * dep[lca(u, v)]; }\n set<int> S;\n void solve() {\n   cin >> n;\n   ++n;\n   for (int i = (2), iend = (n); i <= iend; ++i) {\n     int p;\n     scanf( %d , &p);\n     G[p].push_back(i);\n   }\n   dfs(1);\n   int s = 1, t = 1, lt = 0;\n   auto wkr = [&](int x) { return max(dis(x, s), dis(x, t)); };\n   S.insert(1);\n   for (int i = (2), iend = (n); i <= iend; ++i) {\n     int is = dis(i, s), it = dis(i, t), flg = 0;\n     if (is >= lt && is >= it)\n       t = i, lt = is, flg = 1;\n     else if (it >= lt && it >= is)\n       s = i, lt = it, flg = 1;\n     if (!flg) {\n       printf( %d\n , (int)S.size());\n       continue;\n     }\n     auto tr = S.lower_bound(dfn[i]), st = tr;\n     while (tr != S.end()) {\n       if (wkr(bc[*tr]) < lt)\n         ++tr;\n       else\n         break;\n     }\n     if (tr == S.end()) {\n       auto sr = S.begin();\n       while (sr != st) {\n         if (wkr(bc[*sr]) < lt)\n           ++sr;\n         else\n           break;\n       }\n       S.erase(S.begin(), sr);\n     }\n     S.erase(st, tr);\n     tr = S.lower_bound(dfn[i]), st = tr;\n     while (tr != S.begin()) {\n       --tr;\n       if (wkr(bc[*tr]) >= lt) {\n         ++tr;\n         break;\n       }\n     }\n     if (tr == S.begin()) {\n       auto sr = S.end();\n       while (sr != st) {\n         --sr;\n         if (wkr(bc[*sr]) >= lt) {\n           ++sr;\n           break;\n         }\n       }\n       S.erase(sr, S.end());\n     }\n     S.erase(tr, st);\n     S.insert(dfn[i]);\n     printf( %d\n , (int)S.size());\n   }\n }\n signed main() { solve(); }\n "}
{"func_code_string": "#include <bits/stdc++.h>\n using namespace std;\n struct fenwick {\n   long long n, fen[100005];\n   void resize(int _n) {\n     n = _n + 1;\n     memset(fen, 0, sizeof fen);\n   }\n   int query(int ind) {\n     ind++;\n     int ans = 0;\n     while (ind >= 1) {\n       ans += fen[ind];\n       ind -= ind & -ind;\n     }\n     return ans;\n   }\n   void update(int ind, int val) {\n     ind++;\n     while (ind <= n) {\n       fen[ind] += val;\n       ind += ind & -ind;\n     }\n   }\n   int query(int l, int r) { return query(r) - query(l - 1); }\n };\n const int maxn = 100001;\n int n, l, w, x, y, sz[maxn];\n long long res;\n bool blocked[maxn];\n vector<pair<int, int> > c, v[maxn];\n fenwick tree;\n void dfs(int node, int pnode, int curw, int curl) {\n   c.push_back(make_pair(curw, curl));\n   for (auto &i : v[node])\n     if (i.first != pnode && !blocked[i.first])\n       dfs(i.first, node, curw + i.second, curl + 1);\n }\n long long solve(int node, int curw, int curl) {\n   long long ret = 0;\n   c.clear();\n   dfs(node, 0, curw, curl);\n   sort(c.begin(), c.end());\n   for (auto &i : c) tree.update(i.second, 1);\n   for (int i = 0, j = c.size() - 1; i < c.size(); i++) {\n     while (i <= j && c[i].first + c[j].first > w)\n       tree.update(c[j--].second, -1);\n     if (j < i) break;\n     tree.update(c[i].second, -1);\n     ret += tree.query(l - c[i].second);\n   }\n   return ret;\n }\n int dfsz(int node, int pnode) {\n   sz[node] = 1;\n   for (auto &i : v[node])\n     if (i.first != pnode && !blocked[i.first]) sz[node] += dfsz(i.first, node);\n   return sz[node];\n }\n int find(int node, int pnode, int n) {\n   for (auto &i : v[node])\n     if (i.first != pnode && !blocked[i.first] && 2 * sz[i.first] > n)\n       return find(i.first, node, n);\n   return node;\n }\n void decompose(int node) {\n   int centroid = find(node, 0, dfsz(node, 0));\n   blocked[centroid] = 1;\n   res += solve(centroid, 0, 0);\n   for (auto &i : v[centroid])\n     if (!blocked[i.first]) res -= solve(i.first, i.second, 1);\n   for (auto &i : v[centroid])\n     if (!blocked[i.first]) decompose(i.first);\n }\n int main() {\n   ios_base::sync_with_stdio(0);\n   cin.tie(NULL);\n   cout.tie(NULL);\n   cin >> n >> l >> w;\n   tree.resize(n + 1);\n   for (int i = 2; i <= n && cin >> x >> y; i++) {\n     v[i].push_back(make_pair(x, y));\n     v[x].push_back(make_pair(i, y));\n   }\n   decompose(1);\n   cout << res << endl;\n   return 0;\n }\n "}
{"func_code_string": "#include <bits/stdc++.h>\n const int maxn = 1e5 + 10;\n const int N = 5e2 + 10;\n using namespace std;\n long long gcd(long long p, long long q) { return q == 0 ? p : gcd(q, p % q); }\n long long qpow(long long p, long long q) {\n   long long f = 1;\n   while (q) {\n     if (q & 1) f = f * p % 1000000007;\n     p = p * p % 1000000007;\n     q >>= 1;\n   }\n   return f;\n }\n int n, m, k, t;\n vector<int> d[4][11][10];\n char a[maxn], b[maxn];\n int gao(char p) {\n   if (p == 'A')\n     return 0;\n   else if (p == 'T')\n     return 1;\n   else if (p == 'G')\n     return 2;\n   else\n     return 3;\n }\n void add(vector<int>& d, int x, int y) {\n   while (x < d.size()) d[x] += y, x += x & (-x);\n }\n int get(vector<int>& d, int x) {\n   int ret = 0;\n   while (x) ret += d[x], x -= x & (-x);\n   return ret;\n }\n int main() {\n   int i, j;\n   scanf( %s , a + 1);\n   n = strlen(a + 1);\n   for (i = 0; i <= (int)3; i++)\n     for (j = 1; j <= (int)10; j++)\n       for (k = 0; k <= (int)j - 1; k++) d[i][j][k].resize((n + j - 1) / j + 1);\n   for (i = 1; i <= n; i++) {\n     for (j = 1; j <= 10; j++) {\n       add(d[gao(a[i])][j][(i - 1) % j], (i - 1) / j + 1, 1);\n     }\n   }\n   int q;\n   scanf( %d , &q);\n   while (q--) {\n     int op, x, y;\n     scanf( %d%d , &op, &x);\n     if (op == 1) {\n       scanf( %s , b);\n       for (i = 1; i <= (int)10; i++)\n         add(d[gao(a[x])][i][(x - 1) % i], (x - 1) / i + 1, -1);\n       for (i = 1; i <= (int)10; i++)\n         add(d[gao(b[0])][i][(x - 1) % i], (x - 1) / i + 1, 1);\n       a[x] = b[0];\n     } else {\n       scanf( %d%s , &y, b);\n       int len = strlen(b), ret = 0;\n       for (i = 0; i < len && i < y - x + 1; i++) {\n         int mo = (i + x - 1) % len;\n         ret += get(d[gao(b[i])][len][mo], (y - 1 - mo) / len + 1) -\n                get(d[gao(b[i])][len][mo], (x - 1 + len - 1 - mo) / len);\n       }\n       printf( %d\n , ret);\n     }\n   }\n   return 0;\n }\n "}
{"func_code_string": "#include <bits/stdc++.h>\n using namespace std;\n int main() {\n   long long int i, j, t;\n   cin >> t;\n   for (long long int aa = 0; aa < t; aa++) {\n     long long int n, k, d;\n     cin >> n >> k >> d;\n     long long int mini = k;\n     vector<long long int> v(n);\n     map<long long int, long long int> m;\n     for (i = 0; i < n; i++) {\n       cin >> v[i];\n       if (i < d) {\n         long long int ss = m.size();\n         m[v[i]]++;\n         if (ss < m.size()) m[v[i]] = 1;\n       }\n     }\n     m.size() < mini ? mini = m.size() : mini = mini;\n     for (i = 1; i < n - d + 1; i++) {\n       m[v[i - 1]]--;\n       if (m[v[i - 1]] == 0) m.erase(v[i - 1]);\n       long long int ss = m.size();\n       m[v[i + d - 1]]++;\n       if (ss < m.size()) m[v[i + d - 1]] = 1;\n       m.size() < mini ? mini = m.size() : mini = mini;\n     }\n     m.size() < mini ? mini = m.size() : mini = mini;\n     cout << mini << 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 *p = new int[n + 1], c = 0;\n   int *m = new int[n + 1];\n   for (int i = 0; i <= n; i++) {\n     p[i] = m[i] = 0;\n     c ^= i;\n     m[i] = c;\n   }\n   int f = 0;\n   for (int i = 1; i <= n; i++) {\n     cin >> p[i];\n     f ^= p[i];\n   }\n   int r = 0;\n   for (int i = 2; i <= n; i++) {\n     int grps = (n / i);\n     int rem = n % i;\n     if (grps & 1) r ^= m[i - 1];\n     r ^= m[rem];\n   }\n   cout << (r ^ f);\n   return 0;\n }\n "}
{"func_code_string": "#include <bits/stdc++.h>\n using namespace std;\n const int maxn = 1e5 + 5;\n long long a[maxn], b[maxn], dp[maxn];\n int q[maxn];\n int head = 0, tail = 0;\n double A(int i, int j) { return dp[i] - dp[j]; }\n double B(int i, int j) { return b[i] - b[j]; }\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 = 1; i <= n; i++) cin >> b[i];\n   dp[1] = 0;\n   int head = 1, tail = 1;\n   q[tail] = 1;\n   for (int i = 2; i <= n; i++) {\n     while (head < tail &&\n            A(q[head + 1], q[head]) / B(q[head + 1], q[head]) >= -a[i])\n       head++;\n     dp[i] = dp[q[head]] + b[q[head]] * a[i];\n     while (head < tail && A(i, q[tail]) / B(i, q[tail]) >=\n                               A(q[tail], q[tail - 1]) / B(q[tail], q[tail - 1]))\n       tail--;\n     q[++tail] = i;\n   }\n   cout << dp[n] << '\n';\n   return 0;\n }\n "}
{"func_code_string": "#include <bits/stdc++.h>\n using namespace std;\n const int MAX_INT = numeric_limits<int>::max();\n const int MAX_UINT = numeric_limits<unsigned int>::max();\n void get_acum(const vector<int>& v, vector<int>& acum) {\n   int sum = 0;\n   for (unsigned int i = 0; i < v.size(); ++i) {\n     acum.push_back(sum);\n     sum += v[i];\n   }\n   acum.push_back(sum);\n }\n int solve(vector<int>& A, vector<int>& B, vector<int>& X, unsigned int k) {\n   if (A.size() + X.size() < k || B.size() + X.size() < k) {\n     return -1;\n   } else {\n     sort(A.begin(), A.end());\n     sort(B.begin(), B.end());\n     sort(X.begin(), X.end());\n     vector<int> A_acum, B_acum, X_acum;\n     get_acum(A, A_acum);\n     get_acum(B, B_acum);\n     get_acum(X, X_acum);\n     int res = MAX_INT;\n     unsigned int max_i = min((unsigned int)X.size(), k);\n     for (unsigned int i = 0; i < max_i + 1; ++i) {\n       if (k - i < A_acum.size() && k - i < B_acum.size()) {\n         int total = A_acum[k - i] + B_acum[k - i] + X_acum[i];\n         if (total < res) res = total;\n       }\n     }\n     return res;\n   }\n }\n int main() {\n   ios::sync_with_stdio(false);\n   cin.tie(NULL);\n   unsigned int n, k;\n   cin >> n >> k;\n   vector<int> A;\n   vector<int> B;\n   vector<int> X;\n   for (unsigned int i = 0; i < n; ++i) {\n     unsigned int ti;\n     bool ai, bi;\n     cin >> ti >> ai >> bi;\n     if (ai && bi)\n       X.push_back(ti);\n     else if (ai)\n       A.push_back(ti);\n     else if (bi)\n       B.push_back(ti);\n   }\n   cout << solve(A, B, X, k);\n   return 0;\n }\n "}
{"func_code_string": "#include <bits/stdc++.h>\n using namespace std;\n set<long long int> adj[3005];\n map<long long int, long long int> mq;\n long long int done[3005][3005];\n int main() {\n   ios_base::sync_with_stdio(false);\n   long long int n, m, i, ans = 0;\n   cin >> n >> m;\n   for (i = 0; i < m; i++) {\n     long long int x, y;\n     cin >> x >> y;\n     adj[x].insert(y);\n   }\n   for (i = 1; i <= n; i++) {\n     for (auto it : adj[i]) {\n       for (auto it2 : adj[it]) {\n         if (mq.find(it2) != mq.end() && it2 != i) {\n           ans += mq[it2];\n         }\n         mq[it2]++;\n       }\n     }\n     mq.clear();\n   }\n   cout << 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 b == 0 ? a : gcd(b, a % b); }\n int main() {\n   int a, b, h;\n   cin >> a >> b >> h;\n   int c = 0;\n   while (h != 0) {\n     if (c % 2 == 0) {\n       h = h - gcd(a, h);\n     } else {\n       h = h - gcd(b, h);\n     }\n     c++;\n   }\n   if (c % 2 == 0) {\n     cout << 1 << endl;\n   } else\n     cout << 0 << endl;\n }\n "}
{"func_code_string": "#include <bits/stdc++.h>\n using namespace std;\n const int MAXN = 100000 + 5;\n const double EPS = 1e-3;\n int n;\n int t[MAXN];\n int g(double q) {\n   bool ok = true;\n   for (int i = 1; i < n; i++)\n     if (fabs(double(t[i] - t[i - 1] * q)) > EPS) ok = false;\n   if (ok) return 0;\n   ok = true;\n   for (int i = 2; i < n; i++)\n     if (fabs(double(t[i] - t[i - 1] * q)) > EPS) ok = false;\n   if (ok) return 1;\n   ok = true;\n   int prev = t[0];\n   for (int i = 1; i < n; i++)\n     if (fabs(double(t[i] - prev * q)) > EPS) {\n       if (!ok) return 2;\n       ok = false;\n     } else\n       prev = t[i];\n   return 1;\n }\n int f() {\n   if (n == 1) return 0;\n   double q1 = 0, q2 = 0;\n   if (t[0] != 0) q1 = double(t[1]) / t[0];\n   if (t[n - 2] != 0) q2 = double(t[n - 1]) / t[n - 2];\n   return min(g(q1), g(q2));\n }\n int main() {\n   scanf( %d , &n);\n   for (int i = 0; i < n; i++) scanf( %d , &t[i]);\n   printf( %d\n , f());\n }\n "}
{"func_code_string": "#include <bits/stdc++.h>\n using namespace std;\n const int MAX = 1e6 + 5;\n int a[MAX], run[MAX], ans[MAX];\n char s[MAX];\n int main() {\n   ios_base::sync_with_stdio(0);\n   cin.tie(0);\n   int n;\n   scanf( %d , &n);\n   scanf( %s , s);\n   for (int i = 0; i < n; ++i) {\n     if (s[i] == '0')\n       a[i] = 0;\n     else if (s[i] == '1')\n       a[i] = 1;\n     else\n       a[i] = -1;\n   }\n   vector<pair<int, int>> blocks;\n   int it1 = 0, it2 = 0;\n   while (it1 != n) {\n     while (it2 < n - 1 && a[it1] == a[it2 + 1]) ++it2;\n     blocks.emplace_back(it2 - it1 + 1, a[it1]);\n     ++it2;\n     it1 = it2;\n   }\n   for (int i = 0; i < (int)blocks.size(); ++i) {\n     if (blocks[i].second != -1) continue;\n     if (i == 0)\n       blocks[i].second = blocks[i + 1].second;\n     else if (i == (int)blocks.size() - 1)\n       blocks[i].second = blocks[i - 1].second;\n     else if (blocks[i - 1].second == blocks[i + 1].second)\n       blocks[i].second = blocks[i - 1].second;\n   }\n   vector<pair<int, int>> compress;\n   it1 = 0;\n   it2 = 0;\n   while (it1 != (int)blocks.size()) {\n     int len = blocks[it1].first;\n     while (it2 < (int)blocks.size() - 1 &&\n            blocks[it1].second == blocks[it2 + 1].second)\n       it2++, len += blocks[it2].first;\n     compress.emplace_back(len, blocks[it1].second);\n     ++it2;\n     it1 = it2;\n   }\n   for (auto block : compress) {\n     if (block.second == -1) continue;\n     for (int len = 1; len <= block.first; len++) ans[len] += block.first / len;\n   }\n   int max_size = -1, bef = -2;\n   int size = compress.size();\n   for (int i = 0; i < size; i++) {\n     int len = compress[i].first;\n     int type = compress[i].second;\n     if (bef != -1 && type != -1) {\n       max_size = len;\n       if (i != size - 1) max_size += compress[i + 1].first;\n       for (int l = 1; l <= max_size; l++) run[l] = len % l;\n     } else if (type == -1) {\n       for (int l = 1; l <= max_size; l++) {\n         if (run[l] + len >= l)\n           run[l] += len, ans[l] += run[l] / l, run[l] %= l;\n         else\n           run[l] = len;\n       }\n       int add = 0;\n       if (i != (int)size - 1) add += compress[i + 1].first;\n       if (i != (int)size - 2) add += compress[i + 2].first;\n       for (int l = max_size + 1; l <= len + add; ++l) run[l] = (len % l);\n       max_size = len + add;\n     } else {\n       for (int l = 1; l <= max_size; ++l) {\n         if (run[l] + (len % l) >= l)\n           run[l] += ((len % l) - l), ans[l]++;\n         else\n           run[l] += (len % l);\n       }\n     }\n     bef = type;\n   }\n   for (int i = 1; i <= n; ++i) printf( %d  , ans[i]);\n   printf( \n );\n   return 0;\n }\n "}
{"func_code_string": "#include <bits/stdc++.h>\n using namespace std;\n inline int read() {\n   int f = 1, x = 0;\n   char ch = getchar();\n   while (ch < '0' || ch > '9') {\n     if (ch == '-') {\n       f = -1;\n     }\n     ch = getchar();\n   }\n   while (ch >= '0' && ch <= '9') {\n     x = x * 10 + ch - '0';\n     ch = getchar();\n   }\n   return x * f;\n }\n const int N = 55;\n struct W {\n   int x, y, tx, ty, id;\n } up[N], down[N];\n bool cmp_down(W a, W b) { return a.tx == b.tx ? a.ty < b.ty : a.tx > b.tx; }\n bool cmp_up(W a, W b) { return a.x == b.x ? a.y < b.y : a.x < b.x; }\n vector<pair<int, int> > ans_fr, ans_to;\n bool has[N][N];\n void move_up(int& x, int y) {\n   int dx = x;\n   has[x][y] = 0;\n   has[x - 1][y] = 1;\n   ans_fr.push_back(make_pair(dx, y));\n   ans_to.push_back(make_pair(dx - 1, y));\n   --x;\n }\n void move_down(int& x, int y) {\n   int dx = x;\n   has[x][y] = 0;\n   has[x + 1][y] = 1;\n   ans_fr.push_back(make_pair(dx, y));\n   ans_to.push_back(make_pair(dx + 1, y));\n   ++x;\n }\n void move_left(int x, int& y) {\n   int dy = y;\n   has[x][y] = 0;\n   has[x][y - 1] = 1;\n   ans_fr.push_back(make_pair(x, dy));\n   ans_to.push_back(make_pair(x, dy - 1));\n   --y;\n }\n void move_right(int x, int& y) {\n   int dy = y;\n   has[x][y] = 0;\n   has[x][y + 1] = 1;\n   ans_fr.push_back(make_pair(x, dy));\n   ans_to.push_back(make_pair(x, dy + 1));\n   ++y;\n }\n void move_row(int& x, int& y, int tx, int ty) {\n   while (y < ty && has[x][y + 1] == 0) {\n     move_right(x, y);\n   }\n   while (y > ty && has[x][y - 1] == 0) {\n     move_left(x, y);\n   }\n }\n void move(int& x, int& y, int tx, int ty) {\n   while (x < tx) {\n     move_down(x, y);\n   }\n   while (x > tx) {\n     move_up(x, y);\n   }\n   while (y < ty) {\n     move_right(x, y);\n   }\n   while (y > ty) {\n     move_left(x, y);\n   }\n }\n int check(W a) {\n   if (a.x == a.tx) {\n     return a.y == a.ty ? 0 : 1;\n   } else {\n     return a.y == a.ty ? 2 : 3;\n   }\n }\n int nx[N], ny[N];\n char mp[N][N];\n int vis[N];\n void write(int n) {\n   for (int i = 1; i <= n; i++) {\n     cout << mp[i] + 1 << endl;\n   }\n   puts( ---------------------- );\n }\n void deal(int n, int m) {\n   if (n == 1) {\n     puts( 0 );\n   } else {\n     if (m == 1) {\n       move(up[1].x, up[1].y, up[1].tx, up[1].ty);\n     } else {\n       if (cmp_up(up[1], up[2]) == 0) {\n         swap(up[1], up[2]);\n       }\n       if (up[1].x == 2) {\n         move_up(up[1].x, up[1].y);\n         move_up(up[2].x, up[2].y);\n       } else if (up[2].x == 2) {\n         move_up(up[2].x, up[2].y);\n       }\n       switch (check(up[1])) {\n         case 0:\n           break;\n         case 1:\n           move(up[2].x, up[2].y, 2, 1);\n           move_right(up[1].x, up[1].y);\n           break;\n         case 2:\n           move(up[1].x, up[1].y, up[1].tx, up[1].ty);\n           break;\n         case 3:\n           move(up[1].x, up[1].y, up[1].tx, up[1].ty);\n           move_left(up[2].x, up[2].y);\n           break;\n       }\n       move(up[2].x, up[2].y, up[2].tx, up[2].ty);\n     }\n     cout << ans_fr.size() << endl;\n     for (int i = 0; i < ans_fr.size(); i++) {\n       int xx1 = ans_fr[i].first, xx2 = ans_to[i].first;\n       int yy1 = ans_fr[i].second, yy2 = ans_to[i].second;\n       printf( %d %d %d %d\n , xx1, yy1, xx2, yy2);\n     }\n   }\n }\n int main() {\n   int n = read(), m = read();\n   for (int i = 1; i <= n; i++) {\n     for (int j = 1; j <= n; j++) {\n       mp[i][j] = '.';\n     }\n   }\n   for (int i = 1; i <= m; i++) {\n     up[i].id = i;\n     nx[i] = up[i].x = read();\n     ny[i] = up[i].y = read();\n     has[nx[i]][ny[i]] = 1;\n     mp[nx[i]][ny[i]] = i + '0';\n   }\n   for (int i = 1; i <= m; i++) {\n     up[i].tx = read();\n     up[i].ty = read();\n   }\n   if (n <= 2) {\n     deal(n, m);\n     return 0;\n   }\n   copy(up + 1, up + 1 + m, down + 1);\n   sort(up + 1, up + 1 + m, cmp_up);\n   int cnt = m;\n   while (cnt) {\n     for (int i = 1; i <= m; i++) {\n       if (vis[i] == 0) {\n         int id = up[i].id;\n         move_row(nx[id], ny[id], 1, i);\n         if (ny[id] == i) {\n           vis[i] = 1;\n           cnt--;\n         }\n       }\n     }\n   }\n   for (int i = 1; i <= m; i++) {\n     int id = up[i].id;\n     while (nx[id] > 1) {\n       move_up(nx[id], ny[id]);\n     }\n   }\n   for (int i = 1; i <= m; i++) {\n     move_down(nx[i], ny[i]);\n     move_down(nx[i], ny[i]);\n   }\n   sort(down + 1, down + 1 + m, cmp_down);\n   for (int i = 1; i <= m; i++) {\n     int id = down[i].id;\n     move_up(nx[id], ny[id]);\n     move_row(nx[id], ny[id], 1, i);\n     move_up(nx[id], ny[id]);\n   }\n   for (int i = 1; i <= m; i++) {\n     int id = down[i].id;\n     while (nx[id] < down[i].tx) {\n       move_down(nx[id], ny[id]);\n     }\n   }\n   cnt = m;\n   while (cnt) {\n     for (int i = 1; i <= m; i++) {\n       if (vis[i] == 1) {\n         int id = down[i].id;\n         move_row(nx[id], ny[id], nx[id], down[i].ty);\n         if (ny[id] == down[i].ty) {\n           vis[i] = 2;\n           cnt--;\n         }\n       }\n     }\n   }\n   assert(ans_fr.size() == ans_to.size());\n   assert(ans_fr.size() <= 10800);\n   cout << ans_fr.size() << endl;\n   for (int i = 0; i < ans_fr.size(); i++) {\n     int xx1 = ans_fr[i].first, xx2 = ans_to[i].first;\n     int yy1 = ans_fr[i].second, yy2 = ans_to[i].second;\n     printf( %d %d %d %d\n , xx1, yy1, xx2, yy2);\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   int a[m], b[m];\n   int ndup = n;\n   for (int i = 0; i < m; i++) {\n     cin >> a[i];\n     b[i] = a[i];\n   }\n   sort(a, a + m);\n   sort(b, b + m, greater<int>());\n   int mn = 0, mx = 0;\n   for (int i = 0; i < m; i++) {\n     while (a[i] > 0 && n > 0) {\n       mn += a[i];\n       a[i]--;\n       n--;\n     }\n   }\n   while (ndup > 0) {\n     mx += b[0];\n     b[0]--;\n     ndup--;\n     sort(b, b + m, greater<int>());\n   }\n   cout << mx <<     << mn;\n }\n "}
{"func_code_string": "#include <bits/stdc++.h>\n using namespace std;\n int main() {\n   long long a, b, c, d, e, f, g, h, i, j, k, l, m, n, t;\n   cin >> t;\n   while (t--) {\n     cin >> n;\n     cout << (n + 1) / 2 << endl;\n   }\n }\n "}
{"func_code_string": "//...START BY DOING WHAT IS NECESSARY, THEN WHAT IS POSSIBLE AND SUDDENLY YOU ARE DOING THE IMPOSSIBLE... \n #include <bits/stdc++.h>\n using namespace std;\n #define FAST_FURIER ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0);\n #define pb push_back\n #define mk make_pair\n #define rep(i,a,N) for(ll i=a;i<N;i++)\n #define rrep(i,a,N) for(ll i=a;i>N;i--)\n typedef long long ll;\n #define M 1000000007\n bool comp(int x,int y)\n {\n     return x > y;\n }\n  \n  \n /*..............................code starts here........................*/\n // C is first won in M\n  \n  \n int main() {\n     FAST_FURIER;\n     int tt=1;\n     cin >> tt;\n     ll m,d,k;\n    //ll a,b,c;\n     while(tt--)\n     {\n         cin >> d >> k;\n         ll x = 0,y = 0;\n         int f = 0;\n         while(true){\n             ll d1 = pow(x+k,2)+pow(y,2), d2 = pow(x,2)+pow(y+k,2);\n             f = abs(f-1);\n             if(d1 < d2 and d1 <= d*d){\n                 x += k;\n             }\n             else if(d2 <= d1 and d2 <= d*d) y += k;\n             else break;\n         }\n         if(f) cout <<  Utkarsh ;\n         else cout <<  Ashish ;\n         cout << endl;\n \n     }\n }\n  \n  \n  \n // Author : shivam_123\n  \n // g++ -std=c++17"}
{"func_code_string": "#include <bits/stdc++.h>\n using namespace std;\n long long a, b, c, e[200000], mix, l, r, o, d[200000];\n vector<long long> v[100000], v1;\n set<long long> st;\n map<long long, long long> mp, mp1;\n string s;\n pair<int, int> p[100000], p1[100000];\n char ch[10];\n deque<char> dq;\n int main() {\n   cin >> a;\n   for (int i = 0; i < a / 4; i++)\n     if ((a - 2 * (i + 1)) % 2 == 0) c++;\n   if (a % 4 == 0) {\n     cout << c - 1;\n   } else\n     cout << c;\n }\n "}
{"func_code_string": "#include <bits/stdc++.h>\n using namespace std;\n char s[5000005];\n int len[1000005];\n int idx[1000005];\n int sum[1000005];\n int sz = 0;\n int dp[1000005][20];\n int p[1000005];\n int main() {\n   int n, r, c;\n   scanf( %d%d%d , &n, &r, &c);\n   gets(s);\n   gets(s);\n   int cnt = 0, slen = 0;\n   for (int i = 0; s[i]; i++, slen++) {\n     if (s[i] == ' ' && cnt != 0) {\n       len[sz] = cnt;\n       idx[sz++] = i - cnt;\n       cnt = 0;\n     } else\n       cnt++;\n   }\n   if (cnt > 0) {\n     len[sz] = cnt;\n     idx[sz++] = slen - cnt;\n     cnt = 0;\n   }\n   sum[0] = len[0];\n   for (int i = 1; i < n; i++) sum[i] = sum[i - 1] + 1 + len[i];\n   for (int i = n - 1; i >= 0; i--) {\n     int id = upper_bound(sum, sum + n, (i > 0 ? sum[i - 1] + 1 : 0) + c) - sum;\n     if (id > n) id = n;\n     dp[i][0] = id - i;\n   }\n   for (int j = 2, t = 1; j <= r; j *= 2, t++) {\n     for (int i = n - 1; i >= 0; i--)\n       dp[i][t] = dp[i][t - 1] + dp[i + dp[i][t - 1]][t - 1];\n   }\n   int maid = -1, ma = 0;\n   for (int i = 0; i < n; i++) {\n     int idx = i, rr = r, cur = 0;\n     for (int j = 20; j >= 0; j--) {\n       if (rr >= (1 << j)) {\n         rr -= (1 << j);\n         cur += dp[idx][j];\n         idx += dp[idx][j];\n       }\n     }\n     if (cur > ma) maid = i, ma = cur;\n   }\n   int cn = 1, cs = dp[maid][0];\n   for (int i = maid; i < maid + ma; i++) {\n     s[idx[i] + len[i]] = 0;\n     if (cn < cs) {\n       printf( %s  , s + idx[i]);\n       cn++;\n     } else {\n       printf( %s\n , s + idx[i]);\n       cs = dp[i + 1][0];\n       cn = 1;\n     }\n   }\n   return 0;\n }\n "}
{"func_code_string": "#include <bits/stdc++.h>\n using namespace std;\n char change(char curranswer) {\n   if (curranswer == 'z')\n     curranswer = 'A';\n   else if (curranswer == 'Z')\n     curranswer = '0';\n   else if (curranswer == '9')\n     ;\n   else\n     curranswer++;\n   return curranswer;\n }\n int main() {\n   long long i, j, t;\n   cin >> t;\n   while (t--) {\n     long long r, c, k;\n     long long rice = 0;\n     char a[100][100];\n     cin >> r >> c >> k;\n     for (i = 0; i < r; i++) {\n       for (j = 0; j < c; j++) {\n         cin >> a[i][j];\n         if (a[i][j] == 'R') rice++;\n       }\n     }\n     long long ans = rice / k;\n     long long maxx = rice - k * ans;\n     long long minn = k - maxx;\n     char curranswer = 'a';\n     long long currcount = 0;\n     bool flag = true;\n     for (i = 0; i < r; i++) {\n       for (flag ? (j = 0) : (j = c - 1); flag ? (j < c) : j >= 0;\n            flag ? j++ : j--) {\n         bool local = false;\n         if (a[i][j] == 'R') local = true;\n         a[i][j] = curranswer;\n         if (local) {\n           currcount++;\n           if (maxx > 0) {\n             if (currcount == ans + 1) {\n               maxx--;\n               currcount = 0;\n               curranswer = change(curranswer);\n             }\n           } else if (minn > 0) {\n             if (currcount == ans) {\n               minn--;\n               currcount = 0;\n               if (minn) curranswer = change(curranswer);\n             }\n           }\n         }\n       }\n       flag = !flag;\n     }\n     for (i = 0; i < r; i++) {\n       for (j = 0; j < c; j++) cout << a[i][j];\n       cout << endl;\n     }\n   }\n }\n "}
{"func_code_string": "#include <bits/stdc++.h>\n using namespace std;\n long long gcd(long long x, long long y) {\n   if (y == 0)\n     return x;\n   else\n     return gcd(y, x % y);\n }\n long long expo(long long n, long long m) {\n   long long r = 1;\n   while (m > 0) {\n     if (m % 2) r = (r * n) % 1000000009;\n     n = (n * n) % 1000000009;\n     m = m / 2;\n   }\n   return r % 1000000009;\n }\n long long lx = 0, ly = 0;\n bool check(long long x, long long y) {}\n int main() {\n   ios::sync_with_stdio(0);\n   cin.tie(0);\n   cout.tie(0);\n   ;\n   long long a, b;\n   cin >> a >> b;\n   string s;\n   cin >> s;\n   long long p = 0, q = 0;\n   if (a == 0 && b == 0) {\n     cout <<  Yes ;\n     return 0;\n   }\n   for (long long i = 0; i < s.size(); i++) {\n     if (s[i] == 'U') {\n       ly++;\n     } else if (s[i] == 'D')\n       ly--;\n     else if (s[i] == 'L')\n       lx--;\n     else\n       lx++;\n     if (lx == a && ly == b) {\n       cout <<  Yes ;\n       return 0;\n     }\n   }\n   if (lx == 0 && ly == 0) {\n     cout <<  No ;\n     return 0;\n   }\n   for (long long i = 0; i < s.size(); i++) {\n     if (s[i] == 'U') {\n       q++;\n     } else if (s[i] == 'D')\n       q--;\n     else if (s[i] == 'L')\n       p--;\n     else\n       p++;\n     long long x = a - p, y = b - q, X = lx, Y = ly;\n     if (lx == 0) {\n       if (ly > 0 && y > 0 && x == 0 && y % ly == 0) {\n         cout <<  Yes ;\n         return 0;\n       } else if (ly < 0 && y < 0 && x == 0) {\n         ly = -1 * ly, y = -1 * y;\n         if (y % ly == 0) {\n           cout <<  Yes ;\n           return 0;\n         }\n       }\n     } else if (ly == 0) {\n       if (lx > 0 && x > 0 && y == 0 && x % lx == 0) {\n         cout <<  Yes ;\n         return 0;\n       } else if (lx < 0 && x < 0 && y == 0) {\n         lx = -1 * lx, x = -1 * x;\n         if (x % lx == 0) {\n           cout <<  Yes ;\n           return 0;\n         }\n       }\n     } else {\n       if (lx > 0 && x > 0) {\n         if (ly > 0 && y > 0) {\n           if (x / lx == y / ly && x % lx == 0 && y % ly == 0) {\n             cout <<  Yes ;\n             return 0;\n           }\n         } else if (ly < 0 && y < 0) {\n           ly = -1 * ly, y = -1 * y;\n           if (x / lx == y / ly && x % lx == 0 && y % ly == 0) {\n             cout <<  Yes ;\n             return 0;\n           }\n         }\n       } else if (lx < 0 && x < 0) {\n         lx = -1 * lx, x = -1 * x;\n         if (ly > 0 && y > 0) {\n           if (x / lx == y / ly && x % lx == 0 && y % ly == 0) {\n             cout <<  Yes ;\n             return 0;\n           }\n         } else if (ly < 0 && y < 0) {\n           ly = -1 * ly, y = -1 * y;\n           if (x / lx == y / ly && x % lx == 0 && y % ly == 0) {\n             cout <<  Yes ;\n             return 0;\n           }\n         }\n       }\n     }\n     lx = X, ly = Y;\n   }\n   cout <<  No ;\n   return 0;\n }\n "}
{"func_code_string": "#include <bits/stdc++.h>\n using namespace std;\n const int N = int(3e5), mod = int(1e9) + 7;\n int n;\n int a[N], c[N];\n long long t[N];\n long long x[N], pref[N];\n long double p[N];\n long long suf[N];\n void upd(int v, int val) {\n   v += n - 1;\n   t[v] += val;\n   c[v]++;\n   while (v > 1) {\n     v >>= 1;\n     t[v] = t[v + v] + t[v + v + 1];\n     c[v] = c[v + v] + c[v + v + 1];\n   }\n }\n long long get(int l, int r) {\n   l += n - 1;\n   r += n - 1;\n   long long res = 0;\n   while (l <= r) {\n     if (l & 1) res += t[l];\n     if (!(r & 1)) res += t[r];\n     l = (l + 1) >> 1;\n     r = (r - 1) >> 1;\n   }\n   return res;\n }\n int cnt(int l, int r) {\n   l += n - 1;\n   r += n - 1;\n   int res = 0;\n   while (l <= r) {\n     if (l & 1) res += c[l];\n     if (!(r & 1)) res += c[r];\n     l = (l + 1) >> 1;\n     r = (r - 1) >> 1;\n   }\n   return res;\n }\n int main() {\n   scanf( %d , &n);\n   for (int i = 1; i <= n; i++) {\n     scanf( %d , &a[i]);\n   }\n   long long all = 1ll * n * (n + 1) / 2;\n   long double res = 0;\n   for (int i = 1; i <= n; i++) {\n     long long cur = get(1, a[i] - 1);\n     long double p = (cur + 0.0) * (n - i + 1) / all;\n     res += p * 0.5;\n     cur = get(a[i] + 1, n);\n     p = (cur + 0.0) * (n - i + 1) / all;\n     res += cnt(a[i] + 1, n);\n     res -= p * 0.5;\n     upd(a[i], i);\n   }\n   printf( %.12lf , double(res));\n   return 0;\n }\n "}
{"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 "}