#include <cstdio>
#include <iostream>
#include <algorithm>
#include <cstring>
#include <vector>
#include <cassert>

#define rint register int

using namespace std;

namespace IO {
    inline void read(int &a) {
        int sym=1,num=0;
        char c=getchar();
        while (c<'0' || c>'9') {
            if (c=='-') {
                sym=-1;
        }
        c=getchar();
        }
        while (c>='0' && c<='9') {
            num=num*10+c-'0';
            c=getchar();
        }
        a=sym*num;
    }
    inline void write(int a) {
        if (a<0) {
            putchar('-');
            a*=-1;
        }
        if (a>=10) {
            write(a/10);
        }
        putchar(a%10+'0');
    }
}

using IO::read;
using IO::write;

const int N=100005;
const int M=425;
const int K=425;
const int inf=1e6;
const short shortinf=32000;

int n,m,len,bk;
int arr[N];
short to[N][M];
short dis[M][K][K];
int fir[M][K];
int las[M][K];
int L[M],R[M],B[N];
int last;
vector<int> lsh[M];

inline int get(int x) {
	return (x-1)/len;
}

inline int getl(int x) {
	return x*len+1;
}

inline int getr(int x) {
	return min(getl(x+1)-1,n);
}

inline bool cmp(const int& a,const int& b) {
    return a<b;
}

inline short min(short a,int b) {
    if (a<b) return a;
    else return b;
}

inline short min(int a,short b) {
    if (a<b) return a;
    else return b;
}

inline void initLR() {
	for (int i=1;i<=n;++i) {
		B[i]=get(i);
	}
	for (rint i=0;i<bk;++i) {
		L[i]=getl(i);
		R[i]=getr(i);
	}
}

inline void init() {
    for (rint i=0;i<N;++i) {
    	for (rint j=0;j<M;++j) {
    		to[i][j]=-1;
		}
	}
	for (rint i=0;i<M;++i) {
		for (rint j=0;j<K;++j) {
			for (rint k=0;k<K;++k) {
				dis[i][j][k]=shortinf;
			}
			fir[i][j]=inf;
			las[i][j]=-inf;
		}
	}
    for (rint i=0;i<bk;++i) {
        for (rint j=L[i];j<=R[i];++j) {
            lsh[i].push_back(arr[j]);
        }
        sort(lsh[i].begin(),lsh[i].end(),cmp);
        lsh[i].erase(unique(lsh[i].begin(),lsh[i].end()),lsh[i].end());
        for (rint j=L[i];j<=R[i];++j) {
            rint tmp=lower_bound(lsh[i].begin(),lsh[i].end(),arr[j])-lsh[i].begin();
            to[arr[j]][i]=tmp;
//            assert(tmp>=0 && tmp<=n);
//            arr[j]=tmp;
//            assert(j<=n);
            fir[i][tmp]=min(fir[i][tmp],j);
            las[i][tmp]=max(las[i][tmp],j);
        }
    }
	for (rint i=0;i<bk;++i) {
		for (rint j=L[i];j<=R[i];++j) {
			for (rint k=L[i];k<=R[i];++k) {
				dis[i][to[arr[j]][i]][to[arr[k]][i]]=min(dis[i][to[arr[j]][i]][to[arr[k]][i]],abs(k-j));
			}
		}
	}
//	checkDebug();
}

inline void modify(int x,int y) {
	if (x==y) return;
	for (rint i=0;i<bk;++i) {
		rint toxi=to[x][i];
		rint toyi=to[y][i];
		if (!~toxi) continue;
		if (!~toyi) {
			to[y][i]=toxi,to[x][i]=-1;
		} else {
			fir[i][toyi]=min(fir[i][toyi],fir[i][toxi]);
			las[i][toyi]=max(las[i][toyi],las[i][toxi]);
			fir[i][toxi]=inf,las[i][toxi]=-inf;
			for (rint j=0;j<lsh[i].size();++j) {
//				assert(to[i][lsh[i][j]]==j);
//				int k=to[i][lsh[i][j]];
				rint k=j;
				if (!~k) continue;
				if (toxi==k) continue;
				dis[i][toyi][k]=min(dis[i][toyi][k],dis[i][toxi][k]);
                dis[i][k][toyi]=dis[i][toyi][k];
			}
			for (rint j=0;j<lsh[i].size();++j) {
				rint k=to[lsh[i][j]][i];
//				assert(k==j);
//				int k=j;
				dis[i][toxi][k]=shortinf;
                dis[i][toxi][k]=shortinf;
			}
			dis[i][toyi][toxi]=shortinf;
			dis[i][toxi][toyi]=shortinf;
			to[x][i]=-1;
		}
	}
}

inline int query(int x,int y) {
	rint maxx=-1;
	rint maxy=-1;
	rint ans=inf;
	for (rint i=0;i<bk;++i) {
		rint toxi=to[x][i];
		rint toyi=to[y][i];
		if (~toxi && ~maxy && fir[i][toxi]!=inf) {
			if (fir[i][toxi]>=maxy) ans=min(ans,fir[i][toxi]-maxy);
		}
		if (~toyi && ~maxx && fir[i][toyi]!=inf) {
			if (fir[i][toyi]>=maxx) ans=min(ans,fir[i][toyi]-maxx);
		}
		if (~toxi) maxx=max(maxx,las[i][toxi]);
		if (~toyi) maxy=max(maxy,las[i][toyi]);
        if (~toxi && ~toyi) {
            if (dis[i][toxi][toyi]<=len) ans=min(ans,dis[i][toxi][toyi]);
		    if (dis[i][toyi][toxi]<=len) ans=min(ans,dis[i][toyi][toxi]);
        }
        if (ans<=1) break;
        // assert(ans>=0);
	}
    // cout<<maxx<<" "<<maxy<<endl;
	if (maxx==-1 || maxy==-1 || ans==inf) return -1;
	else return ans;
}

int main() {
//	freopen("1.in","r",stdin);
//	freopen("wa.out","w",stdout);
//	scanf("%d %d",&n,&m);
	read(n); read(m);
	len=315; bk=n/len; if (n%len) bk++;
	for (rint i=1;i<=n;++i) {
//		scanf("%d",&arr[i]);
		read(arr[i]);
	}
	initLR();
	init();
	while (m--) {
//		if (m<=79900) exit(0);
		int op,x,y;
//		scanf("%d %d %d",&op,&x,&y);
		read(op); read(x); read(y);
		x^=last;
		y^=last;
//		assert(x<=1e5 && y<=1e5);
		if (op==1) {
			if (x==y) continue;
			modify(x,y);
		} else {
			rint ans=query(x,y);
			if (ans==-1) {
				last=0;
				puts("Ikaros");
			} else {
				printf("%d\n",last=ans);
			}
		}
	}
	return 0;
}

/*
5 5
1 2 2 4 4
2 3 3
x=3, y=3, Ikaros, last=0
2 2 4
x=2, y=4, 1, last=1
1 3 2
x=2, y=3, none, last=1
array: 1 3 3 4 4
1 5 5
x=4, y=4, none, last=1
array: 1 3 3 4 4
2 2 5
x=3, y=4, 1, last=1
*/

rt，分数在 52 到 58 之间波动