#include <bits/stdc++.h>
using namespace std;
#define debug(x) cout << #x << " " << x << endl;

#define int long long // uważaj

const int N = 1e6 + 7;

int szprotki[N];
pair<int, pair<int, int> > zapytanie[N];
vector<int> vek;
map<int, int> mapowanie;

struct Node {
    int ryby;
    int waga;
    int odjete;

    Node() {
        ryby = 0;
        waga = 0;
        odjete = 0;
    }
};

struct sony_drzewo {

    vector<Node> tree;
    vector<int> odwiedzone;
    int base;

    sony_drzewo(int n) {
        base = 1;
        while(base < n + 5) base *= 2;
        tree.resize(2 * base + 5);
    }

    void fix(int v) {
        assert(v < base);
        tree[v].ryby = 0;
        tree[v].waga = 0;
        tree[v].ryby += tree[v * 2].ryby;
        tree[v].waga += tree[v * 2].waga;
        tree[v].ryby += tree[v * 2 + 1].ryby;
        tree[v].waga += tree[v * 2 + 1].waga;
    }

    void insert(int waga, int dod) {
        int v = mapowanie[waga] + base;
        tree[v].ryby += dod;
        tree[v].waga += dod * waga;
        v /= 2;

        while(v) {
            fix(v);
            v /= 2;
        }
    }

    // ile ryb, suma wag
    pair<int, int> query(int v, int l, int r, int ograniczenie, int need) {

        if(tree[v].ryby == 0) return {0, 0};
        if(l > ograniczenie) return {0, 0};

        if(ograniczenie >= r) {
            if(l == r) {
                int potrzebuje = (need + vek[v - base] - 1) / vek[v - base];
                potrzebuje = min(potrzebuje, tree[v].ryby);

                tree[v].odjete += potrzebuje;
                tree[v].ryby -= potrzebuje;
                tree[v].waga = vek[v - base] * tree[v].ryby;
                odwiedzone.push_back(v);

                return {potrzebuje, vek[v - base] * potrzebuje};
            }

            if(tree[v].waga <= need) {
                tree[v].odjete = tree[v].ryby;
                tree[v].ryby = 0;
                int tmp = tree[v].waga;
                tree[v].waga = 0;
                odwiedzone.push_back(v);

                return {tree[v].odjete, tmp};
            }
        }

        int sr = (l + r) / 2;
        pair<int, int> re1 = query(v * 2 + 1, sr + 1, r, ograniczenie, need);
        if(re1.second >= need) {
            fix(v);
            return re1;
        }
        pair<int, int> re2 = query(v * 2, l, sr, ograniczenie, need - re1.second);
        fix(v);
        return {re1.first + re2.first, re1.second + re2.second};
    }

    pair<int, int> query(int v, int need) {
        return query(1, 0, base - 1, v, need);
    }

    void reset() {
        for(auto x : odwiedzone) {
            tree[x].ryby += tree[x].odjete;
            if(x >= base) tree[x].waga += tree[x].odjete * vek[x - base];
            tree[x].odjete = 0;
        }

        for(auto x : odwiedzone) reset_rek(x);
        odwiedzone.clear();
    }

    void reset_rek(int v) {
        if(v >= base) {
            v /= 2;
        }

        while(v) {
            fix(v);
            v /= 2;
        }
    }

    void pisz() {
        for(int i = 1; i < 2 * base; i++) {
            cout << "(" << tree[i].ryby << ", " << tree[i].waga << ", " << tree[i].odjete << ") ";
            if(__builtin_popcount(i + 1) == 1) cout << endl;
        }
    }
};

int32_t main() {
	ios_base::sync_with_stdio(0);
	cin.tie(0);
	cout.tie(0);

    int n;
    cin >> n;
    for(int i = 0; i < n; i++) {
        cin >> szprotki[i];
        vek.push_back(szprotki[i]);
    }

    int q;
    cin >> q;

    for(int i = 0; i < q; i++) {
        cin >> zapytanie[i].first;
        if(zapytanie[i].first == 1) {
            cin >> zapytanie[i].second.first >> zapytanie[i].second.second;
        } else {
            cin >> zapytanie[i].second.first;
            vek.push_back(zapytanie[i].second.first);
        }
    }

    sort(vek.begin(), vek.end());

    vek.resize(unique(vek.begin(), vek.end()) - vek.begin()); // upper_bound, a nawet i lower

    for(int i = 0; i < vek.size(); i++) {
        mapowanie[vek[i]] = i;
    }

    sony_drzewo tr(vek.size());

    multiset <int> szprotki_w_stawie;

    for(int i = 0; i < n; i++) {
        tr.insert(szprotki[i], 1);
        szprotki_w_stawie.insert(szprotki[i]);
    }

    for(int i = 0; i < q; i++) {
        // debug("huj2");
        // if(i == 4) exit(0);
        if(zapytanie[i].first == 1) {
            // debug("huj3");
            int poc = zapytanie[i].second.first;
            int kon = zapytanie[i].second.second;
            int ans = 0;
            int ostatnio = 0;
            int czy_fail = 0;

            while(poc < kon) {
                // debug(i);
                // tr.pisz();
                auto it = szprotki_w_stawie.lower_bound(poc);
                // if(i == 4) exit(0);

                if(it == szprotki_w_stawie.begin()) {
                    czy_fail = 1;
                    break;
                }
                it --;

                if((*it) == ostatnio) {
                    czy_fail = 1;
                    break;
                }
                ostatnio = (*it);
                it++;

                int need = kon - poc;
                if(it != szprotki_w_stawie.end()) need = min(need, (*it) - poc + 1);

                // debug(need);
                int pozycja = lower_bound(vek.begin(), vek.end(), poc) - vek.begin();
                pair<int, int> ret = tr.query(pozycja - 1, need); // co jak -1?

                ans += ret.first;
                poc += ret.second;
            }

            tr.reset();
            if(czy_fail) cout << -1 << endl;
            else cout << ans << endl;
            // if(i == 3) exit(0);

        } else if(zapytanie[i].first == 2) {
            tr.insert(zapytanie[i].second.first, 1);
            szprotki_w_stawie.insert(zapytanie[i].second.first);
        } else {
            tr.insert(zapytanie[i].second.first, -1);
            szprotki_w_stawie.erase(szprotki_w_stawie.find(zapytanie[i].second.first));
        }
        // debug("huj1");
    }
}