#include <bits/stdc++.h>
 using namespace std;
 const double PI = acos(-1.0);
 const double EPS = 1e-7;
 const long long BIG_PRIME7 = 1000000007;
 const long long BIG_PRIME9 = 1000000009;
 int gcd(int x, int y) { return y ? gcd(y, x % y) : x; }
 char ch = 'a';
 int j, n, m, L, i;
 int N, C;
 int x, y, z, k;
 string f, s;
 int a[101], b[101];
 int main() {
   cin >> x;
   for (i = 0; i < x; i++) {
     cin >> k;
     if (k & 1) z++;
   }
   if (!(z & 1))
     cout << (x - z);
   else
     cout << z;
   return 0;
 }


#include <bits/stdc++.h>
 using namespace std;
 const int N = 111111;
 int last[3 * N], pre[3 * N], v[3 * N], cnt[3 * N], cur = 0;
 inline void add(int a, int b) {
   pre[cur] = last[a];
   v[cur] = b;
   last[a] = cur;
   cur++;
 }
 set<int>* who[N];
 inline set<int>* merge(set<int>*& a, set<int>*& b) {
   if (a->size() < b->size()) {
     return merge(b, a);
   } else {
     for (set<int>::iterator it = b->begin(); it != b->end(); it++) {
       if (a->find(-*it) != a->end()) {
         a->erase(-*it);
       } else {
         a->insert(*it);
       }
     }
     b->clear();
     return a;
   }
 }
 int used[N];
 void dfs(int u) {
   used[u] = true;
   for (int i = last[u]; i >= 0; i = pre[i])
     if (!used[v[i]]) {
       dfs(v[i]);
       cnt[i ^ 1] = cnt[i] = who[v[i]]->size();
       who[u] = merge(who[u], who[v[i]]);
     }
 }
 set<int>* mem[N];
 int main() {
   memset(last, -1, sizeof(last));
   int n;
   scanf( %d , &n);
   for (int i = (0); i <= ((n - 1) - 1); i++) {
     int u, v;
     scanf( %d%d , &u, &v);
     u--;
     v--;
     add(u, v);
     add(v, u);
   }
   for (int i = (0); i <= ((n)-1); i++) mem[i] = who[i] = new set<int>();
   int k;
   scanf( %d , &k);
   for (int i = (1); i <= ((k)); i++) {
     int u, v;
     scanf( %d%d , &u, &v);
     u--;
     v--;
     if (u != v) {
       who[u]->insert(i);
       who[v]->insert(-i);
     }
   }
   dfs(0);
   for (int i = 0; i < cur; i += 2) {
     if (i) printf(   );
     printf( %d , cnt[i]);
   }
   puts(  );
   for (int i = (0); i <= ((n)-1); i++) delete (mem[i]);
   return 0;
 }


#include <bits/stdc++.h>
 using namespace std;
 const int MOD = 1e9 + 7;
 const int INF = 1e9 + 7;
 const int base = 1e9;
 const int MAX = 1e5;
 const double EPS = 1e-9;
 const double PI = acos(-1.);
 int main() {
   ios_base::sync_with_stdio(0);
   cin.tie(0);
   cout.tie(0);
   int n, *a, *res, j = 0;
   cin >> n;
   a = new int[n];
   res = new int[n];
   set<int> cnt;
   for (int i = 0; i < n; i++) {
     cin >> a[i];
   }
   for (int i = n - 1; i >= 0; i--) {
     if (!cnt.count(a[i])) {
       cnt.insert(a[i]);
       res[j] = a[i];
       j++;
     }
   }
   cout << j << endl;
   for (int i = j - 1; i >= 0; i--) {
     cout << res[i] << ' ';
   }
   return 0;
 }


#include <bits/stdc++.h>
 using namespace std;
 struct cell {
   bool up, down, right, left;
   int degree;
   cell() { up = down = left = right = degree = 0; }
   void reset() { up = down = left = right = degree = 0; }
 };
 struct qcell {
   int x, y, degree;
   qcell() {
     x = y = -1;
     degree = 0;
   }
   qcell(int xx, int yy, int deg) {
     x = xx;
     y = yy;
     degree = deg;
   }
 };
 char pitch[2001][2001];
 cell info[2001][2001];
 int n, m;
 int empty_cells = 0;
 bool update(int x, int y) {
   int degree = 0;
   if (x >= 0 && x < n && y >= 0 && y < m) {
     degree = info[x][y].degree;
     if (pitch[x][y] != '.')
       info[x][y].reset();
     else {
       info[x][y].up = (x - 1 >= 0 && pitch[x - 1][y] == '.');
       info[x][y].down = (x + 1 < n && pitch[x + 1][y] == '.');
       info[x][y].left = (y - 1 >= 0 && pitch[x][y - 1] == '.');
       info[x][y].right = (y + 1 < m && pitch[x][y + 1] == '.');
       info[x][y].degree = (info[x][y].up + info[x][y].down + info[x][y].left +
                            info[x][y].right);
     }
   }
   return degree != info[x][y].degree;
 }
 void do_push(int x, int y, queue<qcell> &q) {
   if (x >= 0 && x < n && y >= 0 && y < m)
     if (pitch[x][y] == '.')
       if (info[x][y].degree == 1) q.push(qcell(x, y, 1));
 }
 void occupy(int x, int y, queue<qcell> &q) {
   int xx = x, yy = y;
   char dir = 'U';
   if (info[x][y].down) dir = 'D';
   if (info[x][y].left) dir = 'L';
   if (info[x][y].right) dir = 'R';
   if (dir == 'U') {
     pitch[x][y] = 'v';
     pitch[x - 1][y] = '^';
     xx = x - 1;
   } else if (dir == 'D') {
     pitch[x][y] = '^';
     pitch[x + 1][y] = 'v';
     xx = x + 1;
   } else if (dir == 'L') {
     pitch[x][y] = '>';
     pitch[x][y - 1] = '<';
     yy = y - 1;
   } else {
     pitch[x][y] = '<';
     pitch[x][y + 1] = '>';
     yy = y + 1;
   }
   update(x, y);
   update(xx, yy);
   if (do_push) {
     if (update(x - 1, y)) do_push(x - 1, y, q);
     if (update(x + 1, y)) do_push(x + 1, y, q);
     if (update(x, y - 1)) do_push(x, y - 1, q);
     if (update(x, y + 1)) do_push(x, y + 1, q);
     if (update(xx - 1, yy)) do_push(xx - 1, yy, q);
     if (update(xx + 1, yy)) do_push(xx + 1, yy, q);
     if (update(xx, yy - 1)) do_push(xx, yy - 1, q);
     if (update(xx, yy + 1)) do_push(xx, yy + 1, q);
   }
   empty_cells -= 2;
 }
 int main() {
   cin >> n >> m;
   for (int i = 0; i < n; i++)
     for (int j = 0; j < m; j++) {
       cin >> pitch[i][j];
       if (pitch[i][j] == '.') empty_cells++;
     }
   queue<qcell> q;
   for (int i = 0; i < n; i++)
     for (int j = 0; j < m; j++) {
       update(i, j);
       if (info[i][j].degree == 1) q.push(qcell(i, j, info[i][j].degree));
     }
   bool unique_sol = 1;
   while (1) {
     if (q.empty()) break;
     qcell f = q.front();
     q.pop();
     if (info[f.x][f.y].degree == 0) {
       if (pitch[f.x][f.y] == '.') {
         unique_sol = false;
         break;
       }
     } else
       occupy(f.x, f.y, q);
   }
   if (unique_sol)
     if (empty_cells != 0) unique_sol = 0;
   if (!unique_sol)
     cout <<  Not unique  << endl;
   else
     for (int i = 0; i < n; i++) {
       for (int j = 0; j < m; j++) cout << pitch[i][j];
       cout << endl;
     }
   return 0;
 }


#include <bits/stdc++.h>
 using namespace std;
 const int INF = 0x3f3f3f3f;
 int main() {
   ios::sync_with_stdio(false);
   int t;
   cin >> t;
   while (t--) {
     string s, t;
     cin >> s >> t;
     vector<int> each[26];
     int n, m;
     n = s.length();
     m = t.length();
     for (int i = 0; i < n; ++i) {
       each[s[i] - 'a'].push_back(i);
     }
     int las = INF, res = 0;
     for (int i = 0; i < m; ++i) {
       if (upper_bound(each[t[i] - 'a'].begin(), each[t[i] - 'a'].end(), las) !=
           each[t[i] - 'a'].end()) {
         las =
             *upper_bound(each[t[i] - 'a'].begin(), each[t[i] - 'a'].end(), las);
       } else {
         if (each[t[i] - 'a'].empty()) {
           res = -1;
           break;
         } else {
           res++;
           las = each[t[i] - 'a'][0];
         }
       }
     }
     cout << res << endl;
   }
   return 0;
 }


#include <bits/stdc++.h>
 using namespace std;
 int main() {
   int n, h, a, road_width = 0;
   cin >> n >> h;
   for (int i = 0; i < n; i++) {
     cin >> a;
     if (a > h)
       road_width += 2;
     else
       road_width++;
   }
   cout << road_width <<
 ;
   return 0;
 }


#include <bits/stdc++.h>
 using namespace std;
 int abs(int a, int b) {
   if (a > b)
     return a - b;
   else
     return b - a;
 }
 int main() {
   int n, c, i, b, count = 0, index1 = 1, index2 = 1, flag = 0;
   cin >> n >> c;
   char *s;
   s = new char[n + 2];
   for (i = 1; i <= n; i++) {
     cin >> s[i];
   }
   int *d = new int[n + 1];
   for (i = 1; i <= n / 2; i++) {
     b = abs((int)s[i], (int)s[n - i + 1]);
     if (b < 13)
       d[i] = d[n - i + 1] = b;
     else
       d[i] = d[n - i + 1] = 26 - b;
   }
   if (c > n / 2) c = 1 + n - c;
   for (i = 1; i <= n / 2; i++) {
     if (d[i] > 0) {
       index1 = i;
       break;
     }
   }
   for (i = n / 2; i >= 1; i--) {
     if (d[i] > 0) {
       index2 = i;
       flag = 1;
       break;
     }
   }
   if (c <= index1) {
     count = index2 - c;
   } else if (c <= index2) {
     if (c - index1 > index2 - c)
       count = 2 * (index2 - c) + c - index1;
     else
       count = 2 * (c - index1) + index2 - c;
   } else
     count = c - index1;
   for (i = index1; i <= index2; i++) {
     count += d[i];
   }
   if (flag == 1)
     cout << count;
   else
     cout << 0;
   return 0;
 }


#include <bits/stdc++.h>
 int any_table[11][11];
 struct DammedPascalNUmber {
   int tb[13][13];
   DammedPascalNUmber() {
     int i, j;
     for (i = 0; i <= 12; i++)
       for (j = 0; j <= i; j++) {
         int &r = tb[i][j];
         if (j == 0 || i == 0)
           r = 1;
         else
           r = tb[i - 1][j - 1] + tb[i - 1][j];
       }
   }
   int count(int n, int m) { return tb[n][m]; }
 } pas;
 int any(int dig, int amo) {
   if (dig < amo) return 0;
   if (amo < 0) return 0;
   if (dig == 0) return 1;
   int &r = any_table[dig][amo];
   int i;
   if (r >= 0) return r;
   r = 1;
   for (i = 0; i < amo; i++) r *= 2;
   for (; i < dig; i++) r *= 8;
   r *= pas.count(dig, amo);
   return r;
 }
 int check(int m, int n) {
   int i, j, t, r = 0;
   for (i = 1; i <= m; i++) {
     char str[15];
     t = 0;
     sprintf(str,  %d , i);
     for (j = 0; str[j]; j++)
       if (str[j] == '4' || str[j] == '7') t++;
     if (t == n) r++;
   }
   return r;
 }
 int a[13];
 int dfs(int party, int quta) {
   int r = 0, i;
   if (party == 6) {
     return 1;
   }
   for (i = quta; i >= 0; i--)
     if (a[i] > 0) {
       int t = a[i];
       a[i]--;
       r = (1LL * r + 1LL * t * 1LL * dfs(party + 1, quta - i) +
            1LL * 1000000007) %
           1000000007;
       a[i]++;
     }
   return r;
 }
 void test(int n, int m) { printf( any(%d,%d)=%d
 , n, m, any(n, m)); }
 void test2(int m, int n) {
   printf( (%d,%d)=%d a[%d]=%d
 , m, n, check(m, n), n, a[n]);
 }
 int main() {
   memset(any_table, -1, sizeof(any_table));
   int m, s, i, j, k, sn, lucked;
   while (~scanf( %d , &m)) {
     memset(a, 0, sizeof(a));
     char str[15];
     sprintf(str,  %d , m);
     for (sn = 0; str[sn]; sn++)
       ;
     for (j = sn; j > 0; j--) {
       a[j] = 0;
       lucked = 0;
       for (i = 0; i < sn; i++) {
         int p = 0, q = 0;
         k = str[i] - '0' - 1;
         for (; k >= 0; k--)
           if (k == 4 || k == 7)
             q++;
           else
             p++;
         if (p) a[j] += p * any(sn - i - 1, j - lucked);
         if (q) a[j] += q * any(sn - i - 1, j - lucked - 1);
         if (str[i] == '4' || str[i] == '7') {
           lucked++;
         }
         if (i == sn - 1 && lucked == j) a[j]++;
       }
     }
     a[0] = m;
     for (i = 1; i <= sn; i++) a[0] -= a[i];
     int ans = 0;
     for (i = 1; i <= sn; i++)
       if (a[i]) {
         ans = (1LL * ans + 1LL * a[i] * dfs(0, i - 1) + 1LL * 1000000007) %
               1000000007;
       }
     printf( %d
 , ans);
   }
 }


#include <bits/stdc++.h>
 using namespace std;
 const int maxn = 1e5 + 10;
 const double pi = acos(-1);
 const int inf = 1 << 30;
 const int mod = 1e9 + 9;
 struct point {
   int x, flag;
   bool operator<(const point &a) const { return flag > a.flag; }
 } s, q;
 bool check(long long a[], int n, long long h, int x) {
   priority_queue<int, vector<int>, less<int> > qwe;
   for (int i = 1; i <= min(n, x); i++) qwe.push(a[i]);
   int f = 1, pos;
   while (!qwe.empty()) {
     pos = qwe.top();
     qwe.pop();
     if (f) h -= pos;
     f ^= 1;
   }
   if (h >= 0ll)
     return true;
   else
     return false;
 }
 int main() {
   int n;
   long long h, a[maxn];
   scanf( %d %lld , &n, &h);
   for (int i = 1; i <= n; i++) scanf( %lld , &a[i]);
   int l = 0, r = n, ans = 0;
   while (l <= r) {
     int mid = (l + r) >> 1;
     if (check(a, n, h, mid))
       l = mid + 1, ans = mid;
     else
       r = mid - 1;
   }
   printf( %d
 , ans);
   return 0;
 }


#include <bits/stdc++.h>
 const int64_t mod = 998244353;
 int gcd(int64_t a, int64_t b) {
   while (a != 0 && b != 0) {
     if (a >= b)
       a = a % b;
     else
       b = b % a;
   }
   return a + b;
 }
 struct Fraction {
   int64_t numerator;
   int64_t devider;
   Fraction(int64_t n = 0, int64_t d = 1) : numerator(n), devider(d){};
   const Fraction& operator+(const Fraction& rv) {
     if (rv.devider == devider) {
       numerator += rv.numerator;
       numerator %= mod;
       return *this;
     } else {
       numerator *= rv.devider;
       numerator %= mod;
       numerator += rv.numerator * devider;
       numerator %= mod;
       devider *= rv.devider;
       devider %= mod;
       return *this;
     }
   }
   const Fraction& operator*(const Fraction& rv) {
     numerator *= rv.numerator;
     devider *= rv.devider;
     numerator %= mod;
     devider %= mod;
     return *this;
   }
 };
 struct Item {
   Item(Fraction f, int64_t s, int64_t v) : possibility(f), sum(s), val(v){};
   Fraction possibility;
   int64_t sum;
   int64_t val;
 };
 void extended_euclid(int64_t a, int64_t b, int64_t& x, int64_t& y, int64_t& d) {
   int64_t q, r, x1, x2, y1, y2;
   if (b == 0) {
     d = a, x = 1, y = 0;
     return;
   }
   x2 = 1, x1 = 0, y2 = 0, y1 = 1;
   while (b > 0) {
     q = a / b, r = a - q * b;
     x = x2 - q * x1, y = y2 - q * y1;
     a = b, b = r;
     x2 = x1, x1 = x, y2 = y1, y1 = y;
   }
   d = a, x = x2, y = y2;
 }
 int main() {
   int64_t n, m;
   std::cin >> n >> m;
   std::vector<std::pair<int64_t, bool>> data;
   int64_t posWeight = 0, negWeight = 0;
   for (int64_t i = 0; i < n; ++i) {
     int64_t a;
     std::cin >> a;
     if (a == 0)
       data.push_back(std::make_pair(-1, false));
     else
       data.push_back(std::make_pair(-1, true));
   }
   for (auto& i : data) {
     int64_t w;
     std::cin >> w;
     i.first = w;
     if (i.second)
       posWeight += w;
     else
       negWeight += w;
   }
   std::vector<Item> posVec{
       Item(Fraction(1, 1), posWeight + negWeight, posWeight)},
       negVec{Item(Fraction(1, 1), posWeight + negWeight, negWeight)};
   for (int64_t i = 0; i < m; ++i) {
     std::vector<Item> newPos, newNeg;
     for (auto j : posVec) {
       if (!newPos.size()) {
         Fraction f(j.val, j.sum);
         f = f * j.possibility;
         newPos.push_back(Item(f, j.sum + 1, j.val + 1));
       } else {
         Fraction f(j.val, j.sum);
         f = f * j.possibility;
         newPos.rbegin()->possibility = newPos.rbegin()->possibility + f;
       }
       if (j.sum > j.val) {
         Fraction f(j.sum - j.val, j.sum);
         f = f * j.possibility;
         newPos.push_back(Item(f, j.sum - 1, j.val));
       }
     }
     for (auto j : negVec) {
       if (!newNeg.size() && j.val > 1) {
         Fraction f(j.val, j.sum);
         f = f * j.possibility;
         newNeg.push_back(Item(f, j.sum - 1, j.val - 1));
       } else if (j.val > 1) {
         Fraction f(j.val, j.sum);
         f = f * j.possibility;
         newNeg.rbegin()->possibility = newNeg.rbegin()->possibility + f;
       }
       Fraction f(j.sum - j.val, j.sum);
       f = f * j.possibility;
       newNeg.push_back(Item(f, j.sum + 1, j.val));
     }
     posVec = newPos;
     negVec = newNeg;
   }
   Fraction pos, neg;
   for (auto i : posVec) pos = pos + Fraction(i.val, 1) * i.possibility;
   for (auto i : negVec) neg = neg + Fraction(i.val, 1) * i.possibility;
   for (auto i : data) {
     Fraction res;
     if (i.second)
       res = Fraction(i.first, posWeight) * pos;
     else
       res = Fraction(i.first, negWeight) * neg;
     int64_t g = gcd(res.numerator, res.devider);
     res.numerator /= g;
     res.devider /= g;
     int64_t d, x, y;
     extended_euclid(res.devider, mod, x, y, d);
     std::cout << (((x % mod + mod) % mod) * res.numerator) % mod << std::endl;
   }
   return 0;
 }


#include <bits/stdc++.h>
 using namespace std;
 const int N = 100005;
 int n, m, x, y, f[N], fa[N], ch[N][2];
 char op[5];
 long long a[N], siz[N], ssiz[N], ans[N], sans[N], sqsiz[N], all[N];
 bool isroot(int u) { return ch[fa[u]][0] != u && ch[fa[u]][1] != u; }
 int which(int u) { return u == ch[fa[u]][1]; }
 void pushup(int o) {
   int lc = ch[o][0], rc = ch[o][1];
   siz[o] = siz[lc] + siz[rc] + ssiz[o];
   all[o] = all[lc] + all[rc] + a[o] * ssiz[o];
   ans[o] = ans[lc] + ans[rc] + sans[o];
   ans[o] += (ssiz[o] * ssiz[o] - sqsiz[o]) * a[o];
   ans[o] += 2 * siz[rc] * ssiz[o] * a[o];
   ans[o] += 2 * all[lc] * (siz[o] - siz[lc]);
 }
 void rotate(int x) {
   int y = fa[x], z = fa[y], md = which(x);
   if (!isroot(y)) {
     ch[z][which(y)] = x;
   }
   fa[x] = z;
   ch[y][md] = ch[x][!md];
   fa[ch[y][md]] = y;
   ch[x][!md] = y;
   fa[y] = x;
   pushup(y);
   pushup(x);
 }
 void splay(int u) {
   while (!isroot(u)) {
     if (!isroot(fa[u])) {
       rotate(which(u) == which(fa[u]) ? fa[u] : u);
     }
     rotate(u);
   }
 }
 void access(int u) {
   for (int v = 0; u; v = u, u = fa[u]) {
     splay(u);
     int rc = ch[u][1];
     ssiz[u] += siz[rc];
     sans[u] += ans[rc];
     sqsiz[u] += siz[rc] * siz[rc];
     ch[u][1] = v;
     ssiz[u] -= siz[v];
     sans[u] -= ans[v];
     sqsiz[u] -= siz[v] * siz[v];
     pushup(u);
   }
 }
 void link(int u, int v) {
   access(v);
   splay(v);
   access(u);
   splay(u);
   fa[u] = v;
   ssiz[v] += siz[u];
   sans[v] += ans[u];
   sqsiz[v] += siz[u] * siz[u];
   pushup(v);
 }
 void cut(int u, int v) {
   access(u);
   access(v);
   splay(v);
   splay(u);
   fa[u] = 0;
   ssiz[v] -= siz[u];
   sans[v] -= ans[u];
   sqsiz[v] -= siz[u] * siz[u];
   pushup(v);
 }
 bool check(int u, int v) {
   access(v);
   splay(v);
   splay(u);
   if (isroot(v)) {
     return false;
   }
   return true;
 }
 int main() {
   scanf( %d , &n);
   for (int i = 2; i <= n; i++) {
     scanf( %d , &f[i]);
   }
   for (int i = 1; i <= n; i++) {
     scanf( %lld , &a[i]);
     ans[i] = all[i] = a[i];
   }
   for (int i = 1; i <= n; i++) {
     siz[i] = 1;
     ssiz[i] = 1;
   }
   for (int i = 2; i <= n; i++) {
     link(i, f[i]);
   }
   access(1);
   splay(1);
   printf( %.10lf
 , 1.0 * ans[1] / n / n);
   scanf( %d , &m);
   while (m--) {
     scanf( %s%d%d , op, &x, &y);
     if (op[0] == 'P') {
       if (check(x, y)) {
         swap(x, y);
       }
       cut(x, f[x]);
       f[x] = y;
       link(x, f[x]);
       access(1);
       splay(1);
       printf( %.10lf
 , 1.0 * ans[1] / n / n);
     } else {
       access(x);
       splay(x);
       a[x] = y;
       pushup(x);
       printf( %.10lf
 , 1.0 * ans[x] / n / n);
     }
   }
   return 0;
 }


#include <bits/stdc++.h>
 using namespace std;
 int main() {
   ios_base::sync_with_stdio(false);
   cin.tie(NULL);
   long long x, y, n, m, t, q, a, b, count = 0;
   cin >> n >> m;
   long long arr[n];
   for (x = 0; x < n; x++) cin >> arr[x];
   a = 0;
   for (x = 0; x < n; x++) {
     a = a + arr[x];
     cout << a / m <<    ;
     a = a % m;
   }
 }


#include <bits/stdc++.h>
 using namespace std;
 int qread() {
   char c;
   int s = 0, f = 1;
   while ((c = getchar()) < '0' || c > '9') (c == '-') && (f = -1);
   do s = s * 10 + c - '0';
   while ((c = getchar()) >= '0' && c <= '9');
   return s * f;
 }
 int n, m;
 const int mod = 1e9 + 7;
 int a[100011], pos[100011], bin[100011], inv[100011], sum[100011],
     lp = 0, val[100011], vv[100011], svv[100011];
 struct Ques {
   int l, r, id;
   bool operator<(const Ques &b) const { return r < b.r; }
 } q[100011];
 int ans[100011];
 int WWW(long long v) { return v > 2000000001 ? 2000000001 : v; }
 int main() {
   n = qread();
   m = qread();
   bin[0] = inv[0] = 1;
   for (int i = 1; i <= n; i++)
     a[i] = qread(), bin[i] = (bin[i - 1] << 1) % mod,
     inv[i] = 1ll * inv[i - 1] * ((mod + 1) >> 1) % mod,
     sum[i] = ((sum[i - 1] + 1ll * a[i] * bin[i]) % mod + mod) % mod;
   for (int i = 1; i <= m; i++) {
     q[i].l = qread();
     q[q[i].id = i].r = qread();
   }
   sort(q + 1, q + 1 + m);
   pos[lp = 1] = 1;
   int j = 1;
   val[1] = a[1] * 2;
   vv[1] = svv[1] = ((a[1] * 2) % mod + mod) % mod;
   while (j <= m && q[j].r == 1) ans[q[j].id] = (a[1] + mod) % mod, j++;
   for (int i = 2; i <= n; i++) {
     if (a[i] <= 0)
       pos[++lp] = i, val[lp] = 2 * a[i],
       vv[lp] = (a[i] * 2ll % mod + mod) % mod,
       svv[lp] = (svv[lp - 1] + vv[lp]) % mod;
     else {
       int cur =
           WWW(0ll + val[lp] + bin[pos[lp] - pos[lp - 1] + 1] * 1ll * a[i]);
       int cvv = (vv[lp] + bin[pos[lp] - pos[lp - 1] + 1] * 1ll * a[i]) % mod;
       lp--;
       while (lp && cur > 0) {
         cur = WWW(0ll + val[lp] +
                   (pos[lp] - pos[lp - 1] > 31 ? 2000000001
                                               : bin[pos[lp] - pos[lp - 1]]) *
                       1ll * cur);
         cvv = (vv[lp] + bin[pos[lp] - pos[lp - 1]] * 1ll * cvv) % mod;
         lp--;
       }
       val[++lp] = cur;
       pos[lp] = i;
       vv[lp] = cvv;
       svv[lp] = (svv[lp - 1] + vv[lp]) % mod;
     }
     while (j <= m && q[j].r == i) {
       if (q[j].l == q[j].r) {
         ans[q[j].id] = (a[i] + mod) % mod;
         j++;
         continue;
       }
       int l = q[j].l + 1, Ans = (a[q[j].l] + mod) % mod;
       int L = 1, R = lp;
       while (L < R) {
         int mid = (L + R) >> 1;
         if (pos[mid] >= l)
           R = mid;
         else
           L = mid + 1;
       }
       Ans = (Ans + svv[lp] - svv[L]) % mod;
       Ans = (Ans + mod) % mod;
       Ans = (Ans + (sum[pos[L]] - sum[l - 1] + mod) * 1ll * inv[l - 1]) % mod;
       ans[q[j].id] = Ans;
       j++;
     }
   }
   for (int i = 1; i <= m; i++) printf( %d
 , ans[i]);
   return 0;
 }


#include <bits/stdc++.h>
 using namespace std;
 const long long mod = 1000000007;
 const long long inf = 1000000000000000000;
 int main() {
   long long t;
   cin >> t;
   while (t--) {
     long long n;
     cin >> n;
     vector<pair<long long, long long> > p(n);
     for (auto& x : p) cin >> x.first >> x.second;
     sort(p.begin(), p.end());
     pair<long long, long long> now = {0, 0};
     bool f = 1;
     string ans =   ;
     for (int i = 0; i < n; i++) {
       if (p[i].first >= now.first && p[i].second >= now.second) {
         long long r = p[i].first - now.first, u = p[i].second - now.second;
         while (r--) ans += 'R';
         while (u--) ans += 'U';
         now = p[i];
       } else {
         f = 0;
         break;
       }
     }
     if (f)
       cout <<  YES
  << ans << endl;
     else
       cout <<  NO
 ;
   }
   return 0;
 }


#include <bits/stdc++.h>
 using namespace std;
 int main() {
   int n, m;
   scanf( %d %d , &n, &m);
   for (int i = 0; i < n; i++) {
     if (i % 2 == 0) {
       for (int j = 1; j <= m; j++) {
         printf( # );
       }
     } else if (i % 4 == 1) {
       for (int j = 1; j < m; j++) {
         printf( . );
       }
       printf( # );
     } else if (i % 4 == 3) {
       printf( # );
       for (int j = 1; j < m; j++) {
         printf( . );
       }
     }
     printf(
 );
   }
   return 0;
 }


#include <bits/stdc++.h>
 using namespace std;
 const int N = 2e5 + 65, mod = 1e9 + 7;
 vector<int> g[N];
 int w[N];
 int col[N], pr[N];
 int sz[N][2];
 long long ans = 0;
 void dfs(int v, int par = -1, int c = 0) {
   pr[v] = par;
   ++sz[v][c];
   col[v] = c;
   for (int u : g[v])
     if (u != par) {
       dfs(u, v, c ^ 1);
       sz[v][0] += sz[u][0];
       sz[v][1] += sz[u][1];
     }
 }
 int main() {
   int n;
   scanf( %d , &n);
   for (int i = 0; i < n; ++i) scanf( %d , w + i);
   for (int i = 1; i < n; ++i) {
     int u, v;
     scanf( %d %d , &u, &v);
     --u, --v;
     g[u].push_back(v);
     g[v].push_back(u);
   }
   ans = 0;
   dfs(0);
   for (int v = 0; v < n; ++v) {
     vector<pair<int, int> > vs;
     for (int u : g[v])
       if (u != pr[v]) vs.emplace_back(sz[u][0], sz[u][1]);
     if (pr[v] != -1) vs.emplace_back(sz[0][0] - sz[v][0], sz[0][1] - sz[v][1]);
     long long cnt = n;
     if (col[v]) {
       for (pair<int, int> e : vs) {
         cnt = (cnt + 1LL * e.second * (n - e.first - e.second)) % mod;
         cnt = (cnt - 1LL * e.first * (n - e.first - e.second)) % mod;
       }
     } else {
       for (pair<int, int> e : vs) {
         cnt = (cnt - 1LL * e.second * (n - e.first - e.second)) % mod;
         cnt = (cnt + 1LL * e.first * (n - e.first - e.second)) % mod;
       }
     }
     cnt %= mod;
     if (cnt < 0) cnt += mod;
     ans = (ans + cnt * w[v]) % mod;
   }
   ans %= mod;
   if (ans < 0) ans += mod;
   cout << ans << endl;
   return 0;
 }


#include <bits/stdc++.h>
 using namespace std;
 void readi(int &x) {
   int v = 0, f = 1;
   char c = getchar();
   while (!isdigit(c) && c != '-') c = getchar();
   if (c == '-')
     f = -1;
   else
     v = v * 10 + c - '0';
   while (isdigit(c = getchar())) v = v * 10 + c - '0';
   x = v * f;
 }
 void readll(long long &x) {
   long long v = 0ll, f = 1ll;
   char c = getchar();
   while (!isdigit(c) && c != '-') c = getchar();
   if (c == '-')
     f = -1;
   else
     v = v * 10 + c - '0';
   while (isdigit(c = getchar())) v = v * 10 + c - '0';
   x = v * f;
 }
 void readc(char &x) {
   char c;
   while ((c = getchar()) == ' ')
     ;
   x = c;
 }
 void writes(string s) { puts(s.c_str()); }
 void writeln() { writes(  ); }
 void writei(int x) {
   if (!x) putchar('0');
   char a[25];
   int top = 0;
   while (x) {
     a[++top] = (x % 10) + '0';
     x /= 10;
   }
   while (top) {
     putchar(a[top]);
     top--;
   }
 }
 void writell(long long x) {
   if (!x) putchar('0');
   char a[25];
   int top = 0;
   while (x) {
     a[++top] = (x % 10) + '0';
     x /= 10;
   }
   while (top) {
     putchar(a[top]);
     top--;
   }
 }
 inline long long inc(int &x) { return ++x; }
 inline long long inc(long long &x) { return ++x; }
 inline long long inc(int &x, long long y) { return x += y; }
 inline long long inc(long long &x, long long y) { return x += y; }
 inline double inc(double &x, double y) { return x += y; }
 inline long long dec(int &x) { return --x; }
 inline long long dec(long long &x) { return --x; }
 inline long long dec(int &x, long long y) { return x -= y; }
 inline long long dec(long long &x, long long y) { return x -= y; }
 inline double dec(double &x, double y) { return x -= y; }
 inline long long mul(int &x) { return x = ((long long)x) * x; }
 inline long long mul(long long &x) { return x = x * x; }
 inline long long mul(int &x, long long y) { return x *= y; }
 inline long long mul(long long &x, long long y) { return x *= y; }
 inline double mul(double &x, double y) { return x *= y; }
 inline long long divi(const int &x) {
   long long ans, l, r, mid;
   ans = 0;
   l = 0;
   r = 0x3fffffff;
   while (l < r) {
     mid = (l + r) / 2;
     if (mid * mid <= x) {
       ans = mid;
       l = mid + 1;
     } else
       r = mid;
   }
   return ans;
 }
 inline long long divi(const long long &x) {
   long long ans, l, r, mid;
   ans = 0;
   l = 0;
   r = 0x3fffffff;
   while (l < r) {
     mid = (l + r) / 2;
     if (mid * mid <= x) {
       ans = mid;
       l = mid + 1;
     } else
       r = mid;
   }
   return ans;
 }
 inline long long divi(int &x, long long y) { return x /= y; }
 inline long long divi(long long &x, long long y) { return x /= y; }
 inline double divi(double &x, double y) { return x /= y; }
 inline long long mod(int &x, long long y) { return x %= y; }
 inline long long mod(long long &x, long long y) { return x %= y; }
 int n, m, i, j, ct[100005], x, y, vis[100005];
 vector<int> e[100005];
 struct vt {
   int id, deg;
 } a[100005];
 bool cmp(vt x, vt y) { return x.deg > y.deg; }
 bool dfs(int x) {
   if (vis[x] == 1) return 1;
   if (vis[x] == 2) return 0;
   vis[x] = 1;
   for (__typeof((e[x]).begin()) it = (e[x]).begin(); it != (e[x]).end(); it++)
     if (dfs(*it)) return 1;
   vis[x] = 2;
   return 0;
 }
 bool check(int x) {
   memset(vis, 0, sizeof(vis));
   vis[x] = 2;
   int i;
   for (i = 1; i <= n; i++) {
     if (!vis[i] && dfs(i)) {
       for (i = 1; i <= n; i++)
         if (vis[i] != 1) ct[i] = 1;
       return 0;
     }
   }
   return 1;
 }
 int main() {
   double st = clock();
   ios_base::sync_with_stdio(false);
   ;
   cin >> n >> m;
   if ((1) <= ((m)))
     for (((i)) = (1); ((i)) <= ((m)); ((i))++) {
       cin >> x >> y;
       e[x].push_back(y);
     }
   if ((1) <= ((n)))
     for (((i)) = (1); ((i)) <= ((n)); ((i))++) {
       a[i].id = i;
       a[i].deg = e[i].size();
     }
   stable_sort(a + 1, a + n + 1, cmp);
   if ((1) <= ((n)))
     for (((i)) = (1); ((i)) <= ((n)); ((i))++) {
       if ((clock() - st) / CLOCKS_PER_SEC > 0.9) break;
       x = a[i].id;
       if (ct[x] || !check(x)) continue;
       cout << x;
       return 0;
     }
   cout <<  -1 ;
   return 0;
 }


#include <bits/stdc++.h>
 using namespace std;
 const long long mxn = 1003, inf = 1e18 + 18;
 int n, m, lcp[mxn][mxn], rk[mxn][mxn], ri[mxn], tot;
 long long k, f[mxn];
 string s;
 struct S {
   int l, r;
 } a[mxn * mxn];
 inline bool cmp(S a, S b) {
   int p = a.l + lcp[a.l][b.l], q = b.l + lcp[a.l][b.l];
   if (p > a.r or q > b.r) return a.r - a.l < b.r - b.l;
   return s[p] < s[q];
 }
 inline long long add(long long a, long long b) {
   return a + b > inf ? inf : a + b;
 }
 inline long long calc(int md) {
   for (int i = 1; i <= n; ++i) {
     ri[i] = i;
     for (; ri[i] <= n and rk[i][ri[i]] < md;) ++ri[i];
   }
   memset(f, 0, sizeof(f)), f[n + 1] = 1;
   for (int i = 1; i <= m; ++i) {
     for (int j = n; j; --j) f[j] = add(f[j], f[j + 1]);
     for (int j = 1; j <= n; ++j) f[j] = ri[j] <= n ? f[ri[j] + 1] : 0;
     f[n + 1] = 0;
   }
   return f[1];
 }
 int main() {
   cin >> n >> m >> k >> s, s = ' ' + s;
   for (int i = n; i; --i)
     for (int j = n; j; --j)
       if (s[i] == s[j]) lcp[i][j] = lcp[i + 1][j + 1] + 1;
   for (int i = 1; i <= n; ++i)
     for (int j = i; j <= n; ++j) a[++tot] = (S){i, j};
   sort(a + 1, a + tot + 1, cmp);
   for (int i = 1; i <= tot; ++i) rk[a[i].l][a[i].r] = i;
   int l = 1, r = tot, md;
   for (; l <= r;) {
     md = l + r >> 1;
     if (calc(md) >= k)
       l = md + 1;
     else
       r = md - 1;
   }
   for (int i = a[r].l; i <= a[r].r; ++i) putchar(s[i]);
 }


#include <algorithm>
 #include <cmath>
 #include <cstdio>
 #include <cstring>
 #include <iostream>
 #include <map>
 #include <set>
 #include <unordered_map>

 using namespace std;
 typedef long long LL;
 const int N = 3e5 + 10, mod = 998244353;
 string g[N];
 int dp[N];

 int fastPow(int a, int k) {
     int res = 1;
     while (k) {
         if (k & 1) res = (LL)res * a % mod;
         k >>= 1;
         a = (LL)a * a % mod;
     }
     return res;
 }

 int main() {
     ios::sync_with_stdio(false);
     int n, m, sum = 0, res = 0;
     n = 300000;
     for (int i = 2; i <= n; i++) {
         if (i & 1) sum = (sum + 1) % mod;
         dp[i] = ((LL)dp[i - 1] * 2 % mod + sum + !(i & 1)) % mod;
         sum = (sum << 1) % mod;
     }
     sum = 0;
     cin >> n >> m;
     for (int i = 0; i < n; i++) {
         cin >> g[i];
         for (auto c : g[i])
             if (c == 'o') sum++;
     }
     for (int i = 0; i < n; i++) {
         int cnt = 0, len = 0;
         while (cnt <= m) {
             if (cnt == m || g[i][cnt] == '*') {
                 if (len) {
                     res = (res + (LL)dp[len] *
                                      fastPow(2, sum - len) % mod) %
                           mod;
                     len = 0;
                 }
             } else {
                 len++;
             }
             cnt++;
         }
     }
     for (int i = 0; i < m; i++) {
         int cnt = 0, len = 0;
         while (cnt <= n) {
             if (cnt == n || g[cnt][i] == '*') {
                 if (len) {
                     res = (res + (LL)dp[len] *
                                      fastPow(2, sum - len) % mod) %
                           mod;
                     len = 0;
                 }
             } else {
                 len++;
             }
             cnt++;
         }
     }
     cout << res << endl;
     return 0;
 }


#include <bits/stdc++.h>
 using namespace std;
 const int maxn = 100 + 10;
 char s[maxn];
 int f(char ch) {
   if (ch == 'A') return 1;
   if (ch == 'B') return 2;
   if (ch == 'C') return 4;
   return 0;
 }
 int main() {
   scanf( %s , s + 1);
   int l = strlen(s + 1);
   for (int i = 1; i <= l - 2; ++i) {
     int t = f(s[i]) | f(s[i + 1]) | f(s[i + 2]);
     if (t == 7) {
       cout <<  Yes  << endl;
       return 0;
     }
   }
   cout <<  No ;
   return 0;
 }


#include <bits/stdc++.h>
 using namespace std;
 vector<int> tree[500001];
 bool intree[500001];
 vector<int> tmp(0);
 bool isleaf(int node) {
   if (tree[node].size() == 1 && intree[(tree[node])[0]]) return true;
   return false;
 }
 void DFS(int lvl, int node) {
   intree[node] = true;
   if (isleaf(node)) {
     tmp.push_back(lvl);
   }
   for (int i = 0; i < tree[node].size(); i++) {
     if (!intree[(tree[node])[i]]) {
       DFS(lvl + 1, (tree[node])[i]);
     }
   }
 }
 int main() {
   ios_base::sync_with_stdio(false);
   int N;
   cin >> N;
   for (int i = 1; i <= N; i++) intree[i] = false;
   int x, y;
   for (int i = 0; i < N - 1; i++) {
     cin >> x >> y;
     tree[x].push_back(y);
     tree[y].push_back(x);
   }
   intree[1] = true;
   int ans = 0, c;
   for (int i = 0; i < (tree[1]).size(); i++) {
     tmp.clear();
     DFS(0, (tree[1])[i]);
     sort(tmp.begin(), tmp.end());
     c = tmp.size();
     for (int j = 0; j < c; j++) {
       ans = max(ans, tmp[j] + c - j);
     }
   }
   cout << ans << endl;
 }


#include <bits/stdc++.h>
 using namespace std;
 int main() {
   ios_base::sync_with_stdio(false);
   int n;
   cin >> n;
   vector<string> v(n);
   for (int i = 0; i < n; i++) cin >> v[i];
   for (int i = 1; i < n - 1; i++) {
     for (int j = 1; j < n - 1; j++) {
       if (v[i][j] == '#' and v[i + 1][j] == '#' and v[i][j + 1] == '#' and
           v[i][j - 1] == '#' and v[i - 1][j] == '#') {
         v[i][j] = 'a';
         v[i + 1][j] = 'a';
         v[i][j + 1] = 'a';
         v[i][j - 1] = 'a';
         v[i - 1][j] = 'a';
       }
     }
   }
   int c = 0;
   for (int i = 0; i < n; i++)
     for (int j = 0; j < n; j++)
       if (v[i][j] == '#') {
         c = 1;
         break;
       }
   if (c)
     cout <<  NO  << endl;
   else
     cout <<  YES  << endl;
   return 0;
 }


#include <bits/stdc++.h>
 using namespace std;
 const long long N = 1e5 + 5;
 int32_t main() {
   ios::sync_with_stdio(0);
   cin.tie(0);
   cout.tie(0);
   ;
   long long n;
   cin >> n;
   long long con = -1;
   long long a[n + 5];
   for (long long i = 1; i <= n; i++) {
     cin >> a[i];
   }
   long long i = 1;
   for (i = 1; i < n; i++) {
     if (a[i + 1] == a[i]) {
       con = i;
       break;
     }
   }
   if (con == -1) {
     for (con = 1; con < n; con++) {
       if (a[con] > a[con + 1]) {
         break;
       }
     }
   }
   for (i = 1; i < con; i++) {
     if (a[i + 1] < a[i]) {
       cout <<  NO
            <<
 ;
       return 0;
     }
   }
   while (a[con] == a[con + 1]) {
     con++;
   }
   for (i = con; i < n; i++) {
     if (a[i + 1] >= a[i]) {
       cout <<  NO
            <<
 ;
       return 0;
     }
   }
   cout <<  YES
        <<
 ;
 }


#include <bits/stdc++.h>
 using ll = long long;
 using namespace std;
 int main() {
   ios::sync_with_stdio(false);
   int N, K;
   cin >> N >> K;
   ll total = N + 1;
   total += N;
   total += min(2 * (K - 1) + (N - K), 2 * (N - K) + K - 1);
   cout << total <<
 ;
   return 0;
 }


#include <bits/stdc++.h>
 using namespace std;
 int main() {
   ios_base::sync_with_stdio(false);
   cin.tie(NULL);
   long long int test = 1;
   for (; test > 0; --test) {
     long long int n, a, b, c, d, c1 = 1, c2, c3, c4;
     cin >> n >> a >> b >> c >> d;
     c2 = c1 + b - c;
     c3 = c2 + a - d;
     c4 = c3 + c - b;
     long long int m = 1 - min(min(c1, c2), min(c3, c4)),
                   m1 = max(max(c1, c2), max(c3, c4));
     if (m1 + abs(m) > n)
       cout << 0 << endl;
     else
       cout << (n - (m1 + abs(m)) + 1) * n << endl;
   }
   return (0);
 }


#include <bits/stdc++.h>
 using namespace std;
 const long long int MAX = 1000000007;
 const long long int MAXN = 100010;
 int main() {
   ios_base::sync_with_stdio(false);
   cin.tie(NULL);
   cout.tie(NULL);
   long long int t;
   cin >> t;
   while (t--) {
     long long int n, k;
     cin >> n >> k;
     if (n % 2 == 0 && k % 2 == 1)
       cout <<  NO  << endl;
     else if (n % 2 == 1 && k % 2 == 0)
       cout <<  NO  << endl;
     else {
       if (k * k <= n)
         cout <<  YES  << endl;
       else
         cout <<  NO  << endl;
     }
   }
   return 0;
 }


#include <bits/stdc++.h>
 using namespace std;
 vector<pair<long long int, pair<long long int, long long int> > > P;
 int level[1007];
 double ans = 0;
 bool contains(pair<long long int, pair<long long int, long long int> > A,
               pair<long long int, pair<long long int, long long int> > B) {
   return (A.second.first - B.second.first) * (A.second.first - B.second.first) +
              (A.second.second - B.second.second) *
                  (A.second.second - B.second.second) <
          (A.first) * (A.first);
 }
 int main() {
   long long int i, j, k, l, m, n, x, y, z, a, b, r;
   scanf( %lld , &n);
   for (i = 0; i < n; i++) {
     scanf( %lld , &x);
     scanf( %lld , &y);
     scanf( %lld , &r);
     P.push_back(make_pair(r, make_pair(x, y)));
   }
   sort(P.begin(), P.end());
   for (i = n - 1; i >= 0; i--) {
     for (j = n - 1; j > i; j--) {
       if (contains(P[j], P[i])) {
         level[i] = max(level[i], level[j] + 1);
       }
     }
     if (level[i] == 0) level[i] = 1;
   }
   for (i = 0; i < n; i++) {
     if (level[i] <= 2)
       ans += (P[i].first * P[i].first);
     else {
       if (level[i] % 2 == 1)
         ans -= (P[i].first * P[i].first);
       else
         ans += (P[i].first * P[i].first);
     }
   }
   printf( %.10lf
 , ans * 3.14159265358979);
   return 0;
 }


#include <bits/stdc++.h>
 using namespace std;
 inline long long power(long long a, long long b) {
   long long x = 1;
   a = a % 1000000007ULL;
   while (b) {
     if (b & 1) x = (x * a) % 1000000007ULL;
     a = (a * a) % 1000000007ULL;
     b >>= 1;
   }
   return x;
 }
 inline long long inv(long long a) { return power(a, 1000000007ULL - 2); }
 long long gcd(long long a, long long b) { return a ? gcd(b % a, a) : b; }
 const int N = 2e5 + 5;
 vector<int> adj[N];
 int n, dis[N];
 bool vis[N];
 int cnt[N], p[N];
 int tdis[N];
 vector<int> d[N];
 void dfs(int u, int dd, int par) {
   vis[u] = true;
   if (dd < 3)
     tdis[u] = dd;
   else
     tdis[u] = N;
   dis[u] = dd;
   d[dd].push_back(u);
   p[u] = par;
   for (auto v : adj[u]) {
     if (!vis[v]) dfs(v, dd + 1, u);
   }
 }
 int main() {
   ios_base::sync_with_stdio(false);
   cin >> n;
   int u, v;
   for (int i = 1; i < n; i++) {
     cin >> u >> v;
     adj[u].push_back(v);
     adj[v].push_back(u);
   }
   dfs(1, 0, 0);
   int maxx = 0;
   for (int i = 0; i < n; i++) {
     if (d[i].size() == 0) break;
     maxx = i;
   }
   int ans = 0;
   for (int i = maxx; i > 1; i--) {
     for (auto v : d[i]) {
       if (dis[v] < 2 || tdis[v] == 2) continue;
       ans++;
       tdis[p[v]] = 2;
       for (auto j : adj[p[v]]) tdis[j] = 2;
     }
   }
   cout << ans << endl;
   return 0;
 }


#include <bits/stdc++.h>
 using namespace std;
 int mod = 998244353;
 long long a[300001];
 long long n, m, k;
 int b[300001];
 void solve() {
   cin >> n;
   for (int i = 0; i < n; ++i) {
     int x;
     cin >> x;
     a[x]++;
     b[a[x]] += a[x];
     k = (b[a[x]] >= i && b[a[x]] != n) ? b[a[x]] : k;
   }
   cout << k + 1;
 }
 int main() {
   ios_base::sync_with_stdio(false);
   cin.tie(NULL);
   cout.tie(NULL);
   int t = 1;
   while (t--) {
     solve();
   }
   return 0;
 }


#include <bits/stdc++.h>
 using namespace std;
 int main() {
   char str[2020];
   long l;
   cin >> l;
   cin >> str;
   int i, j, hs = 0, ts = 0;
   for (i = 0; i < l; i++) {
     if (str[i] == 'H')
       hs++;
     else
       ts++;
     str[l + i] = str[i];
   }
   int res = 1000000000;
   int t;
   for (i = 0; i < l; i++) {
     t = 0;
     for (j = 0; j < hs; j++) {
       if (str[i + j] == 'T') t++;
     }
     if (t < res) res = t;
     t = 0;
     for (j = 0; j < ts; j++) {
       if (str[i + j] == 'H') t++;
     }
     if (t < res) res = t;
   }
   cout << res;
   return 0;
 }


#include <bits/stdc++.h>
 using namespace std;
 void mohammed() {
   ios::sync_with_stdio(0);
   ios_base::sync_with_stdio(0);
   cin.tie(0), cout.tie(0);
 }
 int main() {
   mohammed();
   int n, x, y;
   cin >> n;
   map<int, int> mp;
   map<int, int>::iterator it;
   for (int i = 0; i < n; i++) {
     cin >> x >> y;
     mp[x]++;
     mp[y + 1]--;
   }
   x = 0;
   for (it = mp.begin(); it != mp.end(); it++) {
     it->second += x;
     if (it->second > 2) {
       cout <<  NO ;
       return 0;
     }
     x = it->second;
   }
   cout <<  YES ;
   return 0;
 }


#include <bits/stdc++.h>
 using namespace std;
 const double pi = acos(-1.0);
 template <typename T, typename U>
 inline void amin(T &x, U y) {
   if (y < x) x = y;
 }
 template <typename T, typename U>
 inline void amax(T &x, U y) {
   if (x < y) x = y;
 }
 template <class L, class R>
 ostream &operator<<(ostream &os, pair<L, R> P) {
   return os <<  (  << P.first <<  ,  << P.second <<  )
 ;
 }
 template <class T>
 ostream &operator<<(ostream &os, set<T> V) {
   os <<  [ ;
   for (auto vv : V) os << vv <<  ,  ;
   return os <<  ]
 ;
 }
 template <class T>
 ostream &operator<<(ostream &os, vector<T> V) {
   os <<  [ ;
   for (auto vv : V) os << vv <<  ,  ;
   return os <<  ]
 ;
 }
 template <class K, class X>
 ostream &operator<<(ostream &os, map<K, X> V) {
   os <<  [ ;
   for (auto vv : V) os << vv <<  ,  ;
   return os <<  ]
 ;
 }
 long int ceildiv(long int n, long int f) {
   if (n % f) {
     return n / f + 1;
   } else
     return n / f;
 }
 string checkTicket(vector<long> first, vector<long> second) {
   int n = first.size();
   if (first[0] < second[0]) {
     for (int i = 0; i < n; i += 1) {
       if (first[i] >= second[i]) {
         return  NO
 ;
       }
     }
   } else if (first[0] > second[0]) {
     for (int i = 0; i < n; i += 1) {
       if (first[i] <= second[i]) {
         return  NO
 ;
       }
     }
   } else {
     return  NO
 ;
   }
   return  YES
 ;
 }
 int main() {
   long int n;
   cin >> n;
   string s;
   cin >> s;
   vector<long> first, second;
   for (int i = 0; i < n; i++) {
     first.push_back(s[i] - '0');
   }
   for (int i = n; i < 2 * n; i++) {
     second.push_back(s[i] - '0');
   }
   sort(first.begin(), first.end());
   sort(second.begin(), second.end());
   cerr << first << second;
   cout << checkTicket(first, second);
   return 0;
 }


#include <bits/stdc++.h>
 using namespace std;
 const int N = 200005;
 int t[N];
 int p[N];
 int p2[N];
 int main() {
   std::ios::sync_with_stdio(0);
   cin.tie(0);
   cout.tie(0);
   int n;
   long long sum = 0;
   cin >> n;
   for (int i = 0; i <= n; i++) {
     cin >> t[i];
     sum += t[i];
   }
   bool amb = 0;
   for (int i = 1; i <= n; i++) {
     if (t[i] > 1 && t[i - 1] > 1) amb = 1;
   }
   if (!amb) {
     cout <<  perfect ;
     return 0;
   }
   cout <<  ambiguous  << '
';
   long long par = 1, k = 2;
   p[1] = 0;
   p2[1] = 0;
   for (int i = 1; i <= n; i++) {
     long long temp = k;
     for (int j = 0; j < t[i]; j++) {
       p[k] = par;
       p2[k] = par;
       k++;
     }
     par = temp;
   }
   k = 2;
   for (int i = 1; i <= n; i++) {
     if (t[i] > 1 && t[i - 1] > 1) {
       p2[k]++;
       break;
     } else
       k += t[i];
   }
   for (int i = 1; i <= sum; i++) cout << p[i] <<    ;
   cout << '
';
   for (int i = 1; i <= sum; i++) cout << p2[i] <<    ;
 }


#include <bits/stdc++.h>
 using namespace std;
 int main() {
   int n;
   cin >> n;
   long long sum1 = 0, sum2 = 0;
   long temp;
   for (int i = 0; i < n; i++) {
     cin >> temp;
     sum1 += temp;
   }
   for (int i = 0; i < n - 1; i++) {
     cin >> temp;
     sum2 += temp;
   }
   cout << sum1 - sum2 <<
 ;
   for (int i = 0; i < n - 2; i++) {
     cin >> temp;
     sum2 -= temp;
   }
   cout << sum2;
   return (0);
 }


#include <bits/stdc++.h>
 using namespace std;
 const int N = (1 << 20) + 15;
 long long dp[N];
 pair<int, int> id[100];
 int bit[100], c[100], st[N];
 int main() {
   int u, a, mi, n, m, i, j, b, x, p = 0, idd;
   long long k, temp;
   long long ret = 4e18;
   scanf( %d%d%d , &n, &m, &b);
   for (i = 0; i < n; ++i) {
     scanf( %d%d%d , &c[i], &id[i].first, &mi);
     a = 0;
     for (j = 0; j < mi; ++j) scanf( %d , &u), a |= 1 << (u - 1);
     bit[i] = a;
     id[i].second = i;
   }
   memset(dp, -1, sizeof(dp));
   sort(id, id + n);
   dp[0] = 0;
   ++p;
   for (i = 0; i < n; ++i) {
     k = id[i].first, idd = id[i].second;
     if (dp[bit[idd]] != -1 && dp[bit[idd]] <= c[idd]) continue;
     x = p;
     for (j = 0; j < p; ++j) {
       u = st[j] | bit[idd];
       if (dp[u] == -1 && u != (1 << m) - 1) st[x++] = u;
       if (dp[u] == -1 || dp[u] > dp[st[j]] + c[idd]) dp[u] = dp[st[j]] + c[idd];
     }
     if (dp[(1 << m) - 1] != -1) ret = min(ret, k * b + dp[(1 << m) - 1]);
     p = x;
   }
   if (ret == 4e18) ret = -1;
   cout << ret << endl;
 }


#include <bits/stdc++.h>
 using namespace std;
 int cnt[1000100], a[1000100];
 int main() {
   int n, k, ans;
   scanf( %d , &n);
   scanf( %d , &k);
   for (long long i = 0; i < n; i++) scanf( %d , &a[i]);
   int l = 0, r = 0, al, ar;
   set<int> x;
   cnt[a[0]]++;
   x.insert(a[0]);
   ans = 1;
   al = 0, ar = 0;
   while (l < n && r < n) {
     r++;
     x.insert(a[r]);
     cnt[a[r]]++;
     while ((long long)x.size() > k && l <= r) {
       cnt[a[l]]--;
       if (cnt[a[l]] == 0) x.erase(a[l]);
       l++;
     }
     r = max(l, r);
     if (r >= n) break;
     if (r - l + 1 > ans) {
       al = l;
       ar = r;
       ans = r - l + 1;
     }
   }
   printf( %d %d
 , al + 1, ar + 1);
   return 0;
 }


#include <bits/stdc++.h>
 using namespace std;
 const int M = 105;
 int l[M], r[M], t[M], c[M], res[M], p[M];
 int main() {
   int n, m;
   cin >> n >> m;
   for (int i = 0; i < m; ++i) {
     cin >> l[i] >> r[i] >> t[i] >> c[i];
   }
   for (int i = 1; i <= n; ++i) p[i] = INT_MAX;
   for (int i = 0; i < m; ++i)
     for (int j = l[i]; j <= r[i]; ++j)
       if (t[i] < p[j]) p[j] = t[i], res[j] = i;
   int sum = 0;
   for (int i = 1; i <= n; ++i)
     if (p[i] != INT_MAX) sum += c[res[i]];
   cout << sum << endl;
 }


#include <bits/stdc++.h>
 using namespace std;
 const long double EPS = 1e-9, pi = acos(-1);
 const long long N = 1e5 + 5;
 long long r[N], h[N], n, F[N], dp[N];
 bool cmp(pair<long long, long long> a, pair<long long, long long> b) {
   if (a.first == b.first) {
     return a.second < b.second;
   } else
     return a.first < b.first;
 }
 void add(long long d, long long id) {
   while (id <= n) {
     F[id] = max(F[id], d);
     id += (id & -id);
   }
 }
 long long get(long long i) {
   long long res = 0;
   while (i) {
     res = max(res, F[i]);
     i -= (i & -i);
   }
   return res;
 }
 signed main() {
   ios_base::sync_with_stdio(0);
   cin.tie(0);
   cin >> n;
   for (long long i = 1; i <= n; ++i) cin >> r[i] >> h[i];
   vector<pair<long long, long long> > A;
   A.clear();
   for (long long i = 1; i <= n; ++i) {
     A.push_back({r[i] * r[i] * h[i], i});
   }
   sort(A.begin(), A.end(), cmp);
   long long res = 0, id = 0, prev = A[0].first;
   for (long long i = 0; i < n; ++i) {
     if (prev != A[i].first) {
       while (id < i) {
         add(dp[id], A[id].second);
         id++;
       }
     }
     dp[i] = get(A[i].second) + A[i].first;
     res = max(res, dp[i]);
     prev = A[i].first;
   }
   cout << fixed << setprecision(9) << pi * res << endl;
   return 0;
 }


#include <bits/stdc++.h>
 using namespace std;
 int main() {
   int t;
   cin >> t;
   string str;
   for (int i = 0; i < t; i++) {
     cin >> str;
     long long int res = 0;
     long long int arr[str.size()];
     if (str[0] == '+') {
       arr[0] = 1;
     } else {
       arr[0] = -1;
     }
     for (int j = 1; j < str.size(); j++) {
       if (str[j] == '+') {
         arr[j] = arr[j - 1] + 1;
       } else {
         arr[j] = arr[j - 1] - 1;
       }
     }
     int x = -1;
     for (int j = 0; j < str.size(); j++) {
       if (arr[j] == x) {
         res = res + j + 1;
         x--;
       }
     }
     res = res + str.size();
     cout << res << endl;
   }
   return 0;
 }


#include <bits/stdc++.h>
 template <typename T>
 void MACRO_VAR_Scan(T& t) {
   std::cin >> t;
 }
 template <typename First, typename... Rest>
 void MACRO_VAR_Scan(First& first, Rest&... rest) {
   std::cin >> first;
   MACRO_VAR_Scan(rest...);
 }
 template <typename T>
 void MACRO_VEC_ROW_Init(int n, T& t) {
   t.resize(n);
 }
 template <typename First, typename... Rest>
 void MACRO_VEC_ROW_Init(int n, First& first, Rest&... rest) {
   first.resize(n);
   MACRO_VEC_ROW_Init(n, rest...);
 }
 template <typename T>
 void MACRO_VEC_ROW_Scan(int p, T& t) {
   std::cin >> t[p];
 }
 template <typename First, typename... Rest>
 void MACRO_VEC_ROW_Scan(int p, First& first, Rest&... rest) {
   std::cin >> first[p];
   MACRO_VEC_ROW_Scan(p, rest...);
 }
 template <typename T>
 inline T CHMAX(T& a, const T b) {
   return a = (a < b) ? b : a;
 }
 template <typename T>
 inline T CHMIN(T& a, const T b) {
   return a = (a > b) ? b : a;
 }
 void CHECKTIME(std::function<void()> f) {
   auto start = std::chrono::system_clock::now();
   f();
   auto end = std::chrono::system_clock::now();
   auto res = std::chrono::duration_cast<std::chrono::nanoseconds>((end - start))
                  .count();
   std::cerr <<  [Time:  << res <<  ns  (  << res / (1.0e9) <<  s)]
 ;
 }
 template <class T>
 std::vector<std::vector<T>> VV(int n, int m, T init = T()) {
   return std::vector<std::vector<T>>(n, std::vector<T>(m, init));
 }
 template <typename S, typename T>
 std::ostream& operator<<(std::ostream& os, std::pair<S, T> p) {
   os <<  (  << p.first <<  ,   << p.second <<  ) ;
   return os;
 }
 using ll = long long;
 using ull = unsigned long long;
 using ld = long double;
 using PAIR = std::pair<ll, ll>;
 using PAIRLL = std::pair<ll, ll>;
 constexpr ll INFINT = 1 << 30;
 constexpr ll INFINT_LIM = (1LL << 31) - 1;
 constexpr ll INFLL = 1LL << 60;
 constexpr ll INFLL_LIM = (1LL << 62) - 1 + (1LL << 62);
 constexpr double EPS = 1e-9;
 constexpr ll MOD = 1000000007;
 constexpr double PI = 3.141592653589793238462643383279;
 template <class T, size_t N>
 void FILL(T (&a)[N], const T& val) {
   for (auto& x : a) x = val;
 }
 template <class ARY, size_t N, size_t M, class T>
 void FILL(ARY (&a)[N][M], const T& val) {
   for (auto& b : a) FILL(b, val);
 }
 template <class T>
 void FILL(std::vector<T>& a, const T& val) {
   for (auto& x : a) x = val;
 }
 template <class ARY, class T>
 void FILL(std::vector<std::vector<ARY>>& a, const T& val) {
   for (auto& b : a) FILL(b, val);
 }
 namespace FFT {
 const double pi = std::acos(-1);
 std::vector<std::complex<double>> tmp;
 size_t sz = 1;
 std::vector<std::complex<double>> fft(std::vector<std::complex<double>> a,
                                       bool inv = false) {
   size_t mask = sz - 1;
   size_t p = 0;
   for (size_t i = sz >> 1; i >= 1; i >>= 1) {
     auto& cur = (p & 1) ? tmp : a;
     auto& nex = (p & 1) ? a : tmp;
     std::complex<double> e = std::polar(1., 2 * pi * i * (inv ? -1 : 1) / sz);
     std::complex<double> w = 1;
     for (size_t j = 0; j < sz; j += i) {
       for (size_t k = 0; k < i; ++k) {
         nex[j + k] =
             cur[((j << 1) & mask) + k] + w * cur[(((j << 1) + i) & mask) + k];
       }
       w *= e;
     }
     ++p;
   }
   if (p & 1) std::swap(a, tmp);
   if (inv)
     for (size_t i = 0; i < sz; ++i) a[i] /= sz;
   return a;
 }
 std::vector<ll> mul(std::vector<ll> a, std::vector<ll> b) {
   size_t m = a.size() + b.size() - 1;
   sz = 1;
   while (m > sz) sz <<= 1;
   tmp.resize(sz);
   std::vector<std::complex<double>> A(sz), B(sz);
   for (size_t i = 0; i < a.size(); ++i) A[i].real(a[i]);
   for (size_t i = 0; i < b.size(); ++i) B[i].real(b[i]);
   A = fft(A);
   B = fft(B);
   for (size_t i = 0; i < sz; ++i) A[i] *= B[i];
   A = fft(A, true);
   a.resize(m);
   for (size_t i = 0; i < m; ++i) a[i] = std::round(A[i].real());
   return a;
 }
 };  // namespace FFT
 signed main() {
   std::ios::sync_with_stdio(false);
   std::cin.tie(0);
   ;
   ll n, x;
   MACRO_VAR_Scan(n, x);
   ;
   std::vector<ll> a(n);
   for (auto& i : a) std::cin >> i;
   ;
   for (ll i = 0; i < ll(n); ++i) a[i] = a[i] < x;
   std::vector<ll> b;
   {
     ll cnt = 0;
     for (ll i = 0; i < ll(n + 1); ++i) {
       if (i == n || a[i]) {
         b.emplace_back(cnt);
         cnt = 0;
       } else {
         ++cnt;
       }
     }
   }
   ll m = b.size();
   {
     ll ans = 0;
     for (ll i = 0; i < ll(m); ++i) {
       ans += (ll)b[i] * (b[i] + 1) / 2;
     }
     std::cout << (ans);
     ;
   }
   {
     for (ll i = 0; i < ll(m); ++i) ++b[i];
     auto bb(b);
     std::reverse((bb).begin(), (bb).end());
     auto c = FFT::mul(b, bb);
     std::vector<ll> ans(n, 0);
     ll p = 0;
     for (ll i = ll(m - 1) - 1; i >= 0; --i) {
       ans[p++] = c[i];
     }
     for (ll i = 0; i < ll(n); ++i) {
       std::cout <<    ;
       std::cout << (ans[i]);
       ;
     }
     std::cout <<
 ;
     ;
   }
   return 0;
 }


#include <bits/stdc++.h>
 using namespace std;
 int main() {
   int n, k;
   cin >> n >> k;
   for (int i = 0; i < k; i++) {
     if (n % 10 != 0) {
       n = n - 1;
     } else if (n % 10 == 0) {
       n = n / 10;
     }
   }
   cout << n;
   return 0;
 }


#include <bits/stdc++.h>
 using namespace std;
 const int N = 5e5 + 100;
 template <class nmsl>
 inline void read(nmsl &x) {
   x = 0;
   char ch = getchar(), w = 0;
   while (!isdigit(ch)) w = (ch == '-'), ch = getchar();
   while (isdigit(ch)) x = (x << 1) + (x << 3) + (ch ^ 48), ch = getchar();
   x = w ? -x : x;
 }
 long long n, f[N], size[N], root[N], hd[N], bianshu, ans;
 struct abc {
   int nxt, to;
 } qwq[N * 2];
 inline void addedg(int lai, int qu) {
   qwq[++bianshu].nxt = hd[lai];
   qwq[bianshu].to = qu;
   hd[lai] = bianshu;
 }
 inline void first_dp(int u, int father) {
   size[u] = 1;
   for (register int i = hd[u]; i; i = qwq[i].nxt) {
     int v = qwq[i].to;
     if (v == father) continue;
     first_dp(v, u);
     size[u] += size[v];
     f[u] += f[v];
   }
   f[u] += size[u];
   return;
 }
 inline void dp(int u, int father) {
   f[u] = 0;
   for (register int i = hd[u]; i; i = qwq[i].nxt) {
     int v = qwq[i].to;
     f[u] += f[v];
   }
   long long tot = f[u] + n;
   ans = max(ans, tot);
   for (register int i = hd[u]; i; i = qwq[i].nxt) {
     int v = qwq[i].to;
     if (v == father) continue;
     size[u] = n - size[v];
     f[u] = tot - f[v] - size[v];
     dp(v, u);
   }
 }
 int main() {
   read(n);
   for (register int i = 1, qa, qb; i < n; i++)
     read(qa), read(qb), addedg(qa, qb), addedg(qb, qa);
   first_dp(1, 0);
   ans = f[1];
   dp(1, 0);
   cout << ans;
   return 0;
 }


#include <bits/stdc++.h>
 using namespace std;
 const int M = 3000;
 int n, m;
 pair<pair<int, int>, int> v[M];
 map<pair<pair<int, int>, int>, vector<pair<pair<int, int>, int> > > Q;
 int gcd(int a, int b) { return !b ? a : gcd(b, a % b); }
 pair<pair<int, int>, int> get(int x1, int y1, int x2, int y2) {
   int x = x2 - x1, y = y2 - y1;
   if (x == 0)
     y = 1;
   else if (y == 0)
     x = 1;
   else {
     int d = gcd(x, y);
     x /= d, y /= d;
   }
   if (x < 0) x = -x, y = -y;
   return make_pair(make_pair(x, y), y1 * x - x1 * y);
 }
 int sign(double x) {
   if (fabs(x) < 1E-6) return 0;
   return (x > 0) ? 1 : -1;
 }
 double dist(int x1, int y1, int x2, int y2) {
   return sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2));
 }
 bool cmp(pair<pair<int, int>, int> a, pair<pair<int, int>, int> b) {
   if (a.first != b.first) return a.first < b.first;
   return a.second > b.second;
 }
 int main() {
   Q.clear();
   scanf( %d%d , &n, &m);
   for (int i = 0; i < (n); i++) {
     int x1, y1, x2, y2;
     scanf( %d%d%d%d , &x1, &y1, &x2, &y2);
     x1 *= 2, y1 *= 2, x2 *= 2, y2 *= 2;
     if (make_pair(x1, y1) > make_pair(x2, y2)) {
       swap(x1, x2);
       swap(y1, y2);
     }
     pair<pair<int, int>, int> tmp = get(x1, y1, x2, y2);
     Q[tmp].push_back(make_pair(make_pair(x1, y1), 1));
     Q[tmp].push_back(make_pair(make_pair(x2, y2), -1));
   }
   for (int i = 0; i < (m); i++) {
     scanf( %d%d%d , &v[i].first.first, &v[i].first.second, &v[i].second);
     for (int j = 0; j < (i); j++) {
       if (v[i].second != v[j].second) continue;
       int x1 = v[i].first.first, y1 = v[i].first.second, r = v[i].second;
       int x2 = v[j].first.first, y2 = v[j].first.second;
       if (sign(2 * r - dist(x1, y1, x2, y2)) >= 0) continue;
       int x0 = x1 + x2, y0 = y1 + y2;
       int x = x2 * 2 - x0, y = y2 * 2 - y0;
       pair<pair<int, int>, int> tmp = get(x0, y0, x0 - y, y0 + x);
       if (Q.find(tmp) == Q.end()) continue;
       Q[tmp].push_back(make_pair(make_pair(x0, y0), 0));
     }
   }
   int ret = 0;
   for (__typeof(Q.begin()) it = Q.begin(); it != Q.end(); it++) {
     sort(it->second.begin(), it->second.end(), cmp);
     int now = 0;
     for (__typeof(it->second.begin()) t = it->second.begin();
          t != it->second.end(); t++) {
       if (t->second == 0) ret += now;
       now += t->second;
     }
   }
   printf( %d
 , ret);
   return 0;
 }


#include <bits/stdc++.h>
 using namespace std;
 int mpow(int base, int exp);
 void solve() {
   long double n;
   cin >> n;
   long double sum = 0;
   while (n) {
     long double d;
     d = (1) * 1.0 / n;
     sum += d;
     n--;
   }
   cout << sum << '
';
 }
 int main() {
   ios_base::sync_with_stdio(false);
   cin.tie(NULL);
   cout.tie(NULL);
   ;
   solve();
   return 0;
 }
 int mpow(int base, int exp) {
   base %= 1000000007;
   int result = 1;
   while (exp > 0) {
     if (exp & 1) result = ((long long int)result * base) % 1000000007;
     base = ((long long int)base * base) % 1000000007;
     exp >>= 1;
   }
   return result;
 }


#include <bits/stdc++.h>
 using namespace std;
 long long unsigned int countDivisors(long long unsigned int n) {
   long long unsigned int cnt = 0;
   for (long long unsigned int i = 1; i <= sqrt(n); i++) {
     if (n % i == 0) {
       if (n / i == i)
         ++cnt;
       else
         cnt += 2;
     }
   }
   return cnt;
 }
 int Search(string pat, string txt) {
   int n = txt.size();
   int m = pat.size();
   for (int i = 0; i <= n - m; i++) {
     int j;
     for (j = 0; j < m; j++) {
       if (txt[i + j] != pat[j]) {
         break;
       }
     }
     if (j == m) {
       return i;
     }
   }
   return -1;
 }
 int findFirst(const std::vector<long long int> &array, int key, int low,
               int high) {
   int ans = -1;
   while (low <= high) {
     int mid = low + (high - low) / 2;
     if (key == array[mid]) {
       ans = mid;
       high = mid - 1;
     } else if (key > array[mid])
       low = mid + 1;
     else
       high = mid - 1;
   }
   return ans;
 }
 int findLast(const std::vector<long long int> &array, int key, int low,
              int high) {
   int ans = -1;
   while (low <= high) {
     int mid = low + (high - low) / 2;
     if (key == array[mid]) {
       ans = mid;
       low = mid + 1;
     } else if (key > array[mid])
       low = mid + 1;
     else
       high = mid - 1;
   }
   return ans;
 }
 int d, x, y;
 void extendedEuclid(int a, int b) {
   if (b == 0) {
     d = 1;
     x = 1;
     y = 0;
   } else {
     extendedEuclid(b, a % b);
     int temp = x;
     x = y;
     y = temp - (a / b) * y;
   }
 }
 int main() {
   std::ios::sync_with_stdio(false);
   cin.tie(NULL);
   cout.tie(NULL);
   ;
   int t;
   t = 1;
   for (int tc = 0; tc < t; tc++) {
     int n;
     cin >> n;
     vector<int> arr(n), brr(n, 0), v;
     for (int i1 = 0; i1 < n; i1++) cin >> arr[i1];
     int pos = 0;
     for (int i = 0; i < n; i++) {
       int indx = n - arr[i];
       brr[indx] = 1;
       while (brr[pos] == 1 && pos < n) {
         cout << (n - pos) <<    ;
         pos++;
       }
       cout << endl;
     }
   }
   return 0;
 }


#include <bits/stdc++.h>
 using namespace std;
 long long mp[1005][1005];
 long long n, a, b;
 void output() {
   for (long long i = 1; i <= n; i++) {
     for (long long j = 1; j <= n; j++) {
       if (i == j)
         printf( 0 );
       else
         printf( %lld , a < b ? !mp[i][j] : mp[i][j]);
     }
     printf(
 );
   }
 }
 int main() {
   scanf( %lld%lld%lld , &n, &a, &b);
   long long root = 2;
   if ((a != 1 && b != 1)) {
     printf( NO
 );
     return 0;
   }
   if (n == 2 && a == 1 && b == 1) {
     printf( NO
 );
     return 0;
   }
   if (n == 3 && a == 1 && b == 1) {
     printf( NO
 );
     return 0;
   }
   printf( YES
 );
   if (a == 1 && b == 1)
     for (long long i = 1; i < n; i++) mp[i][i + 1] = mp[i + 1][i] = true;
   else
     for (long long i = 0; i < n - max(a, b); i++, root++)
       mp[1][root] = mp[root][1] = true;
   output();
 }


#include <bits/stdc++.h>
 using namespace std;
 long long power(long long a, long long b) {
   long long ans = 1;
   while (b > 0) {
     if (b % 2 != 0) {
       ans = (ans * a) % 1000000007;
     }
     a = ((a % 1000000007) * (a % 1000000007)) % 1000000007;
     b >>= 1;
   }
   return ans;
 }
 void sieve(int n) {
   bool prime[n + 1];
   memset(prime, true, sizeof(prime));
   for (int p = 2; p * p <= n; p++) {
     if (prime[p]) {
       for (int i = p * p; i <= n; i += p) prime[i] = false;
     }
   }
   for (int p = 2; p <= n; p++) {
     if (prime[p]) cout << p <<    ;
   }
 }
 int main() {
   std::ios::sync_with_stdio(false);
   cin.tie(NULL);
   cout.tie(NULL);
   ;
   int t = 1;
   cin >> t;
   while (t--) {
     int n, k;
     cin >> n >> k;
     vector<vector<int>> v;
     for (int i = 0; i < k; i++) {
       int c;
       cin >> c;
       vector<int> temp;
       for (int j = 0; j < c; j++) {
         int z;
         cin >> z;
         temp.push_back(z);
       }
       v.push_back(temp);
     }
     int l = 1, h = n;
     int ma;
     cout <<  ?
          <<     << n <<    ;
     for (int i = 1; i <= n; i++) cout << i <<    ;
     cout << endl;
     cin >> ma;
     for (int i = 0; i < 10; i++) {
       int mid = (h + l) / 2;
       int temp;
       cout <<  ?
            <<     << mid - l + 1 <<    ;
       for (int kha = l; kha <= mid; kha++) cout << kha <<    ;
       cout << endl;
       cin >> temp;
       if (temp == ma)
         h = mid;
       else
         l = mid;
     }
     int ind = h;
     bool flag = false;
     vector<int> ans;
     for (int i = 0; i < v.size(); i++) {
       sort(v[i].begin(), v[i].end());
       for (int j = 0; j < v[i].size(); j++) {
         if (v[i][j] == ind) {
           flag = true;
           cout <<  ?
                <<    ;
           vector<int> loa;
           for (int lo = 1; lo <= n; lo++) {
             if (binary_search(v[i].begin(), v[i].end(), lo) == false) {
               loa.push_back(lo);
             }
           }
           cout << loa.size() <<    ;
           for (auto lo : loa) cout << lo <<    ;
           cout << endl;
           int kha;
           cin >> kha;
           ans.push_back(kha);
         }
       }
       if (flag == false) {
         ans.push_back(ma);
       } else {
         flag = false;
       }
     }
     cout <<  !
          <<    ;
     for (auto i : ans) cout << i <<    ;
     cout << endl;
     string sa;
     cin >> sa;
     if (sa ==  Correct ) {
       continue;
     } else {
       return 0;
     }
   }
   return 0;
 }


#include <bits/stdc++.h>
 using namespace std;
 const long long INF = 1e18;
 const int maxn = 2e6 + 10;
 int a[maxn], cnt[maxn];
 long long sum[maxn];
 int main(void) {
   int n, x, y;
   scanf( %d %d %d , &n, &x, &y);
   int z = x / y;
   for (int i = 1; i <= n; i++)
     scanf( %d , a + i), cnt[a[i]]++, sum[a[i]] += a[i];
   for (int i = 1; i <= 2000000; i++) cnt[i] += cnt[i - 1], sum[i] += sum[i - 1];
   long long ans = INF;
   for (int i = 2; i <= 1000000; i++) {
     long long tmp = 0;
     int zz = min(z, i - 1);
     for (int j = 1; (j - 1) * i < 1000000; j++) {
       if (i - zz - 2 >= 0)
         tmp += (long long)(cnt[j * i - zz - 1] - cnt[j * i - i]) * x;
       if (zz)
         tmp += ((long long)i * j * (cnt[j * i - 1] - cnt[j * i - zz - 1]) -
                 (sum[j * i - 1] - sum[j * i - zz - 1])) *
                y;
     }
     ans = min(ans, tmp);
   }
   printf( extra
 , ans);
   return 0;
 }


#include <bits/stdc++.h>
 using namespace std;
 long long k, b, n, t;
 int main() {
   ios_base ::sync_with_stdio(0);
   cin.tie(0);
   cin >> k >> b >> n >> t;
   long long num = 1;
   long long step = n;
   while (t >= num) {
     num = num * k + b;
     step--;
   }
   if (step < 0) {
     cout << 0;
     return 0;
   }
   cout << step + 1;
   return 0;
 }


#include <bits/stdc++.h>
 const long double pi = 3.14159265359;
 const long long N = 1e9 + 7;
 using namespace std;
 int main() {
   ios_base::sync_with_stdio(0);
   cin.tie(0);
   cout.tie(0);
   long long n, m, arr[200005];
   cin >> n >> m;
   long long cntne = 0, cntpo = 0;
   for (int i = 0; i < n; i++) {
     cin >> arr[i];
     if (arr[i] == -1)
       cntne++;
     else
       cntpo++;
   }
   vector<long long> v;
   for (int i = 0; i < m; i++) {
     long long l, r;
     cin >> l >> r;
     r++;
     long long ans = abs(l - r);
     if ((ans % 2 == 0) && (cntne >= ans / 2) && (cntpo >= ans / 2))
       v.push_back(1);
     else
       v.push_back(0);
   }
   for (int i = 0; i < ((long long)((v).size())); i++) cout << v[i] << endl;
   return 0;
 }


#include <iostream>
 #include <vector>
 #include <algorithm>
 #include <string>

 #define ll long long

 using namespace std;

 int main() {
     ll qua;
     cin >> qua;
     for (int i = 0; i < qua; ++i) {
         ll n;
         cin >> n;
         vector<int> vec(n);
         for (int j = 0; j < n; ++j) {
             cin >> vec[j];
         }
         cout << 0 << ' ';
         for (int j = 1; j < n; ++j) {
             ll r = (vec[j] | vec[j - 1]) - vec[j];
             cout << r << ' ';
             vec[j] += r;
         }
         cout << '
';
     }
     return 0;
 }


#include <bits/stdc++.h>
 using namespace std;
 const int MaxN = 100005;
 const int MaxM = MaxN * 2;
 const int oo = 0x3F3F3F3F;
 int ax[MaxM], K;
 int ret[MaxN];
 set<pair<int, int> > tr[MaxM];
 struct event {
   int l, r, v, tp;
   event() {}
   event(int l, int r, int v, int tp) : l(l), r(r), v(v), tp(tp) {}
   bool operator<(const event& e) const {
     if (r != e.r)
       return r > e.r;
     else
       return tp < e.tp;
   }
 } e[MaxM];
 int getId(int v) { return lower_bound(ax, ax + K, v) - ax + 1; }
 void add(int k, pair<int, int> v) {
   while (k <= K) {
     tr[k].insert(v);
     k += k & -k;
   }
 }
 int read(int k, int v) {
   pair<int, int> ret = make_pair(oo, -1);
   while (k) {
     set<pair<int, int> >::iterator it = tr[k].lower_bound(make_pair(v, 0));
     if (it != tr[k].end()) ret = min(ret, *it);
     k -= k & -k;
   }
   return ret.second;
 }
 int main() {
   int N, M, en;
   int l, r, t;
   scanf( %d%d , &N, &M);
   K = en = 0;
   for (int i = 0; i < N; i++) {
     scanf( %d%d%d , &l, &r, &t);
     e[en++] = event(l, r, t, -i - 1);
     ax[K++] = l;
   }
   for (int i = 0; i < M; i++) {
     scanf( %d%d%d , &l, &r, &t);
     e[en++] = event(l, r, t, i);
     ax[K++] = l;
   }
   sort(ax, ax + K);
   K = unique(ax, ax + K) - ax;
   sort(e, e + en);
   for (int i = 0; i < en; i++) {
     if (e[i].tp < 0) {
       add(getId(e[i].l), make_pair(e[i].v, -e[i].tp));
     } else {
       ret[e[i].tp] = read(getId(e[i].l), e[i].v);
     }
   }
   for (int i = 0; i < M; i++) {
     printf( %d  , ret[i]);
   }
   puts(  );
   return 0;
 }


#include <bits/stdc++.h>
 using namespace std;
 template <typename T, typename U>
 std::istream& operator>>(std::istream& i, pair<T, U>& p) {
   i >> p.first >> p.second;
   return i;
 }
 template <typename T>
 std::istream& operator>>(std::istream& i, vector<T>& t) {
   for (auto& v : t) {
     i >> v;
   }
   return i;
 }
 template <typename T, typename U>
 std::ostream& operator<<(std::ostream& o, const pair<T, U>& p) {
   o << p.first << ' ' << p.second;
   return o;
 }
 template <typename T>
 std::ostream& operator<<(std::ostream& o, const vector<T>& t) {
   if (t.empty()) o << '
';
   for (size_t i = 0; i < t.size(); ++i) {
     o << t[i] <<
 [i == t.size() - 1];
   }
   return o;
 }
 template <typename T>
 using minheap = priority_queue<T, vector<T>, greater<T>>;
 template <typename T>
 using maxheap = priority_queue<T, vector<T>, less<T>>;
 unsigned int logceil(long long first) {
   return first ? 8 * sizeof(long long) - __builtin_clzll(first) : 0;
 }
 namespace std {
 template <typename T, typename U>
 struct hash<pair<T, U>> {
   hash<T> t;
   hash<U> u;
   size_t operator()(const pair<T, U>& p) const {
     return t(p.first) ^ (u(p.second) << 7);
   }
 };
 }  // namespace std
 template <typename T, typename F>
 T bsh(T l, T h, const F& f) {
   T r = -1, m;
   while (l <= h) {
     m = (l + h) / 2;
     if (f(m)) {
       l = m + 1;
       r = m;
     } else {
       h = m - 1;
     }
   }
   return r;
 }
 template <typename F>
 double bshd(double l, double h, const F& f, double p = 1e-9) {
   unsigned int r = 3 + (unsigned int)log2((h - l) / p);
   while (r--) {
     double m = (l + h) / 2;
     if (f(m)) {
       l = m;
     } else {
       h = m;
     }
   }
   return (l + h) / 2;
 }
 template <typename T, typename F>
 T bsl(T l, T h, const F& f) {
   T r = -1, m;
   while (l <= h) {
     m = (l + h) / 2;
     if (f(m)) {
       h = m - 1;
       r = m;
     } else {
       l = m + 1;
     }
   }
   return r;
 }
 template <typename F>
 double bsld(double l, double h, const F& f) {
   unsigned int r = 200;
   while (r--) {
     double m = (l + h) / 2;
     if (f(m)) {
       h = m;
     } else {
       l = m;
     }
   }
   return (l + h) / 2;
 }
 template <typename T>
 T gcd(T a, T b) {
   if (a < b) swap(a, b);
   return b ? gcd(b, a % b) : a;
 }
 template <typename T>
 class vector2 : public vector<vector<T>> {
  public:
   vector2() {}
   vector2(size_t a, size_t b, T t = T())
       : vector<vector<T>>(a, vector<T>(b, t)) {}
 };
 template <typename T>
 class vector3 : public vector<vector2<T>> {
  public:
   vector3() {}
   vector3(size_t a, size_t b, size_t c, T t = T())
       : vector<vector2<T>>(a, vector2<T>(b, c, t)) {}
 };
 template <typename T>
 class vector4 : public vector<vector3<T>> {
  public:
   vector4() {}
   vector4(size_t a, size_t b, size_t c, size_t d, T t = T())
       : vector<vector3<T>>(a, vector3<T>(b, c, d, t)) {}
 };
 template <typename T>
 class vector5 : public vector<vector4<T>> {
  public:
   vector5() {}
   vector5(size_t a, size_t b, size_t c, size_t d, size_t e, T t = T())
       : vector<vector4<T>>(a, vector4<T>(b, c, d, e, t)) {}
 };
 class GOmkarAndPies {
  public:
   vector<std::pair<int, int>> D;
   int N, M, K;
   void fix(int p) {
     for (int i = 0; i < K; ++i) {
       int s = p ^ 1 << i;
       if (D[s].first > D[p].first + 1) {
         D[s] = {D[p].first + 1, D[p].second};
         fix(s);
       }
     }
   };
   void solve(istream& cin, ostream& cout) {
     cin >> N >> M >> K;
     string S, T;
     cin >> S >> T;
     vector<std::pair<int, int>> P(N);
     cin >> P;
     for (std::pair<int, int>& p : P) {
       p.first--;
       p.second--;
     }
     vector<int> X(K);
     iota(X.begin(), X.end(), 0);
     vector<vector<int>> W{X};
     for (int i = 0; i < N; ++i) {
       swap(X[P[i].first], X[P[i].second]);
       vector<int> I(K);
       for (int j = 0; j < K; ++j) I[X[j]] = j;
       W.push_back(X);
     }
     auto apply = [&](int first, string S) {
       int p = 0;
       for (int i = 0; i < K; ++i) {
         p |= (S[i] - '0') << W[first][i];
       }
       return p;
     };
     D.assign(1 << K, {K + 1, -1});
     pair<int, std::pair<int, int>> ans{K + 1, {-1, -1}};
     for (int i = N - M; i >= 0; --i) {
       int TX = apply(i + M, T);
       D[TX] = {0, i + M};
       fix(TX);
       int SX = apply(i, S);
       ans = min(ans, {D[SX].first, {i + 1, D[SX].second}});
     }
     cout << K - ans.first << '
' << ans.second << '
';
   }
 };
 int main() {
   ios_base::sync_with_stdio(false);
   cin.tie(nullptr);
   cout.tie(nullptr);
   GOmkarAndPies solver;
   std::istream& in(std::cin);
   std::ostream& out(std::cout);
   solver.solve(in, out);
   return 0;
 }


#include <bits/stdc++.h>
 using namespace std;
 int main() {
   string s;
   cin >> s;
   cout << (regex_match(s, regex( (1|14|144)* )) ?  YES  :  NO );
 }


#include <bits/stdc++.h>
 using namespace std;
 const int N = 3e3 + 5;
 int dw[N], up[N], E[N][2], Mn;
 vector<pair<int, int> > g[N];
 void dfs_down(int v, int p) {
   dw[v] = 0;
   for (pair<int, int> u : g[v])
     if (u.first != p) dfs_down(u.first, v), dw[v] += dw[u.first] + u.second;
 }
 void dfs_up(int v, int p, int f = -1) {
   if (f != -1) {
     up[v] = up[p] + dw[p] - dw[v] + f - (f == 0);
   } else
     up[v] = 0;
   Mn = min(Mn, dw[v] + up[v]);
   for (pair<int, int> u : g[v])
     if (u.first != p) dfs_up(u.first, v, u.second ^ 1);
 }
 int main() {
   ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
   int n;
   cin >> n;
   if (n == 1) return cout <<  0
 , 0;
   for (int i = 0; i < n - 1; i++) {
     cin >> E[i][0] >> E[i][1];
     g[E[i][0]].push_back({E[i][1], 0});
     g[E[i][1]].push_back({E[i][0], 1});
   }
   int ans = n;
   for (int i = 0; i < n - 1; i++) {
     Mn = n, dfs_down(E[i][0], E[i][1]), dfs_up(E[i][0], E[i][1]);
     int cur = Mn;
     Mn = n, dfs_down(E[i][1], E[i][0]), dfs_up(E[i][1], E[i][0]);
     cur += Mn;
     ans = min(ans, cur);
   }
   cout << ans <<
 ;
 }


#include <bits/stdc++.h>
 using namespace std;
 int main() {
   int n;
   cin >> n;
   cout << ceil(n / 2.0) - 1;
 }


#include <bits/stdc++.h>
 using namespace std;
 const int N = 2e5 + 10;
 int y[N], pos[N];
 int main() {
   int n, m, t = 0, ans = 0, cnt = 0;
   scanf( %d %d , &n, &m);
   for (int i = 1; i <= n; i++) scanf( %d , &y[i]);
   for (int i = 1; i <= m; i++) {
     int y1, y2, x;
     scanf( %d %d %d , &y1, &y2, &x);
     if (y1 == 1) {
       pos[++t] = y2;
     }
     if (y2 == 1e9) {
       ans++;
     }
   }
   sort(y + 1, y + 1 + n);
   sort(pos + 1, pos + 1 + t);
   int i = 1, j = 1;
   cnt = t, ans += n;
   while (i <= n) {
     while (j <= t) {
       if (pos[j] < y[i]) {
         j++, cnt--;
       } else
         break;
     }
     ans = min(ans, cnt + i - 1);
     i++;
   }
   cout << ans;
 }


#include <bits/stdc++.h>
 using namespace std;
 inline int read() {
   int x = 0, f = 1;
   char c = getchar();
   while (c < '0' || c > '9') {
     if (c == '-') f = -1;
     c = getchar();
   }
   while (c >= '0' && c <= '9')
     x = (x << 3) + (x << 1) + (c ^ '0'), c = getchar();
   return x * f;
 }
 const int N = 505, mod = 1e9 + 7;
 inline int inc(int x, int y) {
   x += y - mod;
   return x + (x >> 31 & mod);
 }
 inline int mul(int x, int y) { return 1ll * x * y % mod; }
 inline void Inc(int &x, int y) { x = inc(x, y); }
 int n, a[N], f[N][N];
 int main() {
   n = read();
   for (int i = 1; i <= n; i++) a[i] = read(), f[i][i] = 1;
   for (int i = 1; i <= n + 1; i++) f[i][i - 1] = 1;
   for (int len = 2; len < n; len++)
     for (int l = 1; l <= n - len + 1; l++) {
       int r = l + len - 1;
       f[l][r] = f[l + 1][r];
       for (int k = l + 1; k <= r; k++)
         if (a[k] > a[l]) Inc(f[l][r], mul(f[l + 1][k - 1], f[k][r]));
     }
   printf( %d
 , f[2][n]);
   return 0;
 }


#include <bits/stdc++.h>
 using namespace std;
 const int MAXN = 2001;
 char a[MAXN][MAXN];
 int n, v[MAXN], r[MAXN], c[MAXN];
 int gao() {
   int ret = 0;
   memset(r, 0, sizeof(int) * n);
   memset(c, 0, sizeof(int) * n);
   for (int i = 0; i < n - 1; ++i) {
     for (int j = n - 1; j > i; --j) {
       if (a[i][j] ^ r[i] ^ c[j]) {
         ++ret;
         r[i] ^= 1;
         c[j] ^= 1;
       }
     }
   }
   for (int i = 0; i < n; ++i) v[i] ^= (r[i] ^ c[i]);
   memset(r, 0, sizeof(int) * n);
   memset(c, 0, sizeof(int) * n);
   for (int i = n - 1; i > 0; --i) {
     for (int j = 0; j < i; ++j) {
       if (a[i][j] ^ r[i] ^ c[j]) {
         ++ret;
         r[i] ^= 1;
         c[j] ^= 1;
       }
     }
   }
   for (int i = 0; i < n; ++i) v[i] ^= (r[i] ^ c[i]);
   for (int i = 0; i < n; ++i) ret += v[i];
   return ret;
 }
 int main() {
   while (scanf( %d , &n) != EOF) {
     memset(v, 0, sizeof(int) * n);
     for (int i = 0; i < n; ++i) {
       scanf( %s , a[i]);
       for (int j = 0; j < n; ++j) a[i][j] -= '0';
       v[i] ^= (int)a[i][i];
     }
     printf( %d
 , gao());
   }
   return 0;
 }


#include<bits/stdc++.h>
 using namespace std;
 typedef double db;
 typedef uint32_t u32;
 typedef uint64_t u64;
 typedef pair<int, int> pii;
 typedef pair<int, int> point;
 #define fi first
 #define se second
 #define pb(x) push_back(x)
 #define SZ(x) ((int) (x).size())
 #define all(x) (x).begin(), (x).end()
 #define rep(i, l, r) for(int i = l; i < r; i++)
 typedef long long ll;
 const int mod = 998244353;

 int main() {
 #ifdef local
 	freopen( in.txt ,  r , stdin);
 #endif
 	ios::sync_with_stdio(false);
 	cin.tie(0), cout.tie(0);
 	const int mod = 1e9 + 7;
 	int n;
 	cin >> n;
 	vector<int> a(n);
 	ll tot = 0;
 	for(auto &e : a) {
 		cin >> e;
 		tot += e;
 	}
 	if(tot % n) {
 		cout <<  0
 ;
 		return 0;
 	}
 	vector<int> fac(n + 1, 1);
 	vector<int> ifac(n + 1, 1);
 	for(int i = 2; i <= n; i++) {
 		fac[i] = (ll) fac[i - 1] * i % mod;
 		ifac[i] = (ll) ifac[mod % i] * (mod - mod / i) % mod;
 	}
 	for(int i = 2; i <= n; i++) {
 		ifac[i] = (ll) ifac[i] * ifac[i - 1] % mod;
 	}
 	auto C = [&](int n, int m) {
 		if(n < m || m < 0) return 0ll;
 		return (ll) fac[n] * ifac[m] % mod * ifac[n - m] % mod;
 	};
 	ll avg = tot / n;
 	vector<int> l, r;
 	int eq = 0;
 	for(auto &e : a) {
 		if(e > avg) {
 			r.push_back(e);
 		} else if(e < avg) {
 			l.push_back(e);
 		} else {
 			eq++;
 		}
 	}
 	int ans = 1;
 	if(l.size() > 1 && r.size() > 1) {
 		ans = 2;
 	}
 	if(l.size() == 1) {
 		r.push_back(l[0]);
 		l.clear();
 	}
 	if(r.size() == 1) {
 		l.push_back(r[0]);
 		r.clear();
 	}
 	sort(all(l));
 	sort(all(r));
 	int a1 = fac[l.size()];
 	int a2 = fac[r.size()];
 	for(int i = 0, j = 0; i < (int) l.size(); i = j) {
 		while(j < (int) l.size() && l[j] == l[i]) {
 			j++;
 		}
 		a1 = (ll) a1 * ifac[j - i] % mod;
 	}
 	for(int i = 0, j = 0; i < (int) r.size(); i = j) {
 		while(j < (int) r.size() && r[j] == r[i]) {
 			j++;
 		}
 		a2 = (ll) a2 * ifac[j - i] % mod;
 	}
 	int a3 = C(n, eq);
 	ans = (ll) ans * a1 % mod;
 	ans = (ll) ans * a2 % mod;
 	ans = (ll) ans * a3 % mod;
 	cout << ans << '
';
 	return 0;
 }


#include <bits/stdc++.h>
 using namespace std;
 int main(void) {
   int n;
   cin >> n;
   set<int> a, b;
   vector<pair<int, int> > ans(n);
   for (int i = 0; i < n; ++i) {
     cin >> ans[i].first >> ans[i].second;
     --ans[i].first;
     --ans[i].second;
     if (ans[i].first == -1) a.insert(i);
     if (ans[i].second == -1) b.insert(i);
   }
   while (a.size() > 1) {
     int node = *a.begin();
     a.erase(a.begin());
     int last = node;
     while (ans[last].second != -1) last = ans[last].second;
     auto nxt = b.begin();
     if (*nxt == last) ++nxt;
     ans[*nxt].second = node;
     ans[node].first = *nxt;
     b.erase(nxt);
   }
   for (int i = 0; i < n; ++i)
     cout << ans[i].first + 1 << ' ' << ans[i].second + 1 << '
';
   return 0;
 }


#include <bits/stdc++.h>
 using namespace std;
 int main() {
   int n;
   cin >> n;
   int a[n], sm = 0;
   for (int i = 0; i < n; i++) {
     cin >> a[i];
     sm += a[i];
   }
   vector<int> ind, r;
   int need = sm / 2;
   if (a[0] > need) {
     cout << 1 << endl;
     cout << 1;
     return 0;
   }
   for (int i = 1; i < n; i++) {
     if ((2 * a[i]) <= a[0]) {
       ind.push_back(i + 1);
       r.push_back(a[i]);
     }
   }
   bool ok;
   int u = a[0];
   for (auto x : r) {
     u += x;
   }
   if (u > need) {
     ok = true;
   } else {
     ok = false;
   }
   if (ok) {
     cout << ind.size() + 1 << endl;
     cout << 1 <<    ;
     for (auto x : ind) {
       cout << x <<    ;
     }
   } else {
     cout << 0;
   }
 }


#include <bits/stdc++.h>
 using namespace std;
 int nbVoyages, coutSimple, coutLiaison, maxCartes, coutCarte;
 map<pair<string, string>, int> routes;
 int main() {
   ios_base::sync_with_stdio(false);
   cin >> nbVoyages >> coutSimple >> coutLiaison >> maxCartes >> coutCarte;
   long long total = 0;
   string derFin =   ;
   for (int iVoyage = 0; iVoyage < nbVoyages; iVoyage++) {
     string a, b;
     cin >> a >> b;
     string der = b, pre = a;
     if (b < a) swap(a, b);
     if (routes.find({a, b}) == routes.end()) routes[{a, b}] = 0;
     if (derFin == pre) {
       routes[{a, b}] += coutLiaison;
       total += coutLiaison;
     } else {
       routes[{a, b}] += coutSimple;
       total += coutSimple;
     }
     derFin = der;
   }
   vector<int> couts;
   for (pair<pair<string, string>, int> route : routes) {
     couts.push_back(route.second);
   }
   sort(couts.begin(), couts.end());
   for (int iFois = 0; iFois < maxCartes; iFois++) {
     if (!couts.empty() && couts.back() > coutCarte) {
       total += coutCarte - couts.back();
       couts.pop_back();
     }
   }
   cout << total << endl;
   return 0;
 }


#include <bits/stdc++.h>
 using namespace std;
 const int inf = 0x3f3f3f3f;
 const double eps = 1e-6;
 const int mod = 1000000007;
 int modpow(int x, int y, int md) {
   if (y == 0) return 1;
   int ret = modpow(x, y >> 1, md);
   ret = (long long)ret * ret % md;
   if (y & 1) ret = (long long)ret * x % md;
   return ret;
 }
 int n;
 int sum[5555];
 vector<int> g[5555];
 set<pair<int, int> > ans;
 void dfs(int x, int par = 0) {
   sum[x] = 1;
   for (auto to : g[x])
     if (to != par) dfs(to, x);
   for (auto to : g[x])
     if (to != par) sum[x] += sum[to];
   vector<bool> ok(5555, false);
   ok[0] = true;
   for (auto to : g[x])
     if (to != par) {
       for (int i = 5005; i >= 0; i--)
         if (ok[i] && i + sum[to] <= 5005) ok[i + sum[to]] = true;
     }
   for (int i = 1; i <= 5005; i++)
     if (ok[i] && n - i - 1 >= 1)
       ans.insert(make_pair(i, n - i - 1)), ans.insert(make_pair(n - i - 1, i));
 }
 int main() {
   cin >> n;
   for (int i = 1; i < n; i++) {
     int a, b;
     cin >> a >> b;
     g[a].push_back(b);
     g[b].push_back(a);
   }
   dfs(1);
   cout << ans.size() << endl;
   for (auto p : ans) cout << p.first <<     << p.second << endl;
   return 0;
 }


#include <bits/stdc++.h>
 using namespace std;
 string s[3];
 int N, M, p[3][1000005], a[3][1000005], b[1000005];
 void genPrefix(int pat) {
   int i, k;
   p[pat][0] = 0;
   k = 0;
   i = 1;
   while (i < M) {
     if (s[pat][i] == s[pat][k]) {
       k++;
       p[pat][i] = k;
       i++;
     } else {
       if (k != 0)
         k = p[pat][k - 1];
       else {
         p[pat][i] = 0;
         i++;
       }
     }
   }
 }
 void KMPSearch(int txt, int pat) {
   int i, k;
   genPrefix(pat);
   i = k = 0;
   while (i < N) {
     if (s[txt][i] == s[pat][k]) {
       i++;
       k++;
       a[txt][i - k] = i - 1;
     }
     if (k == M) {
       k = p[pat][k - 1];
     } else if (i < N && s[txt][i] != s[pat][k]) {
       if (k != 0) {
         if (s[txt][i - 1] == s[pat][k])
           a[txt][i - k] = max(i - 1, a[txt][k - 1]);
         k = p[pat][k - 1];
         if (k > 0 && s[txt][i - 1] == s[pat][k])
           a[txt][i - k] = max(i - 1, a[txt][k - 1]);
       } else
         i++;
     }
   }
 }
 int bs(int low, int high, int v) {
   int mid, x = -1;
   while (low <= high) {
     mid = (low + high) >> 1;
     if (b[mid] >= v) {
       x = mid;
       high = mid - 1;
     } else
       low = mid + 1;
   }
   return x;
 }
 pair<int, int> solve() {
   s[2] = s[0];
   reverse(s[2].begin(), s[2].end());
   memset(a, -1, sizeof(a));
   KMPSearch(1, 2);
   KMPSearch(0, 1);
   b[0] = a[1][0];
   int i, j = N, len, k, x;
   int ansx = -1, ansy = -1;
   for (i = 1; i <= N - 1; i++) b[i] = max(b[i - 1], a[1][i]);
   for (i = 0; i <= N - 2; i++) {
     j--;
     if (s[0][i] != s[1][j]) break;
     if (b[0] >= j - 1) {
       ansx = i;
       ansy = i + 1;
     }
     if (a[0][i + 1] <= 0 || i + 1 == N - 1) continue;
     len = min(N - 2, a[0][i + 1]) - i;
     k = bs(0, len, j - 1);
     if (k >= 0 && ansx < i) {
       ansx = i;
       ansy = i + 1 + k;
     }
   }
   return make_pair(ansx, ansy);
 }
 int main() {
   std::ios_base::sync_with_stdio(0);
   int cases, caseno = 0, n, i, j, k, cnt, m;
   getline(cin, s[0]);
   getline(cin, s[1]);
   N = s[0].size();
   M = s[1].size();
   if (N != M) {
     cout <<  -1 -1  << '
';
     return 0;
   }
   pair<int, int> ans = solve();
   cout << ans.first <<     << ans.second << '
';
   return 0;
 }


#include <bits/stdc++.h>
 using namespace std;
 int main() {
   int n, x;
   scanf( %d%d , &n, &x);
   if (n == 1) {
     printf( YES
 );
     printf( %d
 , x);
   } else if (n == 2) {
     if (x == 0)
       printf( NO
 );
     else {
       printf( YES
 );
       printf( 0 %d
 , x);
     }
   } else {
     printf( YES
 );
     int tmp = 0;
     int a = (1 << 17);
     int b = (1 << 18);
     for (int i = 0; i < n - 3; i++) {
       printf( %d  , i);
       tmp ^= i;
     }
     printf( %d %d %d
 , a, b, a ^ b ^ tmp ^ x);
   }
   return 0;
 }


#include <bits/stdc++.h>
 using namespace std;
 bool psort(std::vector<long long int> p1, std::vector<long long int> p2) {
   return p1[0] < p2[0];
 }
 int main() {
   ios_base::sync_with_stdio(false);
   cin.tie(NULL);
   cout.tie(NULL);
   long long int n, m;
   cin >> n;
   std::vector<vector<long long int> > v(n, vector<long long int>(3));
   for (int i = 0; i < n; ++i) {
     cin >> v[i][0];
   }
   for (int i = 0; i < n; ++i) {
     cin >> v[i][1];
   }
   for (int i = 0; i < n; ++i) {
     cin >> v[i][2];
   }
   sort(v.begin(), v.end(), psort);
   cin >> m;
   long long int start[4] = {0};
   for (int i = 0; i < m; ++i) {
     long long int k, t, flag = 0;
     cin >> t;
     while (start[t] < n) {
       if (v[start[t]][0] != -1) {
         if (v[start[t]][1] == t || v[start[t]][2] == t) {
           cout << v[start[t]][0] <<    ;
           v[start[t]][0] = -1;
           start[t]++;
           flag = 1;
           break;
         }
       }
       start[t]++;
     }
     if (flag == 0) cout << -1 <<    ;
   }
   return 0;
 }


#include <bits/stdc++.h>
 using namespace std;
 int main() {
   int n;
   cin >> n;
   string fld;
   cin >> fld;
   int l = 1, r = 2 * n;
   int ans = -1;
   while (l <= r) {
     int mid = (l + r) >> 1;
     int posbl = 1;
     int back = -1, flag = 0;
     for (int i = 0; i < n; i++) {
       if (fld[i] == '*')
         if (i > back && flag == 0) back = i, flag = 1;
       if (fld[i] == 'P') {
         if (back == -1) {
           back = i + mid;
         } else {
           if (i <= back) {
             back = max(back, i + mid);
           } else {
             if (flag == 1) {
               if (i - back > mid) {
                 posbl = 0;
                 break;
               } else if (i - back <= mid && mid <= (2 * (i - back)))
                 back = max(i, (mid - (i - back)) / 2 + i);
               else {
                 back =
                     max(mid - (2 * (i - back)) + i, (mid - (i - back)) / 2 + i);
               }
             } else {
               back = i + mid;
             }
           }
         }
         flag = 0;
       }
     }
     if (flag == 1) posbl = 0;
     if (posbl == 1) {
       r = mid - 1;
       ans = mid;
     } else
       l = mid + 1;
   }
   cout << ans <<
 ;
   return 0;
 }


#include <bits/stdc++.h>
 using namespace std;
 const int N = 2e5 + 10;
 char s[N];
 char t1[7] =  twone ;
 char t2[4] =  one ;
 char t3[4] =  two ;
 int main() {
   int T;
   scanf( %d , &T);
   while (T--) {
     scanf( %s , s);
     int ans = 0;
     int len = strlen(s);
     for (int i = 0; i < len; i++) {
       if (s[i] == 't') {
         int f = 0;
         for (int j = i; j <= i + 4; j++) {
           if (s[j] != t1[j - i]) {
             f = 1;
             break;
           }
         }
         if (f == 0) {
           s[i + 2] = '-';
           ans++;
         }
       }
     }
     for (int i = 0; i < len; i++) {
       if (s[i] == 't') {
         int f = 0;
         for (int j = i; j <= i + 2; j++) {
           if (s[j] != t3[j - i]) {
             f = 1;
             break;
           }
         }
         if (f == 0) {
           s[i + 1] = '-';
           ans++;
         }
       }
     }
     for (int i = 0; i < len; i++) {
       if (s[i] == 'o') {
         int f = 0;
         for (int j = i; j <= i + 2; j++) {
           if (s[j] != t2[j - i]) {
             f = 1;
             break;
           }
         }
         if (f == 0) {
           s[i + 1] = '-';
           ans++;
         }
       }
     }
     printf( %d
 , ans);
     for (int i = 0; i < len; i++)
       if (s[i] == '-') printf( %d  , i + 1);
     printf(
 );
   }
   return 0;
 }


#include <bits/stdc++.h>
 using namespace std;
 int main() {
   ios_base::sync_with_stdio(0);
   long long int n, m = 0, p = 0, cnt = 0, f = 0;
   cin >> n;
   long long int a[n];
   for (long long int i = 0; i < n; i++) {
     cin >> a[i];
     if (a[i] < 0) {
       m++;
     }
     if (a[i] > 0) p++;
     if (a[i] < 0) {
       cnt = cnt - a[i] - 1;
     }
     if (a[i] > 0) {
       cnt = cnt + a[i] - 1;
     }
     if (a[i] == 0) {
       cnt = cnt + 1;
       f++;
     }
   }
   if (f and m % 2 == 0) cout << cnt << endl;
   if (f and m % 2 != 0) cout << cnt << endl;
   if (!f and m % 2 == 0) cout << cnt << endl;
   if (!f and m % 2 != 0) cout << cnt + 2 << endl;
 }


#include <bits/stdc++.h>
 using namespace std;
 int n, m;
 int A[600006];
 vector<int> G[600006];
 int dfn[600006], bc[600006], clo;
 int g[600006][20], dep[600006];
 void dfs(int u) {
   dfn[u] = ++clo, bc[clo] = u;
   if (u == 1) dep[u] = 1;
   for (int v : G[u]) {
     g[v][0] = u;
     dep[v] = dep[u] + 1;
     for (int k = (1), kend = (18); k <= kend; ++k)
       if (g[g[v][k - 1]][k - 1])
         g[v][k] = g[g[v][k - 1]][k - 1];
       else
         break;
     dfs(v);
   }
 }
 int lca(int u, int v) {
   if (dep[u] < dep[v]) swap(u, v);
   if (dep[u] != dep[v])
     for (int k = (18), kend = (0); k >= kend; --k)
       if (dep[g[u][k]] >= dep[v]) u = g[u][k];
   if (u == v) return u;
   for (int k = (18), kend = (0); k >= kend; --k)
     if (g[u][k] != g[v][k]) u = g[u][k], v = g[v][k];
   return g[u][0];
 }
 int dis(int u, int v) { return dep[u] + dep[v] - 2 * dep[lca(u, v)]; }
 set<int> S;
 void solve() {
   cin >> n;
   ++n;
   for (int i = (2), iend = (n); i <= iend; ++i) {
     int p;
     scanf( %d , &p);
     G[p].push_back(i);
   }
   dfs(1);
   int s = 1, t = 1, lt = 0;
   auto wkr = [&](int x) { return max(dis(x, s), dis(x, t)); };
   S.insert(1);
   for (int i = (2), iend = (n); i <= iend; ++i) {
     int is = dis(i, s), it = dis(i, t), flg = 0;
     if (is >= lt && is >= it)
       t = i, lt = is, flg = 1;
     else if (it >= lt && it >= is)
       s = i, lt = it, flg = 1;
     if (!flg) {
       printf( %d
 , (int)S.size());
       continue;
     }
     auto tr = S.lower_bound(dfn[i]), st = tr;
     while (tr != S.end()) {
       if (wkr(bc[*tr]) < lt)
         ++tr;
       else
         break;
     }
     if (tr == S.end()) {
       auto sr = S.begin();
       while (sr != st) {
         if (wkr(bc[*sr]) < lt)
           ++sr;
         else
           break;
       }
       S.erase(S.begin(), sr);
     }
     S.erase(st, tr);
     tr = S.lower_bound(dfn[i]), st = tr;
     while (tr != S.begin()) {
       --tr;
       if (wkr(bc[*tr]) >= lt) {
         ++tr;
         break;
       }
     }
     if (tr == S.begin()) {
       auto sr = S.end();
       while (sr != st) {
         --sr;
         if (wkr(bc[*sr]) >= lt) {
           ++sr;
           break;
         }
       }
       S.erase(sr, S.end());
     }
     S.erase(tr, st);
     S.insert(dfn[i]);
     printf( %d
 , (int)S.size());
   }
 }
 signed main() { solve(); }


#include <bits/stdc++.h>
 using namespace std;
 struct fenwick {
   long long n, fen[100005];
   void resize(int _n) {
     n = _n + 1;
     memset(fen, 0, sizeof fen);
   }
   int query(int ind) {
     ind++;
     int ans = 0;
     while (ind >= 1) {
       ans += fen[ind];
       ind -= ind & -ind;
     }
     return ans;
   }
   void update(int ind, int val) {
     ind++;
     while (ind <= n) {
       fen[ind] += val;
       ind += ind & -ind;
     }
   }
   int query(int l, int r) { return query(r) - query(l - 1); }
 };
 const int maxn = 100001;
 int n, l, w, x, y, sz[maxn];
 long long res;
 bool blocked[maxn];
 vector<pair<int, int> > c, v[maxn];
 fenwick tree;
 void dfs(int node, int pnode, int curw, int curl) {
   c.push_back(make_pair(curw, curl));
   for (auto &i : v[node])
     if (i.first != pnode && !blocked[i.first])
       dfs(i.first, node, curw + i.second, curl + 1);
 }
 long long solve(int node, int curw, int curl) {
   long long ret = 0;
   c.clear();
   dfs(node, 0, curw, curl);
   sort(c.begin(), c.end());
   for (auto &i : c) tree.update(i.second, 1);
   for (int i = 0, j = c.size() - 1; i < c.size(); i++) {
     while (i <= j && c[i].first + c[j].first > w)
       tree.update(c[j--].second, -1);
     if (j < i) break;
     tree.update(c[i].second, -1);
     ret += tree.query(l - c[i].second);
   }
   return ret;
 }
 int dfsz(int node, int pnode) {
   sz[node] = 1;
   for (auto &i : v[node])
     if (i.first != pnode && !blocked[i.first]) sz[node] += dfsz(i.first, node);
   return sz[node];
 }
 int find(int node, int pnode, int n) {
   for (auto &i : v[node])
     if (i.first != pnode && !blocked[i.first] && 2 * sz[i.first] > n)
       return find(i.first, node, n);
   return node;
 }
 void decompose(int node) {
   int centroid = find(node, 0, dfsz(node, 0));
   blocked[centroid] = 1;
   res += solve(centroid, 0, 0);
   for (auto &i : v[centroid])
     if (!blocked[i.first]) res -= solve(i.first, i.second, 1);
   for (auto &i : v[centroid])
     if (!blocked[i.first]) decompose(i.first);
 }
 int main() {
   ios_base::sync_with_stdio(0);
   cin.tie(NULL);
   cout.tie(NULL);
   cin >> n >> l >> w;
   tree.resize(n + 1);
   for (int i = 2; i <= n && cin >> x >> y; i++) {
     v[i].push_back(make_pair(x, y));
     v[x].push_back(make_pair(i, y));
   }
   decompose(1);
   cout << res << endl;
   return 0;
 }


#include <bits/stdc++.h>
 const int maxn = 1e5 + 10;
 const int N = 5e2 + 10;
 using namespace std;
 long long gcd(long long p, long long q) { return q == 0 ? p : gcd(q, p % q); }
 long long qpow(long long p, long long q) {
   long long f = 1;
   while (q) {
     if (q & 1) f = f * p % 1000000007;
     p = p * p % 1000000007;
     q >>= 1;
   }
   return f;
 }
 int n, m, k, t;
 vector<int> d[4][11][10];
 char a[maxn], b[maxn];
 int gao(char p) {
   if (p == 'A')
     return 0;
   else if (p == 'T')
     return 1;
   else if (p == 'G')
     return 2;
   else
     return 3;
 }
 void add(vector<int>& d, int x, int y) {
   while (x < d.size()) d[x] += y, x += x & (-x);
 }
 int get(vector<int>& d, int x) {
   int ret = 0;
   while (x) ret += d[x], x -= x & (-x);
   return ret;
 }
 int main() {
   int i, j;
   scanf( %s , a + 1);
   n = strlen(a + 1);
   for (i = 0; i <= (int)3; i++)
     for (j = 1; j <= (int)10; j++)
       for (k = 0; k <= (int)j - 1; k++) d[i][j][k].resize((n + j - 1) / j + 1);
   for (i = 1; i <= n; i++) {
     for (j = 1; j <= 10; j++) {
       add(d[gao(a[i])][j][(i - 1) % j], (i - 1) / j + 1, 1);
     }
   }
   int q;
   scanf( %d , &q);
   while (q--) {
     int op, x, y;
     scanf( %d%d , &op, &x);
     if (op == 1) {
       scanf( %s , b);
       for (i = 1; i <= (int)10; i++)
         add(d[gao(a[x])][i][(x - 1) % i], (x - 1) / i + 1, -1);
       for (i = 1; i <= (int)10; i++)
         add(d[gao(b[0])][i][(x - 1) % i], (x - 1) / i + 1, 1);
       a[x] = b[0];
     } else {
       scanf( %d%s , &y, b);
       int len = strlen(b), ret = 0;
       for (i = 0; i < len && i < y - x + 1; i++) {
         int mo = (i + x - 1) % len;
         ret += get(d[gao(b[i])][len][mo], (y - 1 - mo) / len + 1) -
                get(d[gao(b[i])][len][mo], (x - 1 + len - 1 - mo) / len);
       }
       printf( %d
 , ret);
     }
   }
   return 0;
 }


#include <bits/stdc++.h>
 using namespace std;
 int main() {
   long long int i, j, t;
   cin >> t;
   for (long long int aa = 0; aa < t; aa++) {
     long long int n, k, d;
     cin >> n >> k >> d;
     long long int mini = k;
     vector<long long int> v(n);
     map<long long int, long long int> m;
     for (i = 0; i < n; i++) {
       cin >> v[i];
       if (i < d) {
         long long int ss = m.size();
         m[v[i]]++;
         if (ss < m.size()) m[v[i]] = 1;
       }
     }
     m.size() < mini ? mini = m.size() : mini = mini;
     for (i = 1; i < n - d + 1; i++) {
       m[v[i - 1]]--;
       if (m[v[i - 1]] == 0) m.erase(v[i - 1]);
       long long int ss = m.size();
       m[v[i + d - 1]]++;
       if (ss < m.size()) m[v[i + d - 1]] = 1;
       m.size() < mini ? mini = m.size() : mini = mini;
     }
     m.size() < mini ? mini = m.size() : mini = mini;
     cout << mini << endl;
   }
   return 0;
 }


#include <bits/stdc++.h>
 using namespace std;
 int main() {
   int n;
   cin >> n;
   int *p = new int[n + 1], c = 0;
   int *m = new int[n + 1];
   for (int i = 0; i <= n; i++) {
     p[i] = m[i] = 0;
     c ^= i;
     m[i] = c;
   }
   int f = 0;
   for (int i = 1; i <= n; i++) {
     cin >> p[i];
     f ^= p[i];
   }
   int r = 0;
   for (int i = 2; i <= n; i++) {
     int grps = (n / i);
     int rem = n % i;
     if (grps & 1) r ^= m[i - 1];
     r ^= m[rem];
   }
   cout << (r ^ f);
   return 0;
 }


#include <bits/stdc++.h>
 using namespace std;
 const int maxn = 1e5 + 5;
 long long a[maxn], b[maxn], dp[maxn];
 int q[maxn];
 int head = 0, tail = 0;
 double A(int i, int j) { return dp[i] - dp[j]; }
 double B(int i, int j) { return b[i] - b[j]; }
 int main() {
   ios::sync_with_stdio(false);
   cin.tie(0);
   cout.tie(0);
   int n;
   cin >> n;
   for (int i = 1; i <= n; i++) cin >> a[i];
   for (int i = 1; i <= n; i++) cin >> b[i];
   dp[1] = 0;
   int head = 1, tail = 1;
   q[tail] = 1;
   for (int i = 2; i <= n; i++) {
     while (head < tail &&
            A(q[head + 1], q[head]) / B(q[head + 1], q[head]) >= -a[i])
       head++;
     dp[i] = dp[q[head]] + b[q[head]] * a[i];
     while (head < tail && A(i, q[tail]) / B(i, q[tail]) >=
                               A(q[tail], q[tail - 1]) / B(q[tail], q[tail - 1]))
       tail--;
     q[++tail] = i;
   }
   cout << dp[n] << '
';
   return 0;
 }