#include<bits/stdc++.h>
using namespace std;

//#define ONLINE
#ifndef ONLINE
char DEBUG_BUFFER[1000];
#define debug(...) {sprintf(DEBUG_BUFFER,##__VA_ARGS__);\
cerr<<"\033[1;36m"<<DEBUG_BUFFER<<"\033[0;2m"<<"\033[0m";}
#else
#define debug(...) ;
#endif

using LL=long long;
using PII=pair<int,int>;

#define all(x) (x).begin(),(x).end()
#define allr(x) (x).rbegin(),(x).rend()

#define FAST_IO {ios::sync_with_stdio(false);cin.tie(nullptr);}
inline int read(){static int x; cin>>x; return x;}
inline LL readLL(){static LL x; cin>>x; return x;}
mt19937_64 rng(chrono::system_clock::now().time_since_epoch().count());

#define N 500010
using ALH=array<LL,2>;//array-LL-Hash
namespace HC{//Hash Const
	const int P[2]={13331,233};
	const int MOD[2]={(int)(1e9+7),998244353};
	LL ksm[N][2],sum[N][2];
	void init(){
		for(int j=0;j<2;j++){
			ksm[0][j]=1,sum[0][j]=1;
			for(int i=1;i<N;i++){
				ksm[i][j]=(ksm[i-1][j]*P[j])%MOD[j];
				sum[i][j]=(sum[i-1][j]+ksm[i][j])%MOD[j];
			}
		}
	}
}
ALH operator <<(const ALH& A,const int& len){
	static ALH ret;
	for(int i=0;i<2;i++){
		ret[i]=(A[i]*HC::ksm[len][i])%HC::MOD[i];
	}
	return ret;
}
ALH operator +(const ALH& A,const ALH& B){
	static ALH ret;
	for(int i=0;i<2;i++){
		ret[i]=(A[i]+B[i])%HC::MOD[i];
	}
	return ret;
}
ALH operator -(const ALH& A,const ALH& B){
	static ALH ret;
	for(int i=0;i<2;i++){
		ret[i]=((A[i]-B[i])%HC::MOD[i]+HC::MOD[i])%HC::MOD[i];
	}
	return ret;
}
ALH operator *(const ALH& A,const ALH& B){
	static ALH ret;
	for(int i=0;i<2;i++){
		ret[i]=A[i]*B[i]%HC::MOD[i];
	}
	return ret;
}

ALH calc(const int& x,LL b){
	static ALH res;
	for(int i=0;i<2;i++){
		res[i]=(HC::sum[b][i]*x)%HC::MOD[i];
	}
	return res;
}

#define ls (id<<1)
#define rs (id<<1|1)
class SGT{//以线段树维护区间最大值为例，支持区间修改
private:
	struct Node{
		int l,r;
		int mx,tag;
		ALH v;
		friend Node operator +(const Node& A,const Node& B){
			Node ret;
			ret.l=A.l,ret.r=B.r;
			ret.mx=max(A.mx,B.mx);
			ret.tag=0;
			ret.v=(A.v<<(B.r-B.l+1))+B.v;
			return ret;
		}
	};
	vector<Node>q;
	void UPD(int id,const int& x){
		q[id].mx+=x,q[id].tag+=x;
		q[id].v=q[id].v+calc(x,q[id].r-q[id].l);
	}
	void spread(int id){
		if(q[id].l==q[id].r) return;
		//spread the lazy tag
		if(q[id].tag){
			UPD(ls,q[id].tag);
			UPD(rs,q[id].tag);
			q[id].tag=0;
		}
	}
	void build(const vector<int>& a,int l,int r,int id=1){
		if(l==r){
			q[id].l=l,q[id].r=r;
			q[id].mx=a[l],q[id].tag=0;
			q[id].v=ALH{a[l],a[l]};
			return;
		}
		int mid=l+r>>1;
		build(a,l,mid,ls);
		build(a,mid+1,r,rs);
		q[id]=q[ls]+q[rs];
	}
public:
	SGT(const vector<int>& a,int n){
		init(a,n);
	}
	void init(const vector<int>& a,int n){
		q.resize(n*5);
		build(a,1,n);
	}
	void modify(int l,int r,int id=1){
		if(q[id].l==l && q[id].r==r){
			//modify the value
			UPD(id,1);
			return;
		}
		spread(id);
		int mid=q[id].l+q[id].r>>1;
		if(r<=mid) modify(l,r,ls);
		else if(l>mid) modify(l,r,rs);
		else modify(l,mid,ls),modify(mid+1,r,rs);
		q[id]=q[ls]+q[rs];
	}
	void adjust(int l,int r,int id=1){
		if(q[id].mx<=65536) return;
		if(l==r){
			q[id].mx=1,q[id].tag=0;
			q[id].v=ALH{1,1};
			return;
		}
		spread(id);
		int mid=q[id].l+q[id].r>>1;
		adjust(l,mid,ls);
		adjust(mid+1,r,rs);
		q[id]=q[ls]+q[rs];
	}
	Node query(int l,int r,int id=1){
		if(q[id].l==l && q[id].r==r) return q[id];
		spread(id);
		int mid=q[id].l+q[id].r>>1;
		if(r<=mid) return query(l,r,ls);
		else if(l>mid) return query(l,r,rs);
		return query(l,mid,ls)+query(mid+1,r,rs);
	}
//	int get(int pos,int id=1){
//		if(q[id].l==q[id].r) return q[id].mx;
//		spread(id);
//		int mid=q[id].l+q[id].r>>1;
//		if(pos<=mid) return get(pos,ls);
//		return get(pos,rs);
//	}
};
#undef ls
#undef rs

int main(){
	FAST_IO;
	HC::init(); //初始化
	int n=read(),T=read();
	vector<int>a(n+1); //[1,65536]
	for(int i=1;i<=n;i++){
		a[i]=read()+1;
	}
	SGT sgt(a,n);
	for(int op,x,y;T--;){
		cin>>op>>x>>y;
		if(op==1){
			sgt.modify(x,y);
			sgt.adjust(1,n);
		}
		else{
			static int len;
			cin>>len;
			cout<<(sgt.query(x,x+len-1).v==sgt.query(y,y+len-1).v?
				"yes":"no")<<'\n';
		}
	}
	return 0;
}

/* stuff you should look for
* int overflow, array bounds
* special cases (n=1?)
* do smth instead of nothing and stay organized
* WRITE STUFF DOWN
* DON'T GET STUCK ON ONE APPROACH
*/