You are given an array a_1, a_2, …, a_n of integers. This array is non-increasing.

Let's consider a line with n shops. The shops are numbered with integers from 1 to n from left to right. The cost of a meal in the i-th shop is equal to a_i.

You should process q queries of two types:

  * 1 x y: for each shop 1 ≤ i ≤ x set a_{i} = max(a_{i}, y). 
  * 2 x y: let's consider a hungry man with y money. He visits the shops from x-th shop to n-th and if he can buy a meal in the current shop he buys one item of it. Find how many meals he will purchase. The man can buy a meal in the shop i if he has at least a_i money, and after it his money decreases by a_i. 

Input

The first line contains two integers n, q (1 ≤ n, q ≤ 2 ⋅ 10^5).

The second line contains n integers a_{1},a_{2}, …, a_{n} (1 ≤ a_{i} ≤ 10^9) — the costs of the meals. It is guaranteed, that a_1 ≥ a_2 ≥ … ≥ a_n.

Each of the next q lines contains three integers t, x, y (1 ≤ t ≤ 2, 1≤ x ≤ n, 1 ≤ y ≤ 10^9), each describing the next query.

It is guaranteed that there exists at least one query of type 2.

Output

For each query of type 2 output the answer on the new line.

Example

Input


10 6
10 10 10 6 6 5 5 5 3 1
2 3 50
2 4 10
1 3 10
2 2 36
1 4 7
2 2 17


Output


8
3
6
2

Note

In the first query a hungry man will buy meals in all shops from 3 to 10.

In the second query a hungry man will buy meals in shops 4, 9, and 10.

After the third query the array a_1, a_2, …, a_n of costs won't change and will be \{10, 10, 10, 6, 6, 5, 5, 5, 3, 1\}.

In the fourth query a hungry man will buy meals in shops 2, 3, 4, 5, 9, and 10.

After the fifth query the array a of costs will be \{10, 10, 10, 7, 6, 5, 5, 5, 3, 1\}.

In the sixth query a hungry man will buy meals in shops 2 and 4.
1 1
5
2 1 6

1

#include <bits/stdc++.h>
using namespace std;
bool check(long long n, long long pos) { return n & (1LL << pos); }
long long Set(long long n, long long pos) { return n = n | (1LL << pos); }
struct segTreemin {
  long long n;
  vector<long long> tree, lazy;
  segTreemin(long long n) : n(n), tree(4 * n, 0), lazy(4 * n, -1) {}
  void propagate(long long node, long long l, long long r) {
    if (lazy[node] != -1) {
      tree[node] = lazy[node];
      if (l != r) lazy[2 * node] = lazy[node], lazy[2 * node + 1] = lazy[node];
    }
    lazy[node] = -1;
  }
  void treeUpdate(long long node, long long l, long long r, long long u,
                  long long v, long long val) {
    long long mid = (l + r) >> 1;
    propagate(node, l, r);
    if (l > v || r < u) return;
    if (l >= u && r <= v) {
      lazy[node] = val;
      propagate(node, l, r);
      return;
    }
    treeUpdate(2 * node, l, mid, u, v, val);
    treeUpdate(2 * node + 1, mid + 1, r, u, v, val);
    tree[node] = min(tree[2 * node], tree[2 * node + 1]);
  }
  void update(long long l, long long r, long long val) {
    treeUpdate(1, 1, n, l, r, val);
  }
  long long treeQuery(long long node, long long l, long long r, long long val) {
    if (tree[node] > val) return n + 1;
    long long mid = (l + r) >> 1;
    propagate(node, l, r);
    if (l == r) return l;
    if (tree[2 * node] <= val) return treeQuery(2 * node, l, mid, val);
    return treeQuery(2 * node + 1, mid + 1, r, val);
  }
  long long query(long long val) { return treeQuery(1, 1, n, val); }
};
struct segTreesum {
  long long n;
  vector<long long> tree, lazy;
  segTreesum(long long n) : n(n), tree(4 * n, 0), lazy(4 * n, -1) {}
  void propagate(long long node, long long l, long long r) {
    if (lazy[node] != -1) {
      tree[node] = lazy[node] * (r - l + 1);
      if (l != r) lazy[2 * node] = lazy[node], lazy[2 * node + 1] = lazy[node];
    }
    lazy[node] = -1;
  }
  void treeUpdate(long long node, long long l, long long r, long long u,
                  long long v, long long val) {
    long long mid = (l + r) >> 1;
    propagate(node, l, r);
    if (l > v || r < u) return;
    if (l >= u && r <= v) {
      lazy[node] = val;
      propagate(node, l, r);
      return;
    }
    treeUpdate(2 * node, l, mid, u, v, val);
    treeUpdate(2 * node + 1, mid + 1, r, u, v, val);
    tree[node] = (tree[2 * node] + tree[2 * node + 1]);
  }
  void update(long long l, long long r, long long val) {
    treeUpdate(1, 1, n, l, r, val);
  }
  long long treeQuery(long long node, long long l, long long r, long long u,
                      long long v) {
    long long mid = (l + r) >> 1;
    propagate(node, l, r);
    if (l > v || r < u) return 0;
    if (l >= u && r <= v) return tree[node];
    return (treeQuery(2 * node, l, mid, u, v) +
            treeQuery(2 * node + 1, mid + 1, r, u, v));
  }
  long long query(long long l, long long r) { return treeQuery(1, 1, n, l, r); }
  long long treeQuery2(long long node, long long l, long long r,
                       long long val) {
    long long mid = (l + r) >> 1;
    propagate(node, l, r);
    if (l == r) {
      if (tree[node] <= val) return l;
      return l - 1;
    }
    if (tree[2 * node] >= val) return treeQuery2(2 * node, l, mid, val);
    return treeQuery2(2 * node + 1, mid + 1, r, val - tree[2 * node]);
  }
  long long query2(long long val) { return treeQuery2(1, 1, n, val); }
};
long long arr[200005];
int main() {
  long long i, j, k, l, m, n, o, r, q;
  long long testcase;
  long long input, flag, tag, ans;
  ios_base::sync_with_stdio(false);
  cin.tie(0);
  cout.tie(0);
  while (cin >> n >> m) {
    segTreemin seg1(n);
    segTreesum seg2(n);
    for (long long i = 1; i <= n; i++) {
      cin >> arr[i];
      seg1.update(i, i, arr[i]);
      seg2.update(i, i, arr[i]);
    }
    for (long long i = 1; i <= m; i++) {
      long long t, x, y;
      cin >> t >> x >> y;
      if (t == 1) {
        long long pos = seg1.query(y);
        if (pos <= x) {
          seg1.update(pos, x, y);
          seg2.update(pos, x, y);
        }
      } else {
        ans = 0;
        while (y > 0) {
          long long pos = seg1.query(y);
          pos = max(pos, x);
          if (pos > n) break;
          long long lo = pos;
          long long hi = n;
          long long tot = y;
          if (pos > 1) tot += seg2.query(1, pos - 1);
          long long ret = seg2.query2(tot);
          ans += ret - pos + 1;
          y -= seg2.query(pos, ret);
          x = ret + 1;
        }
        cout << ans << "\n";
      }
    }
  }
}
