#include<bits/stdc++.h>
#pragma GCC optimize(3)
#pragma GCC target("avx")
#pragma GCC optimize("Ofast")
#pragma GCC optimize("inline")
#pragma GCC optimize("-fgcse")
#pragma GCC optimize("-fgcse-lm")
#pragma GCC optimize("-fipa-sra")
#pragma GCC optimize("-ftree-pre")
#pragma GCC optimize("-ftree-vrp")
#pragma GCC optimize("-fpeephole2")
#pragma GCC optimize("-ffast-math")
#pragma GCC optimize("-fsched-spec")
#pragma GCC optimize("unroll-loops")
#pragma GCC optimize("-falign-jumps")
#pragma GCC optimize("-falign-loops")
#pragma GCC optimize("-falign-labels")
#pragma GCC optimize("-fdevirtualize")
#pragma GCC optimize("-fcaller-saves")
#pragma GCC optimize("-fcrossjumping")
#pragma GCC optimize("-fthread-jumps")
#pragma GCC optimize("-funroll-loops")
#pragma GCC optimize("-fwhole-program")
#pragma GCC optimize("-freorder-blocks")
#pragma GCC optimize("-fschedule-insns")
#pragma GCC optimize("inline-functions")
#pragma GCC optimize("-ftree-tail-merge")
#pragma GCC optimize("-fschedule-insns2")
#pragma GCC optimize("-fstrict-aliasing")
#pragma GCC optimize("-fstrict-overflow")
#pragma GCC optimize("-falign-functions")
#pragma GCC optimize("-fcse-skip-blocks")
#pragma GCC optimize("-fcse-follow-jumps")
#pragma GCC optimize("-fsched-interblock")
#pragma GCC optimize("-fpartial-inlining")
#pragma GCC optimize("no-stack-protector")
#pragma GCC optimize("-freorder-functions")
#pragma GCC optimize("-findirect-inlining")
#pragma GCC optimize("-fhoist-adjacent-loads")
#pragma GCC optimize("-frerun-cse-after-loop")
#pragma GCC optimize("inline-small-functions")
#pragma GCC optimize("-finline-small-functions")
#pragma GCC optimize("-ftree-switch-conversion")
#pragma GCC optimize("-foptimize-sibling-calls")
#pragma GCC optimize("-fexpensive-optimizations")
#pragma GCC optimize("-funsafe-loop-optimizations")
#pragma GCC optimize("inline-functions-called-once")
#pragma GCC optimize("-fdelete-null-pointer-checks")
#pragma GCC optimize(2)
#define int long long
using namespace std;
const int N=4e6+10;
int l[N],r[N],sum[N],sum2[N],tag[N];
int sum1s[N],sum2s[N];
inline void pushup(int p){
	sum[p]=sum[(p<<1)]+sum[(p<<1|1)];
	sum2[p]=sum2[(p<<1)]+sum2[(p<<1|1)];
	sum1s[p]=sum1s[(p<<1)]+sum1s[(p<<1|1)];
	sum2s[p]=sum2s[(p<<1)]+sum2s[(p<<1|1)];
}
int rnk[N];
inline void build(int L,int R,int p){
//	cout<<L<<' '<<R<<'\n';
	l[p]=L,r[p]=R,sum[p]=sum2[p]=tag[p]=0;
	if(L==R){}
	else{
		int mid=(L+R) >> 1;
		build(L,mid,p << 1);build(mid+1,R,p << 1 | 1);
		pushup(p); 
	}
}
inline void update(int L,int k,int p){
	if(l[p]==L&&r[p]==L){
		sum[p]+=k ;sum2[p]+=k/rnk[L];
		sum1s[p]+=k,sum2s[p]+=k/rnk[L];
		return ;
	}
	int mid = (l[p] + r[p]) >> 1;
	if (L <= mid) update(L, k, p << 1);
	else update(L, k, p << 1 | 1);
	pushup(p);
}
inline int query(int L,int R,int p){
	if(l[p]>R||r[p]<L||tag[p])return 0;
	if(l[p]>=L&&r[p]<=R)return sum[p];
	return query(L,R,p << 1)+query(L,R,p << 1 | 1);
}
inline int how(int L,int R,int p){
	if(l[p]>R||r[p]<L||tag[p])return 0;
	if(l[p]>=L&&r[p]<=R)return sum2[p];
	return how(L,R,p << 1)+how(L,R,p<< 1 | 1);
}
unordered_map<int,int>posian;
inline int work(int pos,int past,int now){
	int l=1,r=pos-1;
	while(r-l>1){
		int mid=(l+r) >> 1;
		int sum=query(mid,pos-1,1);
		if(past+sum<now)r=mid-1;
		else l=mid;
	}
	int sum=query(r,pos-1,1);
	if(sum+past>=now)return r;
	return l;
}
int n,m,opt[N],b[N],num;
pair<int,int>a[N],q[N];
inline void maketag(int L,int R,int p){
	if(l[p]>R||r[p]<L)return ;
	if(l[p]>=L&&r[p]<=R){
		tag[p]=1;sum[p]=sum2[p]=0;
	}
	else{
		maketag(L,R,p*2),maketag(L,R,p*2+1);
		pushup(p);
	}
}
inline void cleartag(int L,int R,int p){
	if(l[p]>R||r[p]<L)return ;
	if(l[p]>=L&&r[p]<=R){
		tag[p]=0;
		sum[p]=sum1s[p];sum2[p]=sum2s[p];
	}
	else{
		cleartag(L,R,p*2),cleartag(L,R,p*2+1);
		pushup(p);
	}
}
multiset<int>dc;
char *p1,*p2,buf[100000];
#define nc() (p1==p2 && (p2=(p1=buf)+fread(buf,1,100000,stdin),p1==p2)?EOF:*p1++)
inline int read()
{
    int x=0,f=1;
    char ch=nc();
    while(ch<48||ch>57)
    {
        if(ch=='-')
            f=-1;
        ch=nc();
    }
    while(ch>=48&&ch<=57)
        x=(x << 1) + (x << 3) + (ch ^ 48),ch=nc();
   	return x*f;
}
inline void write(int x)
{
    if(x<0)
        putchar('-'),x=-x;
    if(x>9)
        write(x/10);
    putchar(x%10+48);
    return;
}
signed main(){
//	ios::sync_with_stdio(0),cin.tie(0),cout.tie(0);
	n=read();
	for(int i=1;i<=n;i++){
		a[i].first=read();
		a[i].second=i;
	}
	m=read();
	for(int i=1;i<=m;i++){
		opt[i]=read();
		if(opt[i]==1){
			q[i].first=read();q[i].second=read();
			a[i+n].first=(1LL<<60);
		}else{
			a[i+n].first=read();
			a[i+n].second=i+n;
		}
	}
	sort(a+1,a+1+n+m);
	for(int i=1;i<=n+m;i++){
		if(a[i].first==(1LL<<60))break;
		if(a[i].first!=a[i-1].first)num++;
		b[a[i].second]=num;rnk[num]=a[i].first;posian[a[i].first]=num;
	}
	build(1,num,1);
	for(int i=1;i<=n;i++){
		update(b[i],rnk[b[i]],1);
		dc.insert(dc.lower_bound(rnk[b[i]]),rnk[b[i]]);
	}
	rnk[num+1]=(1LL<<60);
	for(int i=1;i<=m;i++){
		if(opt[i]==1){
			bool getans=1;
			int ans=0;
			vector<pair<int,int> >hd;
			vector<pair<int,int> >undo;
			while(q[i].first<q[i].second){
				int pre=q[i].first,p;
				auto pp=dc.lower_bound(q[i].first);
				if(pp==dc.begin()){
					write(-1);
					puts("");
					getans=0;
					break;
				}
				if(pp==dc.end())p=num+1;
				else p=*pp,p=posian[p];
				int polo=work(p,q[i].first,min(q[i].second,rnk[p]+1));
				q[i].first+=query(polo+1,p-1,1);
				int sf=min((int)(ceil((min(q[i].second,rnk[p]+1)-q[i].first)*1.0/rnk[polo])),how(polo,polo,1));
				int upnum=sf+how(polo+1,p-1,1);
				q[i].first+=sf*rnk[polo];
				ans+=upnum;
				maketag(polo+1,p-1,1); 
				hd.push_back({polo+1,p-1});
				update(polo,-sf*rnk[polo],1);
				undo.push_back({polo,sf*rnk[polo]});
				if(q[i].first<rnk[p]+1&&q[i].first<q[i].second){
					write(-1);
					puts("");
					getans=0;
					break;
				}
			}
			for(int i=0;i<hd.size();i++){
				cleartag(hd[i].first,hd[i].second,1);
			}
			for(int i=0;i<undo.size();i++){
				update(undo[i].first,undo[i].second,1);
			}
			if(getans){
				write(ans);puts("");
			}
		}
		else if(opt[i]==2){
			update(b[i+n],rnk[b[i+n]],1);
			dc.insert(dc.lower_bound(rnk[b[i+n]]),rnk[b[i+n]]);
		}
		else{
			update(b[i+n],-rnk[b[i+n]],1);
			dc.erase(dc.lower_bound(rnk[b[i+n]]));
		}
	}
	return 0;
}