#include <cstdio>
#include <iostream>
#include <map>
#include <ctime>
#include <cstdlib>
#include <vector>
#include <set>
#include <cassert>
#include <algorithm>
using namespace std;

typedef long long ll;

class RemovingNonExistingWeightException
{};

/*class SpratsDatabase
{
	typedef map<ll, ll> Sprats;
public:
	int GetMinimalNumberOfEatenSprats(ll currentCatfishWeight, ll targetCatfishWeight)
	{
		if (IsDone(currentCatfishWeight, targetCatfishWeight))
			return 0;
		if (IsSimplyImmpossible(currentCatfishWeight, targetCatfishWeight))
			return -1;

		int result = 0;
		while (currentCatfishWeight < targetCatfishWeight)
		{
			Sprats::iterator it = FindTheBiggestWeightLowerThanGiveWeight(currentCatfishWeight);
			if (it == spratWeightToQuantity.end())
				return -1;
			++result;
			currentCatfishWeight += it->first;
			RemoveExistingWeight(it);
		}

		return result;
	}

	void AddWeight(const ll& weight)
	{
		++spratWeightToQuantity[weight];
		sumOfAllWeights += weight;
	}

	void RemoveWeight(const ll& weight)
	{
		Sprats::iterator it = spratWeightToQuantity.find(weight);
		if (it == spratWeightToQuantity.end())
			throw RemovingNonExistingWeightException();

		RemoveExistingWeight(it);
	}
private:
	
	bool IsSimplyImmpossible(const ll& currentCatfishWeight, const ll& targetCatfishWeight)
	{
		return sumOfAllWeights < targetCatfishWeight - currentCatfishWeight
			|| spratWeightToQuantity.begin()->first >= currentCatfishWeight;
	}

	bool IsDone(const ll& currentCatfishWeight, const ll& targetCatfishWeight)
	{
		return targetCatfishWeight <= currentCatfishWeight;
	}

	void RemoveExistingWeight(Sprats::iterator it)
	{
		sumOfAllWeights -= it->first;
		--it->second;

		if (it->second == 0)
			spratWeightToQuantity.erase(it);
	}

	Sprats::iterator FindTheBiggestWeightLowerThanGiveWeight(ll weight)
	{
		if (spratWeightToQuantity.empty() || spratWeightToQuantity.begin()->first >= weight)
			return spratWeightToQuantity.end();

		Sprats::iterator result = spratWeightToQuantity.lower_bound(weight);
		if (result == spratWeightToQuantity.end())
		{
			if (spratWeightToQuantity.empty())
				return result;
			else
				--result;
		}
			
		if (result->first < weight)
			return result;

		return --result;
	}
	
	Sprats spratWeightToQuantity;
	ll sumOfAllWeights = 0;
};

class SmartSpratsDatabase
{
	typedef map<ll, ll> Sprats;
public:
	int GetMinimalNumberOfEatenSprats(ll currentCatfishWeight, ll targetCatfishWeight)
	{
		if (IsDone(currentCatfishWeight, targetCatfishWeight))
			return 0;
		if (IsSimplyImmpossible(currentCatfishWeight, targetCatfishWeight))
			return -1;

		int result = 0;
		while (currentCatfishWeight < targetCatfishWeight)
		{
			Sprats::iterator it = FindTheBiggestWeightLowerThanGiveWeight(currentCatfishWeight);
			if (it == spratWeightToQuantity.end())
			{
				RestoreRemovedWeights();
				return -1;
			}
			++result;
			currentCatfishWeight += it->first;
			RemoveExistingWeight(it, true);
		}

		RestoreRemovedWeights();
		return result;
	}

	void AddWeight(const ll& weight)
	{
		++spratWeightToQuantity[weight];
		sumOfAllWeights += weight;
	}

	void RemoveWeight(const ll& weight)
	{
		Sprats::iterator it = spratWeightToQuantity.find(weight);
		if (it == spratWeightToQuantity.end())
			throw RemovingNonExistingWeightException();

		RemoveExistingWeight(it, false);
	}
private:

	bool IsSimplyImmpossible(const ll& currentCatfishWeight, const ll& targetCatfishWeight)
	{
		return sumOfAllWeights < targetCatfishWeight - currentCatfishWeight
			|| spratWeightToQuantity.begin()->first >= currentCatfishWeight;
	}

	bool IsDone(const ll& currentCatfishWeight, const ll& targetCatfishWeight)
	{
		return targetCatfishWeight <= currentCatfishWeight;
	}

	void RemoveExistingWeight(Sprats::iterator it, bool shouldTrace)
	{
		if (shouldTrace)
			removedWeights.push_back(it->first);

		sumOfAllWeights -= it->first;
		--it->second;

		if (it->second == 0)
			spratWeightToQuantity.erase(it);
	}

	Sprats::iterator FindTheBiggestWeightLowerThanGiveWeight(ll weight)
	{
		if (spratWeightToQuantity.empty() || spratWeightToQuantity.begin()->first >= weight)
			return spratWeightToQuantity.end();

		Sprats::iterator result = spratWeightToQuantity.lower_bound(weight);
		if (result == spratWeightToQuantity.end())
		{
			if (spratWeightToQuantity.empty())
				return result;
			else
				--result;
		}

		if (result->first < weight)
			return result;

		return --result;
	}

	void RestoreRemovedWeights()
	{
		for (int i = 0; i < removedWeights.size(); ++i)
			AddWeight(removedWeights[i]);

		removedWeights.clear();
	}

	Sprats spratWeightToQuantity;
	ll sumOfAllWeights = 0;
	vector<ll> removedWeights;
};*/

struct Query
{
	Query() {}
	Query(short t, ll fP, ll sP)
		: type(t), firstParam(fP), secondParam(sP)
	{}
	short type;
	ll firstParam, secondParam;
};

struct Input
{
	int numberOfSprats;
	vector<ll> spratsWeight;
	int numberOfqueries;
	vector<Query> queries;
};

class Hasher
{
public:
	Hasher(const Input& input)
	{
		vector<ll> sprats(input.spratsWeight.begin(), input.spratsWeight.end());
		for (int i = 0; i < input.queries.size(); ++i)
		{
			const Query& currentQuery = input.queries[i];
			if (currentQuery.type == 2)
				sprats.push_back(currentQuery.firstParam);
		}

		Initialize(sprats);
	}
	Hasher(vector<ll> numberToComputeHash)
	{
		Initialize(numberToComputeHash);
	}

	int GetHash(ll number)
	{
		return numberToHash[number];
	}

	ll GetNumber(int hash)
	{
		return hashToNumber[hash];
	}

	const set<ll>& GetAllNumberWithHashes()
	{
		return allNumberWithHashes;
	}

	const vector<ll>& GetAllNumberWithHashesVector()
	{
		return allNumberWithHashesVector;
	}
private:
	void Initialize(vector<ll> numberToComputeHash)
	{
		allNumberWithHashes = set<ll>(numberToComputeHash.begin(), numberToComputeHash.end());
		int hash = 1;
		for (set<ll>::reverse_iterator it = allNumberWithHashes.rbegin(); it != allNumberWithHashes.rend(); ++it)
		{
			numberToHash[*it] = hash;
			hashToNumber[hash++] = *it;
		}

		allNumberWithHashesVector = vector<ll>(allNumberWithHashes.begin(), allNumberWithHashes.end());
	}

	map<ll, int> numberToHash;
	map<int, ll> hashToNumber;
	set<ll> allNumberWithHashes;
	vector<ll> allNumberWithHashesVector;
};

class SumDatabase
{
public:
	SumDatabase(Hasher* hasher)
	{
		this->hasher = hasher;
		arraysSize = hasher->GetAllNumberWithHashes().size();
		sumOfNumberOfGivenHash = new ll[arraysSize + 1];
		numberOfNumbersOfGivenHash = new ll[arraysSize + 1];
		treeOfSum = new ll[arraysSize + 1];
		treeOfNumbers = new ll[arraysSize + 1];

		for (int i = 0; i <= arraysSize; ++i)
			sumOfNumberOfGivenHash[i] = numberOfNumbersOfGivenHash[i] = treeOfNumbers[i] = treeOfSum[i] = 0;
	}

	void AddNumber(ll number)
	{
		int hash = hasher->GetHash(number);
		sumOfNumberOfGivenHash[hash] += number;
		addSumToTree(treeOfSum, hash, number);
		++numberOfNumbersOfGivenHash[hash];
		addSumToTree(treeOfNumbers, hash, 1);
	}

	void RemoveNumber(ll number)
	{
		int hash = hasher->GetHash(number);
		sumOfNumberOfGivenHash[hash] -= number;
		addSumToTree(treeOfSum, hash, -number);
		--numberOfNumbersOfGivenHash[hash];
		addSumToTree(treeOfNumbers, hash, -1);
	}

	ll GetSumOfAllNumberOfHashNotGreaterThan(int hash)
	{
		return getSum(treeOfSum, hash);
	}

	ll GetNumberOfNumberOfHashNotGreaterThan(int hash)
	{
		return getSum(treeOfNumbers, hash);
	}

	void DumpDatabase()
	{
		const set<ll>& allNumberWithHash = hasher->GetAllNumberWithHashes();
		for (set<ll>::const_iterator it = allNumberWithHash.begin(); it != allNumberWithHash.end(); ++it)
		{
			int hash = hasher->GetHash(*it);
			printf("number: %lld, hash: %d\n", *it, hash);
			printf("GetSumOfAllNumberOfHashNotGreaterThan: %lld\n", GetSumOfAllNumberOfHashNotGreaterThan(hash));
			printf("GetNumberOfNumberOfHashNotGreaterThan: %lld\n", GetNumberOfNumberOfHashNotGreaterThan(hash));
		}
	}
	~SumDatabase()
	{
		delete sumOfNumberOfGivenHash;
		delete numberOfNumbersOfGivenHash;
		delete treeOfSum;
		delete treeOfNumbers;
	}
private:

	void addSumToTree(ll* targetTree, int index, ll delta)
	{
		const int numberOfElements = arraysSize;
		while (index <= numberOfElements)
		{
			targetTree[index] += delta;
			index += index & (-index);
		}
	}

	ll getSum(ll* targetTree, int index)
	{
		ll sum = 0;
		while (index > 0)
		{
			sum += targetTree[index];
			index -= index & (-index);
		}

		return sum;
	}
	Hasher* hasher;
	int arraysSize;
	ll* sumOfNumberOfGivenHash;
	ll* numberOfNumbersOfGivenHash;
	ll* treeOfSum;
	ll* treeOfNumbers;

};

class SmartSpratsDatabase2
{
	typedef map<ll, ll> Sprats;
public:
	SmartSpratsDatabase2(Hasher* hasher):
		sumDatabase(new SumDatabase(hasher))
	{
		this->hasher = hasher;
	}
	int GetMinimalNumberOfEatenSprats(ll currentCatfishWeight, ll targetCatfishWeight)
	{
		//sumDatabase->DumpDatabase();

		if (IsDone(currentCatfishWeight, targetCatfishWeight))
			return 0;
		if (IsSimplyImmpossible(currentCatfishWeight, targetCatfishWeight))
			return -1;

		int result = 0;
		while (currentCatfishWeight < targetCatfishWeight)
		{
			Sprats::iterator it = FindTheBiggestWeightLowerThanGiveWeight(currentCatfishWeight);
			if (it == spratWeightToQuantity.end())
			{
				RestoreRemovedWeights();
				return -1;
			}
			// je�li it wskazuje na szprotk� o najwi�kszej masie i masa szczupaka jest od niej wi�ksza,
			// to znaczy, �e mo�na zjada� wszystkie szprotki poczynaj�c od najwi�kszych
			else if (it->first == spratWeightToQuantity.rbegin()->first && currentCatfishWeight > it->first)
			{
				//sumDatabase->DumpDatabase();
				//result = ComputeResulutAssumingThatCatfishCanEatAnySprat(currentCatfishWeight, targetCatfishWeight, result);
				result = ComputeResulutAssumingThatCatfishCanEatAnySprat2(currentCatfishWeight, targetCatfishWeight, result);
				RestoreRemovedWeights();
				return result;
			}
			else
			{
				++result;
				currentCatfishWeight += it->first;
				RemoveExistingWeight(it, true);
			}
		}

		RestoreRemovedWeights();
		return result;
	}

	void AddWeight(const ll& weight)
	{
		++spratWeightToQuantity[weight];
		sumOfAllWeights += weight;
		sumDatabase->AddNumber(weight);
	}

	void RemoveWeight(const ll& weight)
	{
		Sprats::iterator it = spratWeightToQuantity.find(weight);
		if (it == spratWeightToQuantity.end())
			throw RemovingNonExistingWeightException();

		RemoveExistingWeight(it, false);
	}

	~SmartSpratsDatabase2()
	{
		delete sumDatabase;
	}

private:

	bool IsSimplyImmpossible(const ll& currentCatfishWeight, const ll& targetCatfishWeight)
	{
		return sumOfAllWeights < targetCatfishWeight - currentCatfishWeight
			|| spratWeightToQuantity.begin()->first >= currentCatfishWeight;
	}

	bool IsDone(const ll& currentCatfishWeight, const ll& targetCatfishWeight)
	{
		return targetCatfishWeight <= currentCatfishWeight;
	}

	void RemoveExistingWeight(Sprats::iterator it, bool shouldTrace)
	{
		if (shouldTrace)
			removedWeights.push_back(it->first);

		sumOfAllWeights -= it->first;
		--it->second;
		sumDatabase->RemoveNumber(it->first);

		if (it->second == 0)
			spratWeightToQuantity.erase(it);
	}

	Sprats::iterator FindTheBiggestWeightLowerThanGiveWeight(ll weight)
	{
		if (spratWeightToQuantity.empty() || spratWeightToQuantity.begin()->first >= weight)
			return spratWeightToQuantity.end();

		Sprats::iterator result = spratWeightToQuantity.lower_bound(weight);
		if (result == spratWeightToQuantity.end())
		{
			if (spratWeightToQuantity.empty())
				return result;
			else
				--result;
		}

		if (result->first < weight)
			return result;

		return --result;
	}

	void RestoreRemovedWeights()
	{
		for (int i = 0; i < removedWeights.size(); ++i)
		{
			AddWeight(removedWeights[i]);
			//sumDatabase->AddNumber(removedWeights[i]);
			//sumDatabase->DumpDatabase();
		}

		removedWeights.clear();
	}

	int ComputeResulutAssumingThatCatfishCanEatAnySprat(ll currentCatfishWeight, ll targetCatfishWeight, int alreadyEatenSprats)
	{
		if (targetCatfishWeight <= currentCatfishWeight)
			return alreadyEatenSprats;
		if (currentCatfishWeight <= spratWeightToQuantity.rbegin()->first)
			throw string("currentCatfishWeight <= spratWeightToQuantity.rbegin()->first");

		int result = alreadyEatenSprats;
		for (Sprats::reverse_iterator it = spratWeightToQuantity.rbegin(); it != spratWeightToQuantity.rend(); ++it)
		{
			const ll potentialWeight = currentCatfishWeight + it->second * it->first;
			if (potentialWeight >= targetCatfishWeight)
			{
				const int missingWeight = targetCatfishWeight - currentCatfishWeight;
				return result + missingWeight / it->first
					+ (missingWeight % it->first == 0 ? 0 : 1);
			}
			else
			{
				currentCatfishWeight = potentialWeight;
				result += it->second;
			}
		}

		return -1;
	}

	int ComputeResulutAssumingThatCatfishCanEatAnySprat2(ll currentCatfishWeight, ll targetCatfishWeight, int alreadyEatenSprats)
	{
		if (currentCatfishWeight <= spratWeightToQuantity.rbegin()->first)
			throw string("currentCatfishWeight <= spratWeightToQuantity.rbegin()->first");

		int result = alreadyEatenSprats;
		const vector<ll>& allNumberWithHashes = hasher->GetAllNumberWithHashesVector();
		int pocz = 0, kon = allNumberWithHashes.size() - 1;
		ll elem, midSum;
		while (pocz <= kon)
		{
			int mid = pocz + (kon - pocz) / 2;
			elem = hasher->GetHash(allNumberWithHashes[mid]);
			ll sumToFind = targetCatfishWeight - currentCatfishWeight;
			ll midSum = sumDatabase->GetSumOfAllNumberOfHashNotGreaterThan(elem);

			if (midSum < sumToFind)
				kon = mid - 1;
			else
			{
				if (midSum > sumToFind)
					pocz = mid + 1;
				else
					return result + sumDatabase->GetNumberOfNumberOfHashNotGreaterThan(elem);
			}

		}
		/*kon = min(kon + 10, (int)allNumberWithHashes.size() - 1);
		elem = hasher->GetHash(allNumberWithHashes[kon]);
		midSum = sumDatabase->GetSumOfAllNumberOfHashNotGreaterThan(elem);
		return ComputeResulutAssumingThatCatfishCanEatAnySprat(currentCatfishWeight + midSum, targetCatfishWeight, alreadyEatenSprats
			+ sumDatabase->GetNumberOfNumberOfHashNotGreaterThan(elem));*/
		elem = hasher->GetHash(allNumberWithHashes[0]);
		if (sumDatabase->GetSumOfAllNumberOfHashNotGreaterThan(elem) < targetCatfishWeight - currentCatfishWeight)
			return -1;

		kon = min(kon + 10, (int)allNumberWithHashes.size() - 1);
		elem = hasher->GetHash(allNumberWithHashes[kon]);
		midSum = sumDatabase->GetSumOfAllNumberOfHashNotGreaterThan(elem);
		while (kon >= 0)
		{
			elem = hasher->GetHash(allNumberWithHashes[kon]);
			midSum = sumDatabase->GetSumOfAllNumberOfHashNotGreaterThan(elem);
			if (currentCatfishWeight + midSum >= targetCatfishWeight)
			{
				if (currentCatfishWeight + midSum == targetCatfishWeight)
					return sumDatabase->GetNumberOfNumberOfHashNotGreaterThan(elem);
				else
				{
					const ll currentWeight = allNumberWithHashes[kon];
					const ll maxFishes = spratWeightToQuantity[allNumberWithHashes[kon]];
					const ll alreadyEaten = sumDatabase->GetNumberOfNumberOfHashNotGreaterThan(elem);
					for (int i = 0; i <= maxFishes; ++i)
					{
						if (midSum - maxFishes * currentWeight + currentCatfishWeight + i * currentWeight >= targetCatfishWeight)
							return alreadyEatenSprats + alreadyEaten - maxFishes + i;
					}
				}
			}
			--kon;
		}
		return -1;
		/*for (Sprats::reverse_iterator it = spratWeightToQuantity.rbegin(); it != spratWeightToQuantity.rend(); ++it)
		{
			const ll potentialWeight = currentCatfishWeight + it->second * it->first;
			if (potentialWeight >= targetCatfishWeight)
			{
				const int missingWeight = targetCatfishWeight - currentCatfishWeight;
				return result + missingWeight / it->first
					+ (missingWeight % it->first == 0 ? 0 : 1);
			}
			else
			{
				currentCatfishWeight = potentialWeight;
				result += it->second;
			}
		}*/
	}

	Sprats spratWeightToQuantity;
	ll sumOfAllWeights = 0;
	vector<ll> removedWeights;
	Hasher* hasher;
	SumDatabase* sumDatabase;
};

Input ReadInput()
{
	Input result;
	scanf("%d", &result.numberOfSprats);

	ll currentWeight, targetWeight;
	for (int i = 0; i < result.numberOfSprats; ++i)
	{
		scanf("%lld", &currentWeight);
		result.spratsWeight.push_back(currentWeight);
	}

	scanf("%d", &result.numberOfqueries);
	for (int queryNumber = 0; queryNumber < result.numberOfqueries; ++queryNumber)
	{
		Query query;
		scanf("%d", &query.type);
		switch (query.type)
		{
		case 1:
			scanf("%lld %lld", &currentWeight, &targetWeight);
			query.firstParam = currentWeight;
			query.secondParam = targetWeight;
			break;
		case 2:
			scanf("%lld", &currentWeight);
			query.firstParam = currentWeight;
			break;
		case 3:
			scanf("%lld", &currentWeight);
			query.firstParam = currentWeight;
			break;
		}

		result.queries.push_back(query);
	}

	return result;
}

void WriteOutput(const Input& input, SmartSpratsDatabase2& spratDatabase)
{
	for (int i = 0; i < input.spratsWeight.size(); ++i)
		spratDatabase.AddWeight(input.spratsWeight[i]);

	for (int query = 0; query < input.numberOfqueries; ++query)
	{
		const Query& currentQuery = input.queries[query];
		switch (currentQuery.type)
		{
		case 1:
			printf("%d\n", spratDatabase.GetMinimalNumberOfEatenSprats(currentQuery.firstParam, currentQuery.secondParam));
			break;
		case 2:
			spratDatabase.AddWeight(currentQuery.firstParam);
			break;
		case 3:
			spratDatabase.RemoveWeight(currentQuery.firstParam);
			break;
		}
	}
}

void Debug()
{
	vector<ll> numberToHash;
	for (int i = 1; i <= 10; ++i) numberToHash.push_back(i);
	Hasher hasher(numberToHash);
	SumDatabase sumDatabase(&hasher);
	for (int i = 0; i < numberToHash.size(); ++i)
	{
		assert(sumDatabase.GetNumberOfNumberOfHashNotGreaterThan(hasher.GetHash(numberToHash[i])) == 0);
		assert(sumDatabase.GetSumOfAllNumberOfHashNotGreaterThan(hasher.GetHash(numberToHash[i])) == 0);
	}

	for (int iterationNumber = 1; iterationNumber < 10; ++iterationNumber)
	{
		sumDatabase.AddNumber(1);
		assert(sumDatabase.GetNumberOfNumberOfHashNotGreaterThan(hasher.GetHash(1)) == iterationNumber);
		assert(sumDatabase.GetSumOfAllNumberOfHashNotGreaterThan(hasher.GetHash(1)) == iterationNumber);
		for (int i = 1; i < numberToHash.size(); ++i)
		{
			assert(sumDatabase.GetNumberOfNumberOfHashNotGreaterThan(hasher.GetHash(numberToHash[i])) == 0);
			assert(sumDatabase.GetSumOfAllNumberOfHashNotGreaterThan(hasher.GetHash(numberToHash[i])) == 0);
		}
	}

	for (int iterationNumber = 1; iterationNumber < 10; ++iterationNumber)
	{
		sumDatabase.AddNumber(2);
		assert(sumDatabase.GetNumberOfNumberOfHashNotGreaterThan(hasher.GetHash(1)) == iterationNumber + 9);
		assert(sumDatabase.GetSumOfAllNumberOfHashNotGreaterThan(hasher.GetHash(1)) == 9 + 2 * iterationNumber);
		for (int i = 2; i < numberToHash.size(); ++i)
		{
			assert(sumDatabase.GetNumberOfNumberOfHashNotGreaterThan(hasher.GetHash(numberToHash[i])) == 0);
			assert(sumDatabase.GetSumOfAllNumberOfHashNotGreaterThan(hasher.GetHash(numberToHash[i])) == 0);
		}
	}

	sumDatabase.AddNumber(10);
	sumDatabase.AddNumber(10);

	for (int hash = 1; hash <= 8; ++hash)
	{
		assert(sumDatabase.GetNumberOfNumberOfHashNotGreaterThan(hash) == 2);
		assert(sumDatabase.GetSumOfAllNumberOfHashNotGreaterThan(hash) == 20);
	}

	assert(sumDatabase.GetNumberOfNumberOfHashNotGreaterThan(9) == 2 + 9);
	assert(sumDatabase.GetSumOfAllNumberOfHashNotGreaterThan(9) == 2 * 10 + 9 * 2);

	assert(sumDatabase.GetNumberOfNumberOfHashNotGreaterThan(10) == 2 + 9 + 9);
	assert(sumDatabase.GetSumOfAllNumberOfHashNotGreaterThan(10) == 2 * 10 + 9 * 2 + 9);

	sumDatabase.RemoveNumber(10);

	for (int hash = 1; hash <= 8; ++hash)
	{
		assert(sumDatabase.GetNumberOfNumberOfHashNotGreaterThan(hash) == 1);
		assert(sumDatabase.GetSumOfAllNumberOfHashNotGreaterThan(hash) == 10);
	}

	assert(sumDatabase.GetNumberOfNumberOfHashNotGreaterThan(9) == 1 + 9);
	assert(sumDatabase.GetSumOfAllNumberOfHashNotGreaterThan(9) == 1 * 10 + 9 * 2);
}

int main()
{
	//Debug();
	Input input = ReadInput();
	Hasher hasher(input);
	SmartSpratsDatabase2 spratDatabase(&hasher);
	WriteOutput(input, spratDatabase);

	return 0;
}