#include <iostream>
#include <set>
#include <map>
#include <limits>
#include <vector>

#include <iomanip>               // for std::setw
#include <ios>                   // for std::noskipws, streamsize
#include <istream>               // for std::istream
#include <ostream>               // for std::ostream
#include <sstream>               // for std::ostringstream
#include <cstddef>               // for NULL
#include <stdexcept>             // for std::domain_error
#include <string>                // for std::string implicit constructor
#include <cstdlib>               // for std::abs
#include <limits>                // for std::numeric_limits

#include<type_traits>

using namespace std;

// #define DEBUG

#ifdef DEBUG
#define dbg cerr
// #define dbg2 cerr
#define dbg2 0 && cerr
#else
#define dbg 0 && cerr
#define dbg2 0 && cerr
#endif

using fish = unsigned long long;


std::multiset<fish> w;
std::vector<fish> fishes;

struct Node;
Node* root = nullptr;

std::set<Node*> nodes_to_recover;

struct Node {
    void recover() {
        suma = suma_original;
        nr_of_fish = nr_of_fish_original;
        marked = false;
    }

    fish suma, suma_original;
    int nr_of_fish, nr_of_fish_original;
    bool marked;

    int left, right;
    Node *p_left, *p_right;

    int middle() {
        return (this->left + this->right)/2;
    }

    void build(fish values[], int left, int right) {
        dbg2 << "Build node " << left << ", " << right << endl;
        if (left > right) {
            return;
        }

        this->left = left;
        this->right = right;

        if (left == right) {
            this->suma = values[left];
            nr_of_fish = 1;
        } else {
            this->p_left = new Node();
            this->p_right = new Node();

            this->p_left->build(values, left, middle());
            this->p_right->build(values, middle()+1, right);

            nr_of_fish = p_left->nr_of_fish + p_right->nr_of_fish;
            this->suma = this->p_left->suma +  this->p_right->suma;
        }
        suma_original = suma;
        nr_of_fish_original = nr_of_fish;
        this->marked = false;
    }

    fish sum(int left, int right) {
        dbg2 << "[Node " << this->left << ", " << this->right << "]: Sum of (" << left <<  ", " << right << "): ";
        if (left > right) {
            dbg2 << "0\n";
            return 0;
        }

        if (this->left == left && this->right == right) {
            dbg2 << "this node: " << this->suma << "\n";
            return this->suma;
        }

        push();

        dbg2 << "\n";

        return this->p_left->sum(left, min(right, middle())) + 
               this->p_right->sum(max(left, middle()+1), right);
    }

    void push() {
        if (marked) {
            this->p_left->suma = 0;
            this->p_right->suma = 0;
            this->suma = 0;
            this->nr_of_fish = 0;

            this->p_left->marked = true;
            this->p_right->marked = true;
            marked = false;

            nodes_to_recover.insert(this);
        }
    }

    void zero(int l, int r) {
        dbg2 << "Zeroing (" << l <<  ", " << r << "): ";
        if (l > r) {
            dbg2 << "none.\n";
            return;
        }

        if (this->left == l && this->right == r) {
            dbg2 << "this node: " << this->suma << "\n";
            this->marked = true;
            this->suma = 0;
            this->nr_of_fish = 0;
            nodes_to_recover.insert(this);
        } else {
            dbg2 << "\n";
            push();

            this->p_left->zero(l, min(r, middle()));
            this->p_right->zero(max(l, middle()+1), r);

            nodes_to_recover.insert(this);
            this->suma = this->p_left->suma +  this->p_right->suma;
            this->nr_of_fish = p_left->nr_of_fish + p_right->nr_of_fish;
        }
    }

    int nr_of_fishes(int l, int r) {
        if (l > r) {
            return 0;
        }

        if (this->left == l && this->right == r) {
            return this->nr_of_fish;
        }

        push();
        return this->p_left->nr_of_fishes(l, min(r, middle())) + 
               this->p_right->nr_of_fishes(max(l, middle()+1), r);
    }

    void delet() {
        if (left == right) {
            return;
        } else {
            this->p_left->delet();
            this->p_right->delet();

            delete p_left;
            delete p_right;
        }
    }

    void print() {
        if (left == right) {
            dbg2 << "Leaf: " << left << ": " << this->suma << endl;
        } else {
            this->p_left->print();
            this->p_right->print();
            dbg2 << "(" << left << ", " << right << "): " << this->suma << endl;
        }
    }
};

int min_index_with_sum(fish suma, int end_index) {
    int a = 0, b = end_index;

    //dbg << "Binary search: (" << a << ", " << b << ")" << endl;

    while (a < b) {
        int m = (a+b)/2;
        //dbg << "(" << a << ", " << b << ") -> " << root->sum(m, end_index) << endl;

        if (a + 1 == b) {
            if (root->sum(b, end_index) >= suma) {
                return b;
            }
            return a;
        }

        if (root->sum(m, end_index) >= suma) {
            a = m;
        } else {
            b = m;
        }
    }

    return a;
}




int ask_query(fish from, fish to) {
    if (from >= to) {
        //dbg << "Already good!" << endl;
        return 0;
    }
    if (fishes.size() == 0) {
        //dbg << "No fishes to eat :(" << endl;
        return -1;
    }

    fish weight_now = from;
    int result = 0;
    while(weight_now < to) {
        //dbg << "WEIGHT NOW: " << weight_now << "\n";

        if (fishes[0] >= weight_now) {
            //dbg << "Too small to try :(" << endl;
            return -1;
        }

        {
            auto greater_or_equal_to_weight = lower_bound(fishes.begin(), fishes.end(), weight_now);
            auto less_than_weight = greater_or_equal_to_weight;
            less_than_weight--;

            int index_of_less_than_weight = less_than_weight - fishes.begin();

            bool ok = root->nr_of_fishes(index_of_less_than_weight, index_of_less_than_weight) == 1;

            if (ok && weight_now + *less_than_weight >= to) {
                //dbg << "by eating " << *less_than_weight << " (index " << index_of_less_than_weight << ") we can grow enough!" << endl;
                result++;
                return result;
            }
        }

        auto greater_or_equal_to_weight = lower_bound(fishes.begin(), fishes.end(), weight_now);
        
        if (greater_or_equal_to_weight == fishes.begin()) {
            //dbg << "Cannot eat! Smallest " << *fishes.begin() << endl;
            return -1;
        }

        if (greater_or_equal_to_weight == fishes.end()) {
            auto weight_left = to - weight_now;
            //dbg << "Only smaller! Weight left: " << weight_left << endl;

            auto index_done = min_index_with_sum(weight_left, fishes.size()-1);

            //dbg << "Eating [" << index_done << ", " << fishes.size()-1 << "]: " << root->sum(index_done, fishes.size()-1) << endl;

            weight_now += root->sum(index_done, fishes.size()-1);
            result += root->nr_of_fishes(index_done, fishes.size()-1);

            if (weight_now >= to) {
                return result;
            } else {
                return -1;
            }
        }

        auto weight_to_eat = *greater_or_equal_to_weight - weight_now + 1;
        int index_of_weight_to_eat = greater_or_equal_to_weight - fishes.begin();

        auto index_done = min_index_with_sum(weight_to_eat, index_of_weight_to_eat-1);

        //dbg << "To eat fish " << *greater_or_equal_to_weight << " (index " << index_of_weight_to_eat << ")" <<
        //       " you need to eat " << weight_to_eat << " [weight]. Can do that by eating [" << index_done << ", " <<
        //       index_of_weight_to_eat-1 << "]: fishes " << root->nr_of_fishes(index_done, index_of_weight_to_eat-1) << endl;
        

        //dbg << "Increased weight by " << root->sum(index_done, index_of_weight_to_eat-1);

        weight_now += root->sum(index_done, index_of_weight_to_eat-1);
        result += root->nr_of_fishes(index_done, index_of_weight_to_eat-1);
        root->zero(index_done, index_of_weight_to_eat-1);

        //dbg << " to actual: " << weight_now << endl;;

        if (weight_now >= to) {
            return result;
        }

        if (weight_now <= *greater_or_equal_to_weight) {
            //dbg << "\nAte all I could but without success :(\n";
            return -1;
        }



        {
            auto greater_or_equal_to_weight = lower_bound(fishes.begin(), fishes.end(), weight_now);
            auto less_than_weight = greater_or_equal_to_weight;
            less_than_weight--;

            int index_of_less_than_weight = less_than_weight - fishes.begin();

            bool ok = root->nr_of_fishes(index_of_less_than_weight, index_of_less_than_weight) == 1;

            if (ok) {
                //dbg << "Eating smaller one! " << *less_than_weight << "(index " << index_of_less_than_weight << ")\n";

                weight_now += *less_than_weight;
                root->zero(index_of_less_than_weight, index_of_less_than_weight);
                result++;
            }
        }
    }
    //dbg << "DONE\n";
    return result;
}

void query(fish from, fish to) {
    //dbg << endl << endl;
    //dbg << "Query " << from << " -> " << to << endl;

    auto result = ask_query(from, to);
    cout << result << endl;

    for(auto& x: nodes_to_recover) {
        x->recover();
    }
    nodes_to_recover.clear();
}

void build_all() { 
    if (root) {
        root->delet();
        delete root;
    }

    fishes.clear();
    //dbg << "Fishes length = " << w.size() << endl;
    for(const auto& x: w) {
        //dbg << x << " ";
        fishes.push_back(x);
    }
    //dbg << endl;

    root = new Node();
    if (fishes.size() > 0) {
        root->build(fishes.data(), 0, fishes.size()-1);
#ifdef DEBUG
        root->print();
#endif
    }
}


int main() {
   std::ios_base::sync_with_stdio(false);
   std::cin.tie(nullptr);

    int n;
    cin >> n;
    for(int i = 0; i < n; ++i) {
        fish now;
        cin >> now;

        w.insert(now);
    }

    bool to_build = true;

    int queries;
    cin >> queries;

    while(queries--) {
        int type;
        cin >> type;

        if (type == 1) {
            fish from, to;
            cin >> from >> to;

            if (to_build) {
                to_build = false;
                //dbg << "Building all!" << endl;
                build_all();
            }

            query(from, to);
        } else if (type == 2) {
            // add fish
            fish x; 
            cin >> x;
            w.insert(x);

            to_build = true;
        } else if (type == 3) {
            // remove fish
            fish x; 
            cin >> x;
            w.erase(x);

            to_build = true;
        }
    }
}