#include <bits/stdc++.h>

using namespace std;


template<typename val_t>
struct AVLTree {
  
  struct Node {
    Node *p, *l, *r;
    val_t v;
    int h;
    int sz;
    
    val_t mv; // max value
    val_t sum; // sum of values
    int q; // query id
    int iq; // min query id
    
    void init() {
      p = l = r = NULL;
      h = 1;
      sz = 1;
      
      mv = v;
      sum = v;
      q = 0;
      iq = 0;
    }
    
    Node() { init(); }
    Node(val_t const &_v): v(_v) { init(); }
    ~Node() { delete l; delete r; }
    
    static int heightOf(Node const * const &ch) {
      return (ch == NULL ? 0 : ch->h);
    }
    
    static int sizeOf(Node const * const &ch) {
      return (ch == NULL ? 0 : ch->sz);
    }
    
    int balanceFactor() const {
      return heightOf(r) - heightOf(l);
    }
    
    void fix() {
      h = max(heightOf(l), heightOf(r)) + 1;
      sz = sizeOf(l) + sizeOf(r) + 1;
      
      mv = v;
      sum = v;
      iq = q;
      if(l != NULL) { mv = max(mv, l->v); sum += l->sum; iq = min(iq, l->iq); }
      if(r != NULL) { mv = max(mv, r->v); sum += r->sum; iq = min(iq, r->iq); }
    }
    
    val_t usum() {
      val_t ret = v;
      
      if(l != NULL) ret += l->sum;
      if(p != NULL) {
        if(p->r == this) {
          ret += p->v;
          if(p->l != NULL) {
            ret += p->l->sum;
          }
        }
      }
      
      return ret;
    }
    
    Node *rotateRight() {
      Node *t = l;
      if(t == NULL) return this;
      swap(v, t->v);
      l = t->l;
      t->l = t->r;
      t->r = r;
      r = t;
      if(l != NULL)    l->p = this;
      if(t->r != NULL) t->r->p = t;
      t->fix();
      fix();
      return this;
    }
    
    Node *rotateLeft() {
      Node *t = r;
      if(t == NULL) return this;
      swap(v, t->v);
      r = t->r;
      t->r = t->l;
      t->l = l;
      l = t;
      if(r != NULL)    r->p = this;
      if(t->l != NULL) t->l->p = t;
      t->fix();
      fix();
      return this;
    }
    
    void balance() {
      fix();
      if(balanceFactor() == 2) {
        if(r->balanceFactor() < 0) r->rotateRight();
        rotateLeft();
      }
      if(balanceFactor() == -2) {
        if(l->balanceFactor() > 0) l->rotateLeft();
        rotateRight();
      }
    }
    
    void insert(val_t const &w, Node *&ch) {
      if(ch == NULL) {ch = new Node(w); ch->p = this; }
      else            ch->insert(w);
      balance();
    }
    
    void insert(val_t const &w) {
      if(w < v) insert(w, l);
      else      insert(w, r);
    }
    
    Node *first() {
      if(l != NULL) return l->first();
      return this;
    }
    
    Node *next() {
      if(r != NULL) return r->first();
      
      Node *t = this;
      while(t != NULL) {
        if(t->p != NULL and t->p->l == t and t->p->r != NULL) return t->p->r->first();
        t = t->p;
      }
      
      return this;
    }
    
    Node *erase(AVLTree &tr) {
      // cerr << "ethis = " << this << "\n";
      if(l == NULL or r == NULL) {
        Node *t = NULL;
        if(l != NULL) {t = l; l = NULL; }
        if(r != NULL) {t = r; r = NULL; }
        if(t != NULL) t->p = p;
        if(p != NULL) {
          if(this == p->l) p->l = t;
          if(this == p->r) p->r = t;
          p->balance();
        }
        if(tr.root == this) {
          tr.root = t;
        }
        return this;
      }
      
      Node *n = next();
      v = n->v;
      Node *ret = n->erase(tr);
      fix();
      if(p != NULL) p->fix();
      balance();
      if(p != NULL) p->balance();
      
      return ret;
    }
    
    Node *lowerBound(val_t const &w, Node * const &ch) {
      if(ch == NULL) return this;
      else           return ch->lowerBound(w);
    }
    
    Node *lowerBound(val_t const &w) {
      if(w > v) return lowerBound(w, r);
      else {
        Node *ret = lowerBound(w, l);
        return (ret == NULL or ret->v < w) ? this : ret;
      }
    }
    
    int countGreater() const {
      int ans = sizeOf(r);
      for(Node const *t = p, *u = this; t != NULL; u = t, t = t->p) {
        if(t->l == u) ans += 1 + sizeOf(t->r);
      }
      return ans;
    }
    
    void debug(int d = 0) const {
      for(int i = 0; i < d; ++i) cerr << "----";
      cerr << "Node " << v << " h=" << h << " sz=" << sz << "   t=" << this << " p = " << p << " l=" << l << " r=" << r << '\n';
      cerr << 'l';
      if(l) l->debug(d+1);
      else  cerr << '\n';
      cerr << 'r';
      if(r) r->debug(d+1);
      else  cerr << '\n';
    }
  };
  
  Node *root;
  
  int lq; // last query
  
  AVLTree(): root(NULL), lq(0) { }
  ~AVLTree() { delete root; }
  
  void insert(val_t const &w) {
    if(root == NULL) root = new Node(w);
    else             root->insert(w);
  }
  
  Node *lowerBound(val_t const &w) const {
    if(root == NULL) return NULL;
    Node *ret = root->lowerBound(w);
    return ret->v < w ? NULL : ret;
  }
  
  int countGreater(val_t const &w) const {
    Node *t = lowerBound(w);
    if(t == NULL) return 0;
    return (t->v != w) + t->countGreater();
  }
  
  void erase(Node *n) {
    bool last = (root->sz == 1);
    Node *t = n->erase(*this);
    // cerr << "erasing " << t << '\n';
    if(t) {
      t->l = NULL;
      t->r = NULL;
    }
    delete t;
    if(last) root = NULL;
  }
  
  void debug() const {
    if(root) root->debug();
  }
  
};


typedef AVLTree<int64_t>::Node TNode;


TNode *greaterThan(AVLTree<int64_t> &tr, TNode *n, int64_t s) {
  if(n->iq >= tr.lq) return NULL;
  
  if(n->v > s) {
    TNode *t = n->l;
    if(t == NULL or t->iq >= tr.lq) return n;
    t = greaterThan(tr, t, s);
    if(t != NULL and t->v > s) return t; else return n;
  } else {
    TNode *t = n->r;
    if(t == NULL) return NULL;
    return greaterThan(tr, t, s);
  }
}


TNode *greaterThan(AVLTree<int64_t> &tr, int64_t s) {
  TNode *n = tr.root;
  if(n == NULL) return NULL;
  
  return greaterThan(tr, n, s);
}


TNode *lowerThan(AVLTree<int64_t> &tr, TNode *n, int64_t s) {
  if(n->iq >= tr.lq) return NULL;
  
  if(n->v < s) {
    TNode *t = n->r;
    if(t == NULL or t->iq >= tr.lq) return n;
    t = lowerThan(tr, t, s);
    if(t != NULL and t->v < s) return t; else return n;
  } else {
    TNode *t = n->l;
    if(t == NULL) return NULL;
    return lowerThan(tr, t, s);
  }
}


TNode *lowerThan(AVLTree<int64_t> &tr, int64_t s) {
  TNode *n = tr.root;
  if(n == NULL) return NULL;
  
  return lowerThan(tr, n, s);
}


TNode *last(AVLTree<int64_t> &tr, TNode *n) {
  if(n->iq >= tr.lq) return NULL;
  
  if(n->r != NULL and n->r->iq < tr.lq) return last(tr, n->r);
  
  return n;
}


TNode *prevv(AVLTree<int64_t> &tr, TNode *n) {
  if(n->l != NULL and n->l->iq < tr.lq) return last(tr, n->l);
  
  while(n != NULL) {
    if(n->p != NULL and n->p->r == n) {
      if(n->p->q < tr.lq) return n->p;
      return prevv(tr, n->p);
    }
    n = n->p;
  }
  
  return NULL;
}


int64_t eat(AVLTree<int64_t> &tr, TNode *n) {
  int64_t ret = n->v;
  n->q = tr.lq;
  
  while(n != NULL) {
    n->iq = n->q;
    if(n->l) n->iq = min(n->iq, n->l->iq);
    if(n->r) n->iq = min(n->iq, n->r->iq);
    n = n->p;
  }
  
  return ret;
}


int query2(AVLTree<int64_t> &tr, int64_t s, int64_t k) {
  if(s >= k) return 0;
  
  // cerr << "s = " << s << " k = " << k << '\n';
  
  int64_t target = k;
  int count = 0;
  
  {
    TNode *g = greaterThan(tr, s - 1);
    if(g != NULL and g->v + 1 < target) {
      target = g->v + 1;
    }
  }
  
  // cerr << "s = " << s << "  target = " << target << '\n';
  
  TNode *m = lowerThan(tr, s);
  if(m == NULL) return -1;
  //cerr << "m = " << m << '\n';
  if(s + m->usum() < target) return -1;
  
  //cerr << "m = " << m << '\n';
  
  while(s < target) {
    if(m == NULL) return -1;
    s += eat(tr, m);
    // cerr << "IAH s = " << s << '\n';
    m = prevv(tr, m);
    count++;
  }
  
  if(target != k) {
    int c2 = query2(tr, s, k);
    if(c2 == -1) return -1;
    return c2 + count;
  }
  
  return count;
}

int query(AVLTree<int64_t> &tr, int64_t s, int64_t k) {
  tr.lq++;
  return query2(tr, s, k);
}


int main() {
  ios_base::sync_with_stdio(false);
  cin.tie(NULL);
  
  int n;
  cin >> n;
  
  AVLTree<int64_t> tr;
  
  for(int i = 0; i < n; i++) {
    int64_t w;
    cin >> w;
    tr.insert(w);
  }
  
  int q;
  cin >> q;
  
  while(q --> 0) {
    int op;
    cin >> op;
    
    if(op == 1) {
      int64_t s, k;
      cin >> s >> k;
      
      //tr.debug();
      // cerr << "sk " << s << ' ' << k << '\n';
      
      cout << query(tr, s, k) << '\n';
    } else if(op == 2) {
      int64_t w;
      cin >> w;
      tr.insert(w);
    } else /* if(op == 3) */ {
      int64_t w;
      cin >> w;
      tr.erase(tr.lowerBound(w));
    }
  }
  
  return 0;
}