#include <cstdio>
#include <cstdlib>
#include <iostream>
#include <fstream>
#include <sstream>
#include <set>
#include <map>
#include <vector>
#include <list>
#include <algorithm>
#include <cstring>
#include <cmath>
#include <string>
#include <queue>
#include <bitset>		//UWAGA - w czasie kompilacji musi byc znany rozmiar wektora - nie mozna go zmienic
#include <cassert>
#include <iomanip>		//do setprecision
#include <ctime>
#include <complex>
#include <chrono>
#include<unordered_map>
using namespace std;

#define FOR(i,b,e) for(int i=(b);i<(e);++i)
#define FORQ(i,b,e) for(int i=(b);i<=(e);++i)
#define FORD(i,b,e) for(int i=(b)-1;i>=(e);--i)
#define REP(x, n) for(int x = 0; x < (n); ++x)
#define ALL(u) (u).begin(),(u).end()

#define ST first
#define ND second
#define PB push_back
#define MP make_pair
#define LL long long
#define ULL unsigned LL
#define LD long double

typedef pair<int, int> PII;

const double pi = 3.141592653589793238462643383279502884197169399375105820974944592307816406286208998628034825342;

const int MS = 1e5 + 10;
const int MT = 3e5 + 10;

// jesli pierwsza liczba jest < 0, to mamy szczupaka
pair<LL,LL> Q[MS];

// wagi szprotek na wejsciu
LL w[MT];

// pozycje szprotek w drzewie
int pos[MT];
// pozycje szprotek z zapytan w drzewie - tylko tych, co dodajemy, przy usuwaniu, wyrzucamy ostatnia z grupy
int posQ[MS];

void getPos(vector<pair<LL, int>> &V)
{
	sort(V.begin(), V.end());
	REP(i, V.size())
		if (V[i].second < 0)
			pos[-(V[i].second + 1)] = i + 1;
		else
			posQ[V[i].second] = i + 1;
}

namespace BIT
{
	const int MR = (1 << 20) + 10;

	// rozmiar drzewa przedzialowego
	int SZ;

	struct interval
	{
		// poczatek i koniec
		int p, k;

		// ile jest szprotek na danym przedziale, ile zostalo zjedzonych
		// po pierwszym zablokowaniu tego przedzialu uaktualnisz ilez += ile
		// kolejne blokowania nie beda mialy wplywu, dopoki zjedzony nie spadnie do 0
		// ta wartosc poprawnie zostanie zaktualizowana w rodzicu
		// tak samo przy odblokowaniu
		int ile, ilez;

		// suma wag na danym przedziale - analogicznie do ilosci szprotek
		LL w, wz;

		// ile razy przedzial jest zablokowany
		int zjedzony;
	} tree[MR];

	void build(int nr, int p, int k)
	{
		tree[nr].p = p;
		tree[nr].k = k;

		if (p < k)
		{
			build(2 * nr, p, (p + k) / 2);
			build(2 * nr + 1, (p + k) / 2 + 1, k);
		}
	}

	void updatePos(int pos, LL w, int cnt)
	{
		// to bedzie mialo miejsce przy dodawaniu i usuwaniu szprotek - wtedy nic nie bedzie zablokowane
		// dlatego jedziemy od lisci do korzenia i aktualizujemy wszystko po drodze
		int nr = SZ + pos - 1;
		while (nr)
		{
			tree[nr].ile += cnt;
			tree[nr].w += w * cnt;
			nr >>= 1;
		}
	}

	int getLeft(int pos, LL w)
	{
		// mamy dany koniec przedzialu, gdzie bedziemy jesc i calkowita wage, ktora musimy spozyc
		// jedz w lewo i sprawdzaj, gdzie jest maksymalny lewy koniec, ktory da nam odp sume
		// zauwaz, ze jesli mamy jakies zablokowane przedzialy, to one wniosa 0 do sumy, wiec jest ok

		// idz w gore - wiemy, ze na sciezce do korzenia nic nie jest zablokowane
		int nr = SZ + pos - 1;
		// jesli idziemy z lewego syna do gory, to musimy odjac wartosc prawego
		LL sub = 0;
		while (nr)
		{
			if (tree[nr].w - sub >= w)
				break;

			if ((nr & 1) == 0)
			{
				// idziemy z lewego syna, wiec odejmij wartosci z prawego
				// zeby rodzic mial wartosc konczaca sie w prawym koncu, ktory jest w lewym dziecku
				sub += tree[nr + 1].w;
			}
			nr >>= 1;
		}

		// moze nam sie w ogole nie udac
		if (!nr)
			return -1;

		// teraz idz w dol szukajac maksymalnego lewego
		// wiemy, ze przyszlismy z prawego syna albo jestesmy ciagle w poczatkowym wezle
		// nie moglismy uzyskac nic przychodzac z lewego syna, bo odejmujemy prawy przedzial
		// wiec w rodzicu mamy taka sama wartosc, jak w lewym dziecku

		// zobacz, czy jeden wierzcholek nie wystarczy zeby zjesc tyle, ile trzeba
		if (tree[nr].p == tree[nr].k)
			return pos;

		// szukaj maksa w lewym dziecku - odejmij wartosc calego przedzialu
		LL left = w - (tree[nr].w - sub - tree[2 * nr].w);
		nr <<= 1;
		while (tree[nr].p < tree[nr].k)
		{
			// zobacz, czy prawy przedzial da nam wszystko z left
			if (tree[2 * nr + 1].w >= left)
				nr = 2 * nr + 1;
			else
			{
				left -= tree[2 * nr + 1].w;
				nr = 2 * nr;
			}
		}

		// znalezlismy poczatek
		return tree[nr].p;
	}

	// przedzial do zmiany o v, 1 - zjadamy, -1 oddajemy
	// zauwaz, ze algorytm nie bedzie zjadal niczego w srodku juz zjedzonego przedzialu
	// dlatego nie ma potrzeby na lazy propagation
	// bedziemy zjadali wielokrotnie ten sam przedzial, ale dlatego, ze bedziemy pozerac coraz wieksze, zawierajace go przedzialy
	int p, k;
	LL w;
	int ile;
	void change(int nr, int v)
	{
		// spr, czy przedzial jest rozlaczny
		if (tree[nr].p > k || tree[nr].k < p)
			return;

		// spr czy sie zawiera caly
		if (tree[nr].p >= p && tree[nr].k <= k)
		{

			if (v == 1)
			{
				// zjedz
				ile += tree[nr].ile;
				tree[nr].ilez += tree[nr].ile;
				tree[nr].ile = 0;

				w += tree[nr].w;
				tree[nr].wz += tree[nr].w;
				tree[nr].w = 0;

				tree[nr].zjedzony++;
			}
			else
			{
				tree[nr].zjedzony--;

				// algorytm bedzie zmienial na stosie, czyli to, co bylo zjedzone za pierwszym razem
				// jako ostatnie bedzie oddane
				// czyli przywrocenie wartosci dopiero, gdy ilosc zjedzonych wroci z powrotem na 0
				if (!tree[nr].zjedzony)
				{
					tree[nr].ile = tree[nr].ilez;
					tree[nr].ilez = 0;

					tree[nr].w = tree[nr].wz;
					tree[nr].wz = 0;
				}
			}

			return;
		}

		// jedz do dzieci i uaktualnij wartosci
		change(2 * nr, v);
		change(2 * nr + 1, v);

		tree[nr].ile = tree[2 * nr].ile + tree[2 * nr + 1].ile;
		tree[nr].w = tree[2 * nr].w + tree[2 * nr + 1].w;
	}
}// BIT

void clean(vector<PII>& V)
{
	while (!V.empty())
	{
		BIT::p = V.back().first;
		BIT::k = V.back().second;
		BIT::change(1, -1);
		V.pop_back();
	}
}

int attack(LL w, LL k, const set<pair<LL, int>> &S)
{
	if (w >= k)
		return 0;

	// symulacja ataku szczupaka

	// zobacz, czy cokolwiek zezre
	auto it = S.lower_bound(MP(w, -1));
	if (it == S.begin())
		return -1;
	
	// odznacz zjedzona sume wag, liczbe szprotek i pary przedzialow
	LL zjadl = 0;
	int ile = 0;
	vector<PII> V;
	// poszukuj, dopoki nie bedzie mogl zjesc wszystkich
	while (it != S.end())
	{
		// zobacz ile potrzebujesz zjesc, zeby moc wsunac next
		LL left = it->first - (w + zjadl) + 1;
		if (left > 0)
		{
			// cos musisz zjesc -> musisz skonczyc na poprzedniku it
			it--;
			// zobacz, czy przypadkiem nie osiagniesz limitu jedzac
			if (left >= k - (w + zjadl))
			{
				// mozesz przerwac, sprobuj zjesc wszystko do limitu
				BIT::p = BIT::getLeft(it->second, k - (w + zjadl));
				if (BIT::p == -1)
				{
					// nie da sie
					clean(V);
					return -1;
				}

				// da sie
				BIT::k = it->second;
				BIT::ile = 0;
				BIT::change(1, 1);
				ile += BIT::ile;
				V.push_back(MP(BIT::p, BIT::k));

				clean(V);
				return ile;
			}

			// musisz zjesc tyle, zeby moc chapnac nastepnego
			BIT::p = BIT::getLeft(it->second, left);
			if (BIT::p == -1)
			{
				// nie da sie
				clean(V);
				return -1;
			}

			// zjedz to wszystko
			BIT::k = it->second;
			BIT::ile = 0;
			BIT::w = 0;
			BIT::change(1, 1);
			ile += BIT::ile;
			zjadl += BIT::w;
			V.push_back(MP(BIT::p, BIT::k));

			// zobacz, czy przypadkiem nie osiagnales juz odpowiedniego limitu
			// na pewno ten limit byl wiekszy niz to, co musiales zjesc do nastepnego
			// ale mogles zjesc wiecej niz potrzeba
			if (w + zjadl >= k)
			{
				clean(V);
				return ile;
			}
		}

		//  szukaj jak najwiekszego do zjedzenia
		it = S.lower_bound(MP(w + zjadl, -1));
	}

	// jestesmy na koncu i teraz moze zjesc wszystko, zobacz ile mu brakuje
	it--;
	LL left = k - (w + zjadl);
	BIT::p = BIT::getLeft(it->second, left);

	if (BIT::p == -1)
	{
		// nie da rady -> wyczysc przedzialy i zwroc wynik
		clean(V);
		return -1;
	}

	// zjedz tyle, ile trzeba
	BIT::k = it->second;
	BIT::ile = 0;
	BIT::change(1, 1);
	ile += BIT::ile;
	V.push_back(MP(BIT::p, BIT::k));

	// wyczysc
	clean(V);

	return ile;
}

int main()
{
	vector<pair<LL, int>> tmppos;

	int n;
	scanf("%d", &n);
	REP(i, n)
	{
		scanf("%lld", &w[i]);
		tmppos.push_back(MP(w[i], -(i + 1)));
	}

	int q;
	scanf("%d", &q);
	REP(i, q)
	{
		int typ;
		scanf("%d", &typ);
		if (typ == 1)
		{
			scanf("%lld%lld", &Q[i].first, &Q[i].second); Q[i].first = -Q[i].first;
		}
		else
		{
			Q[i].first = typ;
			scanf("%lld", &Q[i].second);

			if (typ == 2)
				tmppos.push_back(MP(Q[i].second, i));
		}
	}

	// wyznacz pozycje szprotek
	getPos(tmppos);

	// jedna z 2 glownych struktur - set z wagami szprotek i ich pozycjami w drzewie
	set<pair<LL, int>> S;

	// przygotuj drzewo
	BIT::SZ = 1;
	while (BIT::SZ < tmppos.size())
		BIT::SZ <<= 1;
	BIT::build(1, 1, BIT::SZ);
	// wrzuc pozycje
	REP(i, n)
	{
		BIT::updatePos(pos[i], w[i], 1);
		S.insert(MP(w[i], pos[i]));
	}

	// jedz queries
	REP(i, q)
	{
		if (Q[i].first > 0)
		{
			if (Q[i].first == 2)
			{
				BIT::updatePos(posQ[i], Q[i].second, 1);
				S.insert(MP(Q[i].second, posQ[i]));
			}
			else
			{
				auto it = S.upper_bound(MP(Q[i].second, BIT::SZ + 1)); it--;
				BIT::updatePos(it->second, Q[i].second, -1);
				S.erase(it);
			}
		}
		else
			printf("%d\n", attack(-Q[i].first, Q[i].second, S));
	}

	return 0;
}

// FOR GNU C++ use the following pattern:
// Uncomment the code below and change your main into main2
// It does not build in MS C++
// But it does increase the stack size from 256 MB on CF and uses GNU C++

//#include <Processthreadsapi.h>
//#include <iostream>
//#include <Synchapi.h>
//#include <windows.h>
//#include <process.h>
//
//DWORD WINAPI MyThreadFunction(LPVOID lpParam) {
//    main2(nullptr);
//    return 0;
//}
//int main() {
//    auto h = CreateThread(nullptr, 1024 << 20, MyThreadFunction, nullptr, STACK_SIZE_PARAM_IS_A_RESERVATION, nullptr);
//    WaitForSingleObject(h, INFINITE);
//}