#include <bits/stdc++.h>

using namespace std;
using LL = long long;

const int N = 3e5 + 10, M = 1e5 + 10;
const LL INF = 2e18;

struct {
  vector<LL> vec;

  void push(LL x) { vec.emplace_back(x); }

  int init() {
    sort(vec.begin(), vec.end());
    vec.erase(unique(vec.begin(), vec.end()), vec.end());
    return vec.size();
  }

  int find(LL x) { return lower_bound(vec.begin(), vec.end(), x) - vec.begin() + 1; }

  LL get(int x) { return vec[x - 1]; }
} D;

struct Query {
  int op;
  LL x, y;
} q[M];

struct Node {
  int cnt;
  LL sum;
  Node(int cnt = 0, LL sum = 0) : cnt(cnt), sum(sum) {}
};

stack<pair<int, Node>> stk;

inline Node operator+(Node a, Node b) {
  return {a.cnt + b.cnt, a.sum + b.sum};
}

struct SGT {
  Node t[(N + M) * 4];

  void pushup(int p) { t[p] = t[p * 2] + t[p * 2 + 1]; }

  void modify(int p, int l, int r, int x, LL v) {
    if (l == r) {
      t[p] = t[p] + Node(v < 0 ? -1 : 1, v);
      return;
    }
    int m = (l + r) / 2;
    if (x <= m) modify(p * 2, l, m, x, v);
    else modify(p * 2 + 1, m + 1, r, x, v);
    pushup(p);
  }

  Node find_last(int p, int l, int r, int L, LL k) {
    if (t[p].cnt == 0 || l > L) return {0, 0};
    if (r <= L && t[p].sum <= k) {
      auto org = t[p];
      stk.emplace(p, t[p]);
      t[p] = Node();
      return org;
    }
    if (l == r) {
      LL v = D.get(l);
      int cnt = min((LL)t[p].cnt, (k + v - 1) / v);
      stk.emplace(p, t[p]);
      t[p] = t[p] + Node(-cnt, -v * cnt);
      return Node(cnt, v * cnt);
    }
    int m = (l + r) / 2;
    Node ans = find_last(p * 2 + 1, m + 1, r, L, k);
    if (ans.sum < k) ans = ans + find_last(p * 2, l, m, L, k - ans.sum);
    pushup(p);
    return ans;
  }
} sgt;

int main() {
  // freopen("A.in", "r", stdin);
  cin.tie(0)->sync_with_stdio(0);
  int n;
  cin >> n;
  multiset<LL> S;
  for (int i = 1; i <= n; i++) {
    LL w;
    cin >> w;
    S.insert(w), D.push(w);
  }
  int m;
  cin >> m;
  for (int i = 1; i <= m; i++) {
    cin >> q[i].op;
    if (q[i].op == 1) cin >> q[i].x >> q[i].y;
    else cin >> q[i].x, D.push(q[i].x);
  }
  int len = D.init();
  for (LL x : S) sgt.modify(1, 1, len, D.find(x), x);
  for (int i = 1; i <= m; i++) {
    if (q[i].op == 1) {
      LL s = q[i].x, k = q[i].y;
      int ans = 0;
      while (s < k) {
        auto it = S.lower_bound(s);
        LL nxt = min(it == S.end() ? INF : *it + 1, k);
        auto u = sgt.find_last(1, 1, len, D.find(s) - 1, nxt - s);
        ans += u.cnt, s += u.sum;
        if (s < nxt) {
          ans = -1;
          break;
        }
      }
      while (stk.size()) {
        auto [p, u] = stk.top();
        stk.pop();
        sgt.t[p] = u;
        while (p / 2) {
          p /= 2;
          sgt.pushup(p);
        }
      }
      cout << ans << '\n';
    } else if (q[i].op == 2) {
      LL w = q[i].x;
      S.insert(w);
      sgt.modify(1, 1, len, D.find(w), w);
    } else {
      LL w = q[i].x;
      S.erase(S.find(w));
      sgt.modify(1, 1, len, D.find(w), -w);
    }
  }
  return 0;
}