// https://www.geeksforgeeks.org/avl-tree-set-2-deletion/
#include<bits/stdc++.h>
using namespace std;


typedef long long ll;
typedef long long TKey;

class Node {
    public:
    Node *left;
    Node *right;
    Node *parent;
    int height;
    TKey key;
    // extra data:
    int val;
    int cnt;
    ll sum;
};

class AVLTree {

public:

    Node *root;

    AVLTree() {
        root = NULL;
    }

    void insert(Node *newNode) {
        root = insertNode(root, newNode, NULL);
    }

    void remove(TKey key) {
        root = removeNode(root, key, NULL);
    }

    Node *find(TKey key) {
        Node *node = findLE(key);
        if (!node) return NULL;
        if (node->key != key) return NULL;
        return node;
    }

    Node *findLE(TKey key) {
        Node *node = root, *smaller = NULL;
        while (node) {
            if (key < node->key) {
                node = node->left;
            } else if (key > node->key) {
                smaller = node;
                node = node->right;
            } else {
                break;
            }
        }
        if (!node) return smaller;
        return node;
    }

    Node *pred(Node *node)
    {
        if (node->left != NULL) return getMax(node->left);
        if (node == root) return NULL;
        // find path to node
        Node *parent = root, *path[256];
        int len = 0;
        while (parent != node) {
            path[len++] = parent;
            if (node->key < parent->key) parent = parent->left; else parent = parent->right;
        }
        // here parent == node
        while (len > 0) {
            parent = path[--len];
            if (node == parent->right) return parent;
            node = parent;
        }
        return NULL;
    }

    Node *succ(Node *node)
    {
        if (node->right != NULL) return getMin(node->right);
        if (node == root) return NULL;
        // find path to node
        Node *parent = root, *path[256];
        int len = 0;
        while (parent != node) {
            path[len++] = parent;
            if (node->key < parent->key) parent = parent->left; else parent = parent->right;
        }
        // here parent == node
        while (len > 0) {
            parent = path[--len];
            if (node == parent->left) return parent;
            node = parent;
        }
        return NULL;
    }


    /* Given a non-empty binary search tree, return the node with minimum key value found in that tree.
    Note that the entire tree does not need to be searched. */
    Node* getMin() {
        return getMin(root);
    }

    Node* getMin(Node* node) {
        Node* current = node;
        /* loop down to find the leftmost leaf */
        while (current->left != NULL) current = current->left;
        return current;
    }

    Node* getMax() {
        return getMax(root);
    }

    Node* getMax(Node* node) {
        Node* current = node;
        /* loop down to find the rightmost leaf */
        while (current->right != NULL) current = current->right;
        return current;
    }





    Node* insertNode(Node* node, Node *newNode, Node *parent) {
        /* 1. Perform the normal BST rotation */
        if (node == NULL) {
            newNode->parent = parent;
            return newNode;
        }

        if (newNode->key < node->key) {
            node->left = insertNode(node->left, newNode, node);
        } else if (newNode->key > node->key) {
            node->right = insertNode(node->right, newNode, node);
        } else { // Equal keys not allowed
            return node;
        }

        /* 2. Update height of this ancestor node */
        node->height = 1 + maxHeight(node->left, node->right);

        /* 3. Get the balance factor of this ancestor node to check whether this node became unbalanced */
        int balance = getBalance(node);

        // If this node becomes unbalanced, then there are 4 cases:

        // Left Left Case
        if (balance > 1 && newNode->key < node->left->key) {
            childrenChanged(node);
            return rightRotate(node, parent);
        }

        // Right Right Case
        if (balance < -1 && newNode->key > node->right->key) {
            childrenChanged(node);
            return leftRotate(node, parent);
        }

        // Left Right Case
        if (balance > 1 && newNode->key > node->left->key) {
            node->left = leftRotate(node->left, node);
            childrenChanged(node);
            return rightRotate(node, parent);
        }

        // Right Left Case
        if (balance < -1 && newNode->key < node->right->key) {
            node->right = rightRotate(node->right, node);
            childrenChanged(node);
            return leftRotate(node, parent);
        }

        childrenChanged(node);
        /* return the (unchanged) node pointer */
        return node;
    }

    // Recursive function to delete a node with given key from subtree with given root. It returns root of the modified subtree.
    Node* removeNode(Node* node, TKey key, Node *parent) {
        // STEP 1: PERFORM STANDARD BST DELETE
        if (node == NULL) return NULL;

        node->parent = parent;

        if (key < node->key) {
            // If the key to be deleted is smaller than the node's key, then it lies in left subtree
            node->left = removeNode(node->left, key, node);
        } else if (key > node->key) {
            // If the key to be deleted is greater than the node's key, then it lies in right subtree
            node->right = removeNode(node->right, key, node);
        } else {
            // if key is same as node's key, then this is the node to be deleted
            // node with only one child or no child
            if (node->left == NULL || node->right == NULL) {
                Node *temp = node->left ? node->left : node->right;

                if (temp == NULL) {
                    // No child case
                    temp = node;
                    node = NULL;
                } else {
                    // One child case
                    *node = *temp; // Copy the contents of the non-empty child
                    node->parent = parent;
                }
                free(temp);
            } else {
                // node with two children: Get the inorder successor (smallest in the right subtree)
                Node* temp = getMin(node->right);
                // Copy the inorder successor's data to this node
                copyData(temp, node);
                // Delete the inorder successor
                node->right = removeNode(node->right, temp->key, node);
            }
        }

        // If the tree had only one node then return
        if (node == NULL) return node;

        // STEP 2: UPDATE HEIGHT OF THE CURRENT NODE
        node->height = 1 + maxHeight(node->left, node->right);

        // STEP 3: GET THE BALANCE FACTOR OF THIS NODE (to check whether this node became unbalanced)
        int balance = getBalance(node);

        // If this node becomes unbalanced, then there are 4 cases:

        // Left Left Case
        if (balance > 1 && getBalance(node->left) >= 0) {
            childrenChanged(node);
            return rightRotate(node, parent);
        }

        // Left Right Case
        if (balance > 1 && getBalance(node->left) < 0) {
            node->left = leftRotate(node->left, node);
            childrenChanged(node);
            return rightRotate(node, parent);
        }

        // Right Right Case
        if (balance < -1 && getBalance(node->right) <= 0) {
            childrenChanged(node);
            return leftRotate(node, parent);
        }

        // Right Left Case
        if (balance < -1 && getBalance(node->right) > 0) {
            node->right = rightRotate(node->right, node);
            childrenChanged(node);
            return leftRotate(node, parent);
        }

        childrenChanged(node);
        return node;
    }

private:

    Node *rightRotate(Node *y, Node *parent) {
        Node *x = y->left;
        Node *T2 = x->right;

        // Perform rotation
        x->right = y; y->parent = x;
        y->left = T2; if (T2) T2->parent = y;

        // Update heights
        y->height = maxHeight(y->left, y->right) + 1;
        x->height = maxHeight(x->left, x->right) + 1;

        x->parent = parent;
        childrenChanged(y);
        childrenChanged(x);
        // Return new root
        return x;
    }

    Node *leftRotate(Node *x, Node *parent) {
        Node *y = x->right;
        Node *T2 = y->left;

        // Perform rotation
        y->left = x; x->parent = y;
        x->right = T2; if (T2) T2->parent = x;

        // Update heights
        x->height = maxHeight(x->left, x->right) + 1;
        y->height = maxHeight(y->left, y->right) + 1;

        y->parent = parent;
        childrenChanged(x);
        childrenChanged(y);
        // Return new root
        return y;
    }

    // Get Balance factor of node N
    int getBalance(Node *N) {
        if (N == NULL) return 0;
        return height(N->left) - height(N->right);
    }

    int maxHeight(Node *a, Node *b) {
        int ah = height(a), bh = height(b);
        if (ah > bh) return ah;
        return bh;
    }

    int height(Node *N) {
        if (N == NULL) return 0;
        return N->height;
    }

    Node* createNode(TKey key)
    {
        Node* node = new Node();
        node->key = key;
        node->left = NULL;
        node->right = NULL;
        node->parent = NULL;
        node->height = 1; // new node is initially added at leaf
        return node;
    }

public:
    void copyData(Node *src, Node *dst) {
        dst->key = src->key;
        dst->cnt = src->cnt;
        dst->sum = src->sum;
        dst->val = src->val;
    }

    void childrenChanged(Node *node) {
        int lcnt = 0;
        if (node->left) lcnt = node->left->cnt;
        int rcnt = 0;
        if (node->right) rcnt = node->right->cnt;
        node->cnt = lcnt + rcnt + node->val;

        ll lsum = 0;
        if (node->left) lsum = node->left->sum;
        ll rsum = 0;
        if (node->right) rsum = node->right->sum;
        node->sum = lsum + rsum + node->key*node->val;
    }

    void insert(TKey key, int val) {
        Node *node = createNode(key);
        node->val = val;
        childrenChanged(node);
        insert(node);
    }

    void valueChanged(Node *node) {
        while (node) {
            childrenChanged(node);
            node = node->parent;
        }
    }

    void addVal(TKey key, int val) {
        Node *node;
        if (node = find(key)) {
            node->val += val;
            valueChanged(node);
            if (node->val == 0) {
                remove(key);
            }
        } else {
            insert(key, val);
        }
    }

    int ileRyb(Node *node, ll s) {
        if (s == node->sum) {
            return node->cnt;
        }
        int w = 0;
        if (node->right) {
            if (s >= node->right->sum) {
                w += node->right->cnt;
                s -= node->right->sum;
            } else {
                return ileRyb(node->right, s);
            }
        }
        if (s <= node->val * node->key) {
            w += (s + node->key - 1) / node->key;
            return w;
        } else {
            w += node->val;
            s -= node->val * node->key;
        }
        if (node->left) {
            w += ileRyb(node->left, s);
        }
        return w;
    }
};



AVLTree tree;

/*
int main()
{
    for (int i=0; i<=100; i++) {
        tree.addVal(i, 1);
    }
    for (int i=0; i<=100; i++) {
        tree.addVal(i, 1);
    }

    Node *n = tree.getMin();
    while (n) {
        printf("%d %d\n", n->key, n->val);
        n = tree.succ(n);
    }
    printf("rootcnt=%d rootsum=%d\n\n", tree.root->cnt, tree.root->sum);
    for (int i=0; i<100; i++) {
        tree.remove(i);
        printf("remove %d rootcnt=%d rootsum=%d\n", i, tree.root->cnt, tree.root->sum);
    }
    return 0;
}

*/


int atak(ll s, ll k) {
    int wynik = 0;
    AVLTree zjedzone;
    Node *it;
    while (s < k) {
        ll mniejsza; //, wieksza;
        if (!tree.root || tree.root->sum < k-s) {
            wynik = -1;
            break;
        }
        it = tree.findLE(s);
        if (it && it->key == s) it = tree.pred(it);
        int ile = 1;
        if (!it) { // wszystkie wieksze lub rowne
            wynik = -1;
            break;
        } else if (it == tree.getMax()) { // wszystkie mniejsze
            mniejsza = it->key;
            wynik += tree.ileRyb(tree.root, k-s);
            break;
        } else {
            mniejsza = it->key;
            // wieksza = tree.succ(it)->key;
            // ile = (wieksza-s+mniejsza)/mniejsza;
            // if (ile > it->val) ile = it->val;
        }
        tree.addVal(mniejsza, -ile);
        zjedzone.addVal(mniejsza, ile);
        s += ile*mniejsza;
        wynik += ile;
    }
    if (zjedzone.root) {
        for (it=zjedzone.getMin(); it != NULL; it = zjedzone.succ(it)) {
            tree.addVal(it->key, it->val);
        }
    }
    return wynik;
}

int main()
{
    int n, q;
/*
    ll i, sum;
    n=100000;
    for (i=1; i<=n; i++) {
        tree.addVal(i, 1);
        sum = ((i+1)*i)/2;
        if (tree.root->sum != sum) {
            break;
        }
    }

    printf("i=%d\n", i);
    //printf("%d %d %d %d %d\n", ryby.begin(), ryby.end(), ryby.lower_bound(-4), ryby.lower_bound(-4)->first, (--ryby.end())->first);
    return 0;
*/
    scanf("%d", &n);
    for (int i=0; i<n; i++) {
        ll w;
        scanf("%lld", &w);
        tree.addVal(w, 1);
    }

    //printf("sum=%lld cnt=%d key=%lld val=%d\n", tree.root->sum, tree.root->cnt, tree.root->key, tree.root->val);
    //return 0;
    scanf("%d", &q);
    for (int i=0; i<q; i++) {
        int t;
        ll s, k, w;
        scanf("%d", &t);
        //printf("i=%d\n", i);
        if (t == 1) {
            scanf("%lld %lld", &s, &k);
            printf("%d\n", atak(s, k));
        } else if (t == 2) {
            scanf("%lld", &w);
            tree.addVal(w, 1);
        } else {
            scanf("%lld", &w);
            tree.addVal(w, -1);
        }
    }

    return 0;
}