#include <assert.h>
#include <algorithm>
#include <cstdio>
#include <set>
#include <utility>

using namespace std;

typedef pair<int, int> PII;

const int MAXT = 1 << 20;
const int MAXQ = 100'000;
const int MAXN = 300'000 + MAXQ;

struct T {
  long long sum;
  int count;
  int left, right;
  T() {}

  T(long long sum) : sum(sum), left(-1), right(-1) {}
  T(long long sum, bool count, int idx)
      : sum(sum), count(count), left(idx), right(idx) {}

  int idx() const {
    assert(left == right);
    return left;
  }
};

bool operator<(const T& l, const T& r) {
  if (l.sum != r.sum)
    return l.sum < r.sum;
  return l.idx() < r.idx();
}

enum Op { QUERY, ADD, REMOVE };

Op op_from_code(int code) {
  if (code == 1)
    return QUERY;
  else if (code == 2)
    return ADD;
  else if (code == 3)
    return REMOVE;
  else
    assert(false);
  return QUERY;
}

struct E {
  Op op;
  long long a1;
  long long a2;
};

int n, q;
int cap;

E e[MAXQ];
T t[MAXT];

long long get_sum(int i) {
  if (t[i].left == t[i].right && t[i].count == 0)
    return 0;
  return t[i].sum;
}

void build(int i) {
  assert(0 < i && i < cap);
  t[i].left = t[2 * i].left;
  t[i].right = t[2 * i + 1].right;
  t[i].sum = get_sum(2 * i) + get_sum(2 * i + 1);
  t[i].count = t[2 * i].count + t[2 * i + 1].count;
}

void update(int i) {
  if (i == 0)
    return;
  if (i < cap)
    build(i);
  update(i / 2);
}

long long get_count(int i, int left, int right) {
  if (i > cap + n) {
    return 0;
  }

  if (left <= t[i].left && t[i].right <= right) {
    return t[i].count;
  }

  if (t[i].right < left || right < t[i].left) {
    return 0;
  }
  return get_count(2 * i, left, right) + get_count(2 * i + 1, left, right);
}

long long get_count(int left, int right) {
  return get_count(1, left, right);
}

pair<int, long long> get_jump(int i, long long target, int left, int right) {
  if (i > cap + n) {
    return pair(left, 0);
  }

  if (t[i].right < left || right < t[i].left) {
    return pair(left, 0);
  }

  if (left <= t[i].left && t[i].right <= right && get_sum(i) <= target) {
    return pair(t[i].left, get_sum(i));
  }

  if (t[i].left == t[i].right) {
    return pair(t[i].left, get_sum(i));
  }

  auto right_res = get_jump(2 * i + 1, target, left, right);
  if (right_res.second >= target) {
    return right_res;
  };
  auto left_res = get_jump(2 * i, target - right_res.second, left, right);
  if (left_res.second == 0) {
    return right_res;
  }
  left_res.second += right_res.second;
  return left_res;
}

pair<int, long long> get_jump(long long target, int left, int right) {
  return get_jump(1, target, left, right);
}

T& a(int i) {
  return t[i + cap];
}

set<T> enabled, disabled;

set<PII>::const_iterator merge(set<PII>& eaten, set<PII>::const_iterator it) {
  auto next = it;
  next++;
  if (next != eaten.end()) {
    assert(it->first < it->second);
    assert(next->first < next->second);
    assert(it->second <= next->first);
    if (it->second == next->first) {
      auto p = pair(it->first, next->second);
      eaten.erase(it);
      eaten.erase(next);
      auto res = eaten.insert(p);
      assert(res.second);
      it = res.first;
    }
  }
  return it;
}

void eat(set<PII>& eaten, PII p) {
  auto res = eaten.insert(p);
  assert(res.second);
  auto it = res.first;
  it = merge(eaten, it);
  if (it != eaten.begin()) {
    it--;
    merge(eaten, it);
  }
}

int query(long long s, long long k) {
  int res = 0;

  set<PII> eaten;
  eaten.insert(pair(-1, 0));
  while (s < k) {
    auto next = enabled.lower_bound(T(s));
    assert(next == enabled.end() || next->sum >= s);
    int right = n;
    if (next != enabled.end()) {
      right = next->idx();
    }
    long long need = k - s;
    if (next != enabled.end()) {
      if (s > next->sum) {
        eat(eaten, pair(next->idx(), next->idx() + 1));
        s += next->sum;
        res++;
        next++;
        continue;
      }
      need = min(need, next->sum - s + 1);
    }
    assert(need > 0);
    long long jump = 0;
    int left = right;

    auto bound = eaten.lower_bound(pair(right, -1));
    assert(bound != eaten.begin());
    bound--;

    while (jump < need && left > 0) {
      assert(bound->second < right && bound->second <= left);

      auto jump_to = get_jump(need - jump, bound->second, right - 1);

      left = jump_to.first;
      jump += jump_to.second;
      res += get_count(left, right - 1);

      auto p = pair(left, right);
      assert(left < right);
      right = bound->first;
      left = right;
      bound--;
      eat(eaten, p);
    }

    if (jump < need) {
      return -1;
    }
    s += jump;
  }
  return res;
}

void add(long long x) {
  assert(x > 0);
  auto it = disabled.lower_bound(T(x));
  assert(it != disabled.end());
  assert(a(it->idx()).sum == x);
  a(it->idx()).count = 1;
  update(cap + it->idx());
  enabled.insert(a(it->idx()));
  disabled.erase(it);
}

void remove(long long x) {
  assert(x > 0);
  auto it = enabled.lower_bound(T(x));
  assert(it != enabled.end());
  assert(a(it->idx()).sum == x);
  a(it->idx()).count = 0;
  update(cap + it->idx());
  disabled.insert(a(it->idx()));
  enabled.erase(it);
}

int main() {
  scanf("%d", &n);
  for (int i = 0; i < n; i++) {
    scanf("%lld", &t[i].sum);
    t[i].count = 1;
  }
  scanf("%d", &q);
  for (int i = 0; i < q; i++) {
    int op_code;
    long long a1, a2 = -1;
    scanf("%d %lld", &op_code, &a1);
    Op op = op_from_code(op_code);
    if (op == QUERY) {
      scanf("%lld", &a2);
    }
    e[i].op = op;
    e[i].a1 = a1;
    e[i].a2 = a2;
  }

  for (int i = 0; i < q; i++) {
    if (e[i].op == ADD) {
      t[n].sum = e[i].a1;
      t[n].count = 0;
      n++;
    }
  }

  sort(t, t + n);

  for (int i = 0; i < n; i++) {
    a(i).left = a(i).right = i;
    if (a(i).count) {
      enabled.insert(a(i));
    } else {
      disabled.insert(a(i));
    }
  }

  cap = 1;
  while (cap < n)
    cap *= 2;
  for (int i = n - 1; i >= 0; i--)
    t[i + cap] = t[i];
  for (int i = cap + n; i < 2 * cap; i++) {
    t[i].left = t[i].right = MAXN;
    t[i].count = t[i].sum = 0;
  }
  for (int i = cap - 1; i > 0; i--)
    build(i);

  for (int i = 0; i < q; i++) {
    if (e[i].op == QUERY) {
      printf("%d\n", query(e[i].a1, e[i].a2));
    } else if (e[i].op == ADD) {
      add(e[i].a1);
    } else if (e[i].op == REMOVE) {
      remove(e[i].a1);
    } else {
      assert(false);
    }
  }
}