#include <iostream>
#include <vector>
#include <algorithm>
#include <fstream>
#include <string>
#include <list>

//struct cup {
//	long long l, a, b;
//};
//
//struct less_than_a
//{
//	inline bool operator() (const cup& struct1, const cup& struct2)
//	{
//		return (struct1.a < struct2.a);
//	}
//};
//struct less_than_b
//{
//	inline bool operator() (const cup& struct1, const cup& struct2)
//	{
//		return (struct1.b < struct2.b);
//	}
//};
//
//void test(int i) {
//	const std::string path_in = "MS" + std::to_string(i) + ".in";
//
//	const std::string path_out = "MS" + std::to_string(i) + ".out";
//
//
//	std::ifstream in_in(path_in);
//
//	std::ifstream in_out(path_out);
//
//
//	if (!in_in.good() || !in_out.good()) return;
//
//	int t;	//num of test
//	in_in >> t;
//	int n_correct = 0;
//	for (int i = 0; i < t; i++)
//	{
//		int n;	//num of teas
//		in_in >> n;
//		std::vector<cup> tab(n);
//		long long startSum = 0;
//		long long endSum = 0;
//		for (int j = 0; j < n; j++)
//		{
//			//a-starting temp, b-desired temp
//			in_in >> tab[j].l >> tab[j].a >> tab[j].b;
//			startSum += tab[j].l * tab[j].a;
//			endSum += tab[j].l * tab[j].b;
//		}
//		std::string correct_answear;
//		in_out >> correct_answear;
//		if(std::min_element(tab.begin(), tab.end(), less_than_a())->a <= std::min_element(tab.begin(), tab.end(), less_than_b())->b &&
//			std::max_element(tab.begin(), tab.end(), less_than_a())->a >= std::max_element(tab.begin(), tab.end(), less_than_b())->b &&
//			startSum == endSum){
//			if (correct_answear == "TAK")
//				++n_correct;
//			else
//				std::cout << "XD";
//		}
//		else {
//			if (correct_answear == "NIE")
//				++n_correct;
//			else
//				std::cout << "XD";
//		}
//	}
//	std::cout << (float)n_correct / t << '\n';
//}

std::pair<int, int> eatAtBegin(std::vector<bool>& isEaten, int threshold, std::list<long long>::iterator& startIt, int startIndex) {
	std::list<long long>::iterator currIt = startIt;
	int tempEaten = 0;
	int numOfEaten = 0;
	for (int i = startIndex - 1; i >= 0; i--)
	{
		--currIt;
		if (!isEaten[i]) {
			isEaten[i] = true;
			tempEaten += *currIt;
			++numOfEaten;
		}
		if (tempEaten >= threshold) {
			return std::make_pair(tempEaten, numOfEaten);
		}
	}
	return std::make_pair(-1, -1);
}

int main() {
	std::ios_base::sync_with_stdio(0);
	std::cin.tie(0);
	/*for (int i = 1; i <= 100; i++)
	{
		test(i);
	}*/
	int n;
	std::cin >> n;
	std::list<long long> sortedTab(n);	//moze forward_list
	std::list<long long>::iterator it = sortedTab.begin();
	for  (int i = 0; i < n; i++)
	{
		long long w;
		std::cin >> w;
		*it = w;
		++it;
	}
	sortedTab.sort();
	int q;
	std::cin >> q;
	for (int i = 0; i < q; i++)
	{
		int type;
		std::cin >> type;
		int size = sortedTab.size();
		if (type == 1) {
			int s, k;
			std::cin >> s >> k;

			std::vector<bool> isEaten(size, false);
			std::list<long long>::iterator startIt;
			int startIndex = 0;
			std::list<long long>::iterator currentIt = sortedTab.begin();
			bool foundLargestPosFish = false;
			long long sum = 0;
			long long numOfFish = 0;
			//maybe binsearch?
			for (int j = 1; j <= size; j++)
			{
				std::list<long long>::iterator lastIt = currentIt++;
				if (j == size && !foundLargestPosFish && *lastIt <= s) {
					foundLargestPosFish = true;
					startIt = lastIt;
					startIndex = j - 1;
				}
				else if (!foundLargestPosFish && *currentIt > s && *lastIt <= s) {
					//znaleziona najwieksza mniejsza
					foundLargestPosFish = true;
					startIt = lastIt;
					startIndex = j - 1;
				}
				if (foundLargestPosFish) {
					if (*lastIt < s + sum) {
						target:
						sum += *lastIt;
						isEaten[j - 1] = true;
						++numOfFish;
					}

					else {
						//nie udalo sie trzeba wrocic na pocz

						std::pair<int, int> result = eatAtBegin(isEaten, 
							*lastIt - sum - s < k - sum - s ? *lastIt - sum - s: k - sum - s, 
							startIt, startIndex);
						if (result.first == -1) {
							std::cout << "-1\n";
							break;
						}
						else {
							numOfFish += result.second;
							sum += result.first;
							if(*lastIt < s + sum && s + sum < k)
								goto target;
						}

					}
					if (j == size && s + sum < k && numOfFish != size) {
						std::pair<int, int> result = eatAtBegin(isEaten,
							*lastIt - sum - s < k - sum - s ? *lastIt - sum - s : k - sum - s,
							startIt, startIndex);
						if (result.first == -1) {
							std::cout << "-1\n";
							break;
						}
						else {
							numOfFish += result.second;
							sum += result.first;
						}
					}
				}
				if (s + sum >= k) {
					std::cout << numOfFish << '\n';
					break;
					//found sum
				}
				else if (j == size) {
					std::cout << "-1\n";
				}
			}
			/*if (s + sum < k) {
				//for (std::list<long long>::iterator it = startIt; it != sortedTab.begin(); it--)//nie zejdzie do konca
				for (int j = startIndex; j > 0; j--)
				{
					if (s + sum >= k) {
						break;
					}
					else {
						sum += *startIt;
						numOfFish++;
						--startIt;
					}

				}
			}
			if (s + sum < k) {
				std::cout << "-1\n";
			}
			else
				std::cout << numOfFish << '\n';*/
		}
		if (type == 2) {
			long long w;
			std::cin >> w;
			std::list<long long>::iterator curr = sortedTab.begin();
			std::list<long long>::iterator last;
			for (int j = 0; j < size; j++)
			{
				last = curr++;
				if (*last <= w && *curr >= w) {
					sortedTab.insert(curr, w);
					break;
				}
			}
		}
		if (type == 3) {
			long long w;
			std::cin >> w;
			std::list<long long>::iterator curr = sortedTab.begin();
			for (int j = 0; j < size; j++)
			{
				if (*curr == w) {
					sortedTab.erase(curr);
					break;
				}
				++curr;
			}
		}
	}
}