#include <bits/stdc++.h>
using namespace std;

#define endl '\n'
#define L long long
#define MP make_pair
#define REP(i, n) for(int i = 0; i < n; ++i)
#define REPR(i, n) for(int i = n - 1; i >= 0; --i)
#define FOR(i, a, b) for(int i = a; i < b; ++i)
#define FORR(i, a, b) for(int i = b - 1; i >= a; --i)
#define EB emplace_back
#define ST first
#define ND second
#define S size()
#define RS resize

using VI = vector<int>;
using VVI = vector<VI>;
using PI = pair<int, int>;
using PL = pair<L, L>;
using VPI = vector<PI>;
using VPL = vector<PL>;
using VVPI = vector<VPI>;
using VL = vector<L>;
using VVL = vector<VL>;
using VB = vector<bool>;
using VC = vector<char>;

int n;
L inf = (L)2000000000000000000;
VPL a;
unordered_map<L, VI> mapa;
unordered_map<L, int> wskaz;

struct z
{
    int typ;
    L w, k;
    int poz;
};

vector<z> zap;

struct drzewo
{
    int ts = 1, ls = 1;
    VL suma, maks;
    VI ile, poz_maks;
    
    void merge(int v)
    {
        int u1 = 2 * v, u2 = 2 * v + 1;
        suma[v] = suma[u1] + suma[u2];
        maks[v] = max(maks[u1], maks[u2]);
        if (maks[u1] > maks[u2])
            poz_maks[v] = poz_maks[u1];
        else
            poz_maks[v] = poz_maks[u2];
        ile[v] = ile[u1] + ile[u2];
    }
    
    drzewo(int r)
    {
        while (ts <= r)
            ts *= 2;
        ts *= 2;
        ls = ts / 2;
        suma.RS(ts);
        maks.RS(ts);
        ile.RS(ts);
        poz_maks.RS(ts);
        REP(i, r)
        {   
            int v = i + ls;
            if (a[i].ND == -1)
            {
                suma[v] = maks[v] = a[i].ST;
                ile[v] = 1;
            }
            poz_maks[v] = i;
        }
        FORR(v, 1, ls)
            merge(v);
    }
    
    void dodaj(int v, L c)
    {
        v += ls;
        ile[v]++;
        suma[v] = c;
        maks[v] = c;
        poz_maks[v] = v - ls;
        while (v > 1)
        {
            v >>= 1;
            merge(v);
        }
    }
    
    void usun(int v, L c)
    {
        v += ls;
        ile[v] = 0;
        suma[v] -= c;
        maks[v] -= c;
        poz_maks[v] = v - ls;
        while (v > 1)
        {
            v >>= 1;
            merge(v);
        }
    }
    
    L query_suma(int l, int r)
    {
        if (l > r)
            return 0;
        l += ls;
        r += ls;
        L wyn = suma[l];
        if (l != r)
            wyn += suma[r];
        while ((l >> 1) != (r >> 1))
        {
            if (l % 2 == 0)
                wyn += suma[l + 1];
            if (r % 2 == 1)
                wyn += suma[r - 1];
            l >>= 1;
            r >>= 1;
        }
        return wyn;
    }
    
    int query_ile(int l, int r)
    {
        if (l > r)
            return 0;
        l += ls;
        r += ls;
        int wyn = ile[l];
        if (l != r)
            wyn += ile[r];
        while ((l >> 1) != (r >> 1))
        {
            if (l % 2 == 0)
                wyn += ile[l + 1];
            if (r % 2 == 1)
                wyn += ile[r - 1];
            l >>= 1;
            r >>= 1;
        }
        return wyn;
    }
    
    L query_maks(int l, int r)
    {
        if (l > r)
            return 0;
        l += ls;
        r += ls;
        L wyn = max(maks[l], maks[r]);
        while ((l >> 1) != (r >> 1))
        {
            if (l % 2 == 0)
                wyn = max(wyn, maks[l + 1]);
            if (r % 2 == 1)
                wyn = max(wyn, maks[r - 1]);
            l >>= 1;
            r >>= 1;
        }
        return wyn;
    }
    
    int query_poz_maks(int l, int r)
    {
        l += ls;
        r += ls;
        L m = maks[l];
        int poz = poz_maks[l];
        if (maks[r] >= maks[l])
        {
            m = maks[r];
            poz = poz_maks[r];
        }
        while ((l >> 1) != (r >> 1))
        {
            if (l % 2 == 0 && (maks[l + 1] > m || (maks[l + 1] == m && poz_maks[l + 1] > poz)))
            {
                m = maks[l + 1];
                poz = poz_maks[l + 1];
            }
            if (r % 2 == 1 && (maks[r - 1] > m || (maks[r - 1] == m && poz_maks[r - 1] > poz)))
            {
                m = maks[r - 1];
                poz = poz_maks[r - 1];
            }
            l >>= 1;
            r >>= 1;
        }
        return poz;
    }
};

int binsearch_najd(L s, drzewo &tree, int r)
{
    int poc = -1, kon = r - 1;
    while (poc < kon)
    {   
        int sro = (poc + kon + 1) / 2;
        if (tree.query_maks(0, sro) < s)
            poc = sro;
        else
            kon = sro - 1;
    }
    if (tree.query_maks(0, poc) == 0)
        return -1;
    else
        return tree.query_poz_maks(0, poc);
}

L binsearch_wie(L s, drzewo &tree, int r)
{
    int poc = 0, kon = r - 1;
    while (poc < kon)
    {
        int sro = (poc + kon) / 2;
        if (tree.query_maks(0, sro) >= s)
            kon = sro;
        else
            poc = sro + 1;
    }
    if (tree.query_maks(0, poc) < s)
        return inf;
    else
        return tree.query_maks(0, poc);
}

set<PI> prze;

L licz_prze(int l, int r, drzewo &tree)
{
    L wyn = tree.query_suma(l, r);
    for (PI p : prze)
        wyn -= tree.query_suma(max(p.ST, l), p.ND);
    return wyn;
}

int ile_prze(int l, int r, drzewo &tree)
{
    int wyn = tree.query_ile(l, r);
    for (PI p : prze)
        wyn -= tree.query_ile(max(p.ST, l), p.ND);
    return wyn;
}

void update_prze(int l, int r)
{   
    set<PI> usu;
    for (PI p : prze)
        if (p.ST >= l)
            usu.insert(p);
    for (PI u : usu)
        prze.erase(u);
    prze.insert(MP(l, r));
}

int binsearch_prze(L w, drzewo &tree, int gdzie)
{
    int poc = 0, kon = gdzie;
    while (poc < kon)
    {
        int sro = (poc + kon + 1) / 2;
        if (licz_prze(sro, gdzie, tree) > w)
            poc = sro;
        else
            kon = sro - 1;
    }
    if (licz_prze(0, gdzie, tree) <= w)
        return -1;
    else
        return poc;
}

int main()
{
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);
    cin >> n;
    a.RS(n);
    REP(i, n)
    {
        cin >> a[i].ST;
        a[i].ND = -1;
    }
    int q;
    cin >> q;
    zap.RS(q);
    REP(i, q)
    {
        cin >> zap[i].typ >> zap[i].w;
        if (zap[i].typ == 1)
            cin >> zap[i].k;
        else if (zap[i].typ == 2)
            a.EB(zap[i].w, i);
    }
    int r = int(a.S);
    sort(a.begin(), a.end());
    REP(i, r)
        if (a[i].ND == -1)
            mapa[a[i].ST].EB(i);
    REP(i, r)
        if (a[i].ND != -1)
            zap[a[i].ND].poz = i;
    REP(i, r)
        wskaz[a[i].ST] = 0;
    drzewo tree(r);
    for (auto za : zap)
    {   
        if (za.typ == 1)
        {   
            L s = za.w, k = za.k;
            int zjedzone = 0;
            bool zle = false;
            if (s >= k)
            {
                cout << 0 << endl;
                continue;
            }
            int gdzie = binsearch_najd(s, tree, r);
            if (gdzie == -1)
            {
                cout << -1 << endl;
                continue;
            }
            while (s < k)
            {   
                L szu = binsearch_wie(s, tree, r);
                szu = min(szu - s, k - s - 1);
                int cof = binsearch_prze(szu, tree, gdzie);
                if (cof == -1)
                {
                    zle = true;
                    break;
                }
                zjedzone += ile_prze(cof, gdzie, tree);
                s += licz_prze(cof, gdzie, tree);
                update_prze(cof, gdzie);
                gdzie = binsearch_najd(s, tree, r);
            }
            prze.clear();
            if (zle)
                cout << -1 << endl;
            else
                cout << zjedzone << endl;
        }
        else if (za.typ == 2)
        {
            tree.dodaj(za.poz, a[za.poz].ST);
            mapa[za.w].EB(za.poz);
        }
        else
        {
            int poz = mapa[za.w][wskaz[za.w]];
            wskaz[za.w]++;
            tree.usun(poz, a[poz].ST);
        }
    }
}