#include <iostream>
#include <cstdio>
#include <algorithm>
#include <vector>
#include <map>

using namespace std;
typedef long long I;
#define MAX 524288

//#define MAX 32

//#define MAX 8

#define MAXQ 131072

#define MAXI 3100000000000000000LL

#define ATACK 1
#define ADD 2
#define REM 3
struct K {
    I c,s,k;
    int pos = -1;
};

K kom[MAXQ];


#define DD(x)
#define DDD(x)
#define DDD2(x) 

#define EE(x) 

struct D {
    D() : sum(0), req(0), small(MAXI), big(0), count(0) {}
    D(I w) : sum(w), req(w+1), small(w), big(w), count(1) {}
    I sum, req, small, big, count;
    int id = -1;
    void print(){
     //   std::cout <<"r:" << req << " s:" << sum  /*<< "_:" << small*/ << " b:" << big << " c:" << count << " | ";
    //    std::cout << " s:" << sum << " c:" << count << " | ";
      //  std::cout << " s:" << sum << " b:" << big << "|" ;
        std::cout << " s:" << sum << "|" ;
    }
};

D d[MAX*2];

void update(I i) {
    d[i].sum = d[2*i].sum + d[2*i+1].sum;
    d[i].count = d[2*i].count + d[2*i+1].count;
    d[i].small = std::min(d[2*i].small, d[2*i+1].small);
    d[i].big = std::max(d[2*i].big, d[2*i+1].big);
    d[i].req = std::max(d[2*i].req, d[2*i+1].req - d[2*i].sum);
}

int find(I w, int posw = 1) {
    DD(cout << "f:" << posw << "\n");
    if(MAX <= posw) return posw;
    if(w>=d[2*posw+1].small) return find(w, 2*posw+1);
    return find(w, 2*posw);
}

int findL(I w, int posw = 1) {
    DD(cout << "f:" << posw << "\n");
    if(MAX <= posw) return posw;
    if(w>d[2*posw].big) return findL(w, 2*posw+1);
    return findL(w, 2*posw);
}

void remove_pos(int pos) {
    d[pos] = D();
    while(pos) {
        pos/=2;
        update(pos);
    }
}
void remove_w(I w) {
    int pos = find(w);
    d[pos] = D();
    while(pos) {
        pos/=2;
        update(pos);
    }
}


void add(int pos, I w) {
    d[pos] = D(w);
    while(pos) {
        pos/=2;
        update(pos);
    }
}

int sumR(int posw, I &s, I k, int pos = 1, int a= MAX, int b = 2*MAX) {
    if (b <= posw || d[pos].sum < 1 || k <= s) return 0;
    if (posw <= a && d[pos].req <= s && s+d[pos].sum <= k) {
        s+=d[pos].sum;
        return d[pos].count;
    }
    if(MAX <= pos) {
        if (d[pos].req <= s) {
            s+=d[pos].sum;
            return d[pos].count;
        }
        return 0;
    }
    int res = 0;
    res += sumR(posw, s, k, 2*pos,   a, (a+b)/2);
    res += sumR(posw, s, k, 2*pos+1, (a+b)/2, b);
    return res;
}



I sumL(int posw, int &dist, int pos = 1, int a= MAX, int b = 2*MAX) {
    if (pos >= 2*MAX) return 0;
    if (posw < a || d[pos].count < 1 || dist == 0) return 0;
    if (b <= posw && d[pos].count <= dist) {
        dist-=d[pos].count;
        return d[pos].sum;
    }
    
    I res = 0;
    res += sumL(posw, dist, pos*2+1, (a+b)/2, b);
    res += sumL(posw, dist, 2*pos,   a, (a+b)/2);
    return res;
}


int sum(int aa, int bb, int &npos,I &s, I k, int pos = 1, int a = MAX, int b=2*MAX) {
//    std::cout << "!sum:" << aa -MAX << "," << bb -MAX << " - " << a -MAX  << "," << b-MAX << " pos:" << pos - MAX<<  "\n";
    if (pos >= 2*MAX) return 0;
    if (d[pos].count < 1 || s >=k) return 0;
    if (aa <= a && b <= bb && s+d[pos].sum <= k) {
        s+=d[pos].sum;
        npos = a;
        return d[pos].count;
    }
    if(aa <= a && b <= bb && MAX <= pos && d[pos].sum != MAXI) {
        s+=d[pos].sum;
        npos = a;
        return d[pos].count;
    }
    int ab2 = (a+b)/2;
    int res = 0;
    if (ab2<=bb)
        res += sum(std::max(ab2,aa), bb, npos, s, k, 2*pos+1, ab2, b);
    if (aa <= ab2)
        res += sum(aa, std::min(ab2, bb), npos, s, k, 2*pos,  a ,ab2);
    
    return res;
}

int findSum(std::vector<std::pair<int,int>> &przed, I &s, I k, int res = 0) {
    if (przed.empty()) return res;
    auto p = przed.back();
    przed.pop_back();
    int pos = p.second;
    int count = sum(p.first, p.second, pos, s, k);
    if (s>=k) {
        przed.emplace_back(p.first, pos);
        return count+res;
    }
    return findSum(przed, s, k, res+count);
}

int findLess(I w) {
    int pos = findL(w);
    EE(std::cout << "!!!findL:" << pos -MAX<< "\n");
    while(d[pos].sum >= w) pos--;
    return pos;
}

int calc2(std::vector<std::pair<int,int>> &przed, I &s, I k, int res = 0) {
    if (s>=k) return res;
    int pos = findL(s);
    EE(std::cout << "!pos:" << pos-MAX << " s:" << s << "\n");
    if(pos >= 2*MAX || k-s <= d[pos].sum - s +1) {
        EE(std::cout << "A:\n");
        I ss = 0;
        int count = findSum(przed, ss, k-s);
        EE(std::cout << " ss: " << s  << " count:" << count << "\n");

        if(ss < k-s) return -1;
        return res+count;
    } else {
        EE(std::cout << "B:\n");
        I ss = 0;
        int count = findSum(przed, ss, d[pos].sum - s +1);
        if(ss < d[pos].sum - s +1) return -1;
        s += ss;
        if (s>=k) return count+res;
        EE(std::cout << " s: " << s  << " count:" << count  << " pos:" << pos << "\n");
        int npos = findLess(s);
        EE(std::cout << " przed: " << pos+1 -MAX << "," << std::min(2*MAX,npos+1) -MAX  << "\n");
        przed.emplace_back(pos, std::min(2*MAX,npos+1));
        return calc2(przed, s, k, count+res);
    }
}


int calc(I s, I k) {
    int npos = findLess(s);
    EE(std::cout << "npos:" << npos -MAX<<  " s:" << s <<"\n");
    std::vector<std::pair<int,int>> przed;
    przed.emplace_back(MAX, std::min(2*MAX, npos+1));

    int res = calc2(przed, s, k);
    if(res >= MAX+1) return -1;
    return res;
}

void print()
{
    int v = 2;
    for(int i=1;i<MAX*2;i++) {
        d[i].print();
        if(i == v-1) {
            std::cout << "\n";
            v*=2;
        }
    }
}

int main()
{
    I n,w,nn,q;
    scanf("%lld", &n);
    for(nn=0;nn<n;nn++) {
        scanf("%lld", &w);
        d[MAX+nn] = D(w);
    }
    scanf("%lld", &q);
    for(I j=0;j<q;j++) {
        I c,s,k;
        scanf("%lld %lld", &c, &s);
        if(c == ATACK) scanf("%lld", &k);
        kom[j] = {c,s,k};
    }

    //ADD
    for(I j=0;j<q;j++) 
        if(kom[j].c == ADD) {
            d[MAX+nn] = D(kom[j].s);
            d[MAX+nn].id = j;
            nn++;
        }
    d[MAX+nn++] = D(MAXI);

    sort(&d[MAX], &d[2*MAX], [](const D& a, const D &b) {return a.sum < b.sum;} );

    DDD2(std::cout << "sorted\n";
    print());

    //Update pos
    for(int i=MAX;i<2*MAX;i++) {
        if(d[i].id>=0) kom[d[i].id].pos = i;
    }

    for(I i=MAX-1; i > 0; i--) update(i);

    //REMOVE
    for(I j=0;j<q;j++) if(kom[j].c == ADD) remove_pos(kom[j].pos);


/*    std::cout << "Removed\n";

    
    print();
    int ff = 3;
    std::cout << "find" << ff << "->" << find(ff) - MAX << "\n";
    ff=8;
    std::cout << "findL" << ff << "->" << findL(ff) - MAX << "\n";
    int d =1;
    std::cout << "sumL:" << sumL(MAX+4, d) << "\n";
    std::cout << "sumR:" << sumR(MAX+2, s,k) << "\n";
    std::cout << "s: " << s << "\n";
 
   int pos;
    I s=9,k=16;
    std::cout << "sum:" << sum(6+MAX, 7+MAX, pos, s, k) << "\n";
    std::cout << "s: " << s << "\n";
*/
//    return 1 ;
    

    for(I j=0;j<q;j++) {
        switch(kom[j].c) {
            case ADD: 
                add(kom[j].pos, kom[j].s);
                DDD2(std::cout << "added pos:" << kom[j].pos - MAX  << " w: " << kom[j].s << "\n";
                print());
                break;
            case REM: 
                remove_w(kom[j].s); 
                DDD2(std::cout << "removed:" << kom[j].s << "\n";
                print());
                break;
            case ATACK: 
                EE(print());
  //              printf("WYNIK %lld: %d\n", j, calc(kom[j].s, kom[j].k)); 
                printf("%d\n", calc(kom[j].s, kom[j].k)); 
            break;
        }
    }
}