#include <set>
#include <vector>
#include <algorithm>
#include <map>
#include <string>


#if defined (_MSC_VER)
#include <io.h>
// code specific to Visual Studio compiler
#else
#include "unistd.h"
#endif

using ull = unsigned long long;
using ll = long long;
int n;

int id_gen = 0;
std::multimap<ull, int> sprats;
std::vector<bool> eaten;

class Input {
public:
    Input() { bufpos = bufend = buffer; eof = false; }
    bool Eof() { return eof; }
    char Peek() { if (bufpos == bufend) Grab(); return *bufpos; }
    unsigned char UPeek() { return static_cast<unsigned char>(Peek()); }
    void SkipWS();
    template<class T> T Get();
    void operator()() {}
    template<class Arg, class... Args> void operator()(Arg& arg, Args&... args) {
        arg = Get<Arg>();
        operator()(args...);
    }
private:
    static const int BUFSIZE = 1 << 16;
    char buffer[BUFSIZE];
    char* bufpos;
    char* bufend;
    bool eof;
    void Grab();
};

void Input::Grab() {
    if (eof) return;
    bufpos = buffer;
    bufend = buffer + read(0, buffer, BUFSIZE);
    if (bufend == bufpos) { eof = true; *bufpos = 0; }
}

template<> inline char Input::Get<char>() {
    char res = Peek();
    ++bufpos;
    return res;
}

void Input::SkipWS() {
    while (isspace(UPeek())) Get<char>();
}

template<> unsigned Input::Get<unsigned>() {
    SkipWS();
    unsigned x = 0;
    while (isdigit(UPeek())) {
        x = 10u * x + (Get<char>() - '0');
    }
    return x;
}

template<> int Input::Get<int>() {
    SkipWS();
    bool neg = false;
    if (Peek() == '-') { neg = true; Get<char>(); }
    unsigned x = Get<unsigned>();
    if (neg) x = -x;
    return static_cast<int>(x);
}

template<> ull Input::Get<ull>() {
    SkipWS();
    ull x = 0;
    while (isdigit(UPeek())) {
        x = 10ULL * x + (Get<char>() - '0');
    }
    return x;
}

template<> ll Input::Get<ll>() {
    SkipWS();
    bool neg = false;
    if (Peek() == '-') { neg = true; Get<char>(); }
    ull x = Get<ull>();
    if (neg) x = -x;
    return static_cast<ll>(x);
}

template<>
std::string Input::Get<std::string>() {
    SkipWS();
    std::string s;
    while (!Eof() && !isspace(UPeek())) s += Get<char>();
    return s;
}

class Output {
public:
    void Flush();
    Output() :bufpos(buffer), BUFLIMIT(buffer + BUFSIZE - 100) {}
    ~Output() { Flush(); }
    void Put(char c);
    void Put(unsigned x);
    void Put(int x);
    void Put(ull x);
    void Put(ll x);
    void Put(const char* s);
    void Put(const std::string& s);

    void operator()() {}
    template<class Arg, class... Args> void operator()(const Arg& arg, const Args&... args) {
        Put(arg);
        operator()(args...);
    }
private:
    static const int BUFSIZE = 1 << 16;
    char buffer[BUFSIZE];
    char* bufpos;
    char* BUFLIMIT;
};

void Output::Flush() {
    char* p = buffer;
    while (p < bufpos) {
        p += write(1, p, bufpos - p);
    }
    bufpos = buffer;
}

inline void Output::Put(char c) {
    *bufpos = c;
    ++bufpos;
    if (bufpos >= BUFLIMIT) Flush();
}

void Output::Put(unsigned x) {
    char* old = bufpos;
    do {
        *bufpos = char('0' + x % 10u);
        x /= 10u;
        ++bufpos;
    } while (x);
    std::reverse(old, bufpos);
    if (bufpos >= BUFLIMIT) Flush();
}

void Output::Put(int x) {
    if (x < 0) {
        Put('-'); Put(-static_cast<unsigned>(x));
    }
    else {
        Put(static_cast<unsigned>(x));
    }
}

void Output::Put(ull x) {
    char* old = bufpos;
    do {
        *bufpos = char('0' + x % 10u);
        x /= 10u;
        ++bufpos;
    } while (x);
    std::reverse(old, bufpos);
    if (bufpos >= BUFLIMIT) Flush();
}

void Output::Put(ll x) {
    if (x < 0) {
        Put('-'); Put(-static_cast<ull>(x));
    }
    else {
        Put(static_cast<ull>(x));
    }
}

void Output::Put(const char* s) {
    while (*s) Put(*s++);
}

void Output::Put(const std::string& s) {
    for (char c : s) Put(c);
}

Input IN;
Output OUT;

void add_sprat(ull w)
{
	sprats.emplace(w, id_gen++);
}

void remove_sprat(ull w)
{
	const auto it = sprats.find(w);
	sprats.erase(it);
}

void process_query(ull s, ull k)
{
	ull eaten_count = 0;
	std::fill(eaten.begin(), eaten.end(), false);

	while (s < k && !sprats.empty())
	{
		auto it = sprats.lower_bound(s);
		if (it == sprats.begin())
			break;

		const auto eat_till_bigger_or_equal = it == sprats.end() ? k : std::min(it->first + 1, k);

		while (s < eat_till_bigger_or_equal && it != sprats.begin())
		{			
			it = std::prev(it);

			if (eaten[it->second])
				continue;
			
			s += it->first;
			eaten[it->second] = true;
			++eaten_count;
		}

		if (s < eat_till_bigger_or_equal)
			break;
	}

	if (s < k)
        OUT("-1\n");
	else
        OUT(static_cast<ull>(eaten_count), '\n');
}


void process_queries()
{
	int q;
	ull a, b;
	char type;
    IN(q);
	eaten.resize(n + q);

	while (q--)
	{
        IN.SkipWS();
        IN(type);
		if (type == '1')
		{
            IN(a, b);
			process_query(a, b);
		}
		else
		{
			if (type == '2')
			{
                IN(a);
				add_sprat(a);
			}
			else if (type == '3')
			{
                IN(a);
				remove_sprat(a);
			}
		}
	}
}

int main()
{
	ull x;
    IN(n);

	for (int i = 0; i < n; ++i)
	{
        IN(x);
		sprats.emplace(x, id_gen++);
	}

	process_queries();
	return 0;
}