#include <cstdint>
#include <iostream>
#include <set>
#include <vector>
#include <algorithm>
#include <optional>
#include <numeric>

using u32 = std::uint32_t;
using u64 = std::uint64_t;

struct szprotka_t {
    szprotka_t() : w_{0}, istnieje_{false} {}
    szprotka_t(u64 w, bool i) : w_{w}, istnieje_{i} {}
    u64 w_ = 0;
    bool istnieje_ = true;
    friend bool operator<(const szprotka_t& lhs, const szprotka_t& rhs) {
        return lhs.w_ < rhs.w_;
    }
    friend bool operator<(const szprotka_t& lhs, const u64 rhs) {
        return lhs.w_ < rhs;
    }
    friend bool operator<(const u64& lhs, const szprotka_t& rhs) {
        return lhs < rhs.w_;
    }
};

using sz_vec_it = std::vector<szprotka_t>::iterator;

struct fish_sum_t {
    fish_sum_t() : sum_{0}, it_{} {}
    fish_sum_t(u64 w, sz_vec_it i) : sum_{w}, it_{i} {}
    u64 sum_ = 0;
    sz_vec_it it_;
    friend bool operator<(const fish_sum_t& lhs, const fish_sum_t& rhs) {
        return lhs.sum_ < rhs.sum_;
    }
    friend bool operator<(const fish_sum_t& lhs, const u64 rhs) {
        return lhs.sum_ < rhs;
    }
    friend bool operator<(const u64& lhs, const fish_sum_t& rhs) {
        return lhs < rhs.sum_;
    }
};

void print_sz(std::multiset<szprotka_t>& sz) {
    for(auto &s : sz) {
        std::cout << s.w_ << ", ";
    }
    std::cout << '\n';
}

void print_sz_vec(std::vector<szprotka_t>& v, u64 count) {
    for(u64 i=0; i<count; ++i) {
        std::cout << v[i].w_ << ", ";
    }
    std::cout << '\n';
}

std::vector<fish_sum_t> fish_sums;

std::optional<u64> find_fish_to_eat(std::vector<szprotka_t>& v, sz_vec_it last, u64& s, u64 k) {

    if(s == last->w_) {
        //zjedz tylko jedna rybe
        auto fish = last-1;
        s += fish->w_;
        fish->istnieje_ = false;
        return 1;
    }

    u64 count = 0;
    auto it = last-1;
    while(true) {
        if(it->istnieje_) {
            s += it->w_;
            it->istnieje_ = false;
            ++count;
            if(s >= k) {
                return count;
            }
            if(s > last->w_) {
                return count;
            }
        }
        if(it == v.begin()) {
            break;
        }
        --it;
    }
    
    return {};
}

u64 eat_all(const std::vector<szprotka_t>& sz_vec, u64& s, u64 k) {
    u64 count = 0;
    auto it = sz_vec.end()-1;
    while(true) {
        if(it->istnieje_) {
            s += it->w_;
            ++count;
            if(s >= k) {
                return count;
            }
        }
        if(it == sz_vec.begin()) {
            break;
        }
        --it;
    }
    return count;
}

int main(void) {
    std::multiset<szprotka_t> szprotki;
    u32 n, q, t;
    u64 w, s, k;
    u64 sum = 0;
    std::cin >> n;
    for(u32 i=0; i<n; ++i) {
        std::cin >> w;
        sum += w;
        szprotki.emplace(w, true);
    }
    // print_sz(szprotki);
    std::cin >> q;
    std::vector<szprotka_t> sz_vec;
    sz_vec.resize(n+q);
    fish_sums.resize(n+q);
    for(u32 i=0; i<q; ++i) {
        std::cin >> t;
        if(t == 1) {
            std::cin >> s >> k;
            if(s >= k) {
                std::cout << 0 << '\n';
                continue;
            }
            if(s <= szprotki.begin()->w_) {
                // std::cout << "first\n";
                std::cout << -1 << '\n';
                continue;
            }
            if(k > sum + s) {
                // std::cout << "second\n";
                std::cout << -1 << '\n';
                continue;
            }

            u64 j = 0;
            for(auto& sz : szprotki) {
                sz_vec[j] = sz;
                ++j;
            }
            // print_sz_vec(sz_vec, j);
            //policz

            auto first = sz_vec.begin();
            auto last = sz_vec.begin()+szprotki.size();
            auto lower = std::lower_bound(first, last, s);
            if(lower == first) {
                // std::cout << "third\n";
                std::cout << -1 << '\n';
                continue;
            }

            u64 count = 0;
            while(s<k) {
                if(lower == last) {
                    count += eat_all(sz_vec, s, k);
                    if(s >= k) {
                        std::cout << count << '\n';
                        break;
                    } else {
                        // std::cout << "fourth\n";
                        std::cout << -1 << '\n';
                        break;
                    }
                }
                // std::cout << "lower: " << lower->w_ << "\n";
                auto c =  find_fish_to_eat(sz_vec, lower, s, k);
                if(!c) {
                    // std::cout << "fifth\n";
                    std::cout << -1 << '\n';
                    break;
                }
                count += c.value();

                if(s >= k) {
                    std::cout << count << '\n';
                    break;
                }
                lower = std::lower_bound(first, last, s);
            }
        }
        else if(t == 2) {
            std::cin >> w;
            szprotki.emplace(w, true);
            sum += w;
            // print_sz(szprotki);

        }
        else {
            std::cin >> w;
            szprotka_t szukana{w, true};
            auto znaleziona = szprotki.find(szukana);
            szprotki.erase(znaleziona);
            sum -= w;
            // print_sz(szprotki);
        }
    }

    return 0;
}