#include <bits/stdc++.h>

using namespace std;

const int MAXN = 1000005;

struct Node
{
	int l,r,ch[2];
	int maxs,minl,maxr;
	int sz;
	Node (int L = 0,int R = -1)
	{
		ch[0] = ch[1] = 0;
		l = minl = L,r = maxr = R;
		maxs = r - l + 1;
		sz = 1;
	}
}node[MAXN * 40];

int n,m,id;
int a[MAXN];
int b[MAXN];
int label[MAXN];
int sz[MAXN];
int bel[MAXN];
int st[MAXN];
int rt[MAXN << 3];

set<int> S;

void update(int u)
{
	node[u].sz = node[node[u].ch[0]].sz + 1 + node[node[u].ch[1]].sz;
	node[u].maxs = max(max(node[node[u].ch[0]].maxs,node[node[u].ch[1]].maxs),node[u].r - node[u].l + 1);
	node[u].minl = min(node[u].l,node[node[u].ch[0]].minl);
	node[u].maxr = max(node[u].r,node[node[u].ch[1]].maxr);
}

void link(int u,int v,bool dir)
{
	node[u].ch[dir] = v;
	update(u);
}

pair<int,int> split(int u,int x)
{
	if (!u)
		return make_pair(0,0);
	if (node[u].l <= x)
	{
		pair<int,int> res = split(node[u].ch[1],x);
		link(u,res.first,1);
		return make_pair(u,res.second);
	}
	pair<int,int> res = split(node[u].ch[0],x);
	link(u,res.second,0);
	return make_pair(res.first,u);
}

int merge(int u,int v)
{
	if (!u || !v)
		return u | v;
	if (rand() % (node[u].sz + node[v].sz) + 1 <= node[u].sz)
	{
		link(u,merge(node[u].ch[1],v),1);
		return u;
	}
	link(v,merge(u,node[v].ch[0]),0);
	return v;
}

void modify(int o,int l,int r,int x,int y,int L,int R,int v)
{
	if (l >= x && r <= y)
	{
		pair<int,int> res = split(rt[o],L);
		if (v == 1)
		{
			node[++id] = Node(L,R);
			rt[o] = merge(merge(res.first,id),res.second);
			return;
		}
		pair<int,int> res2 = split(res.first,L - 1);
		rt[o] = merge(res2.first,res.second);
		return;
	}
	int mid = l + r >> 1;
	if (mid >= x)
		modify(o << 1,l,mid,x,y,L,R,v);
	if (mid + 1 <= y)
		modify(o << 1 | 1,mid + 1,r,x,y,L,R,v);
}

int queryt(int u,int l,int r)
{
	if (!u)
		return 0;
	if (node[u].maxr < l || node[u].minl > r)
		return 0;
	if (node[u].maxr <= r && node[u].minl >= l)
		return node[u].maxs;
	int res = (node[u].l >= l && node[u].r <= r ? node[u].r - node[u].l + 1 : 0);
	return max(res,max(queryt(node[u].ch[0],l,r),queryt(node[u].ch[1],l,r)));
}

int query(int o,int l,int r,int p,int x,int y)
{
	int res = queryt(rt[o],x,y);
	if (l == r)
		return res;
	int mid = l + r >> 1;
	if (mid >= p)
		return max(res,query(o << 1,l,mid,p,x,y));
	return max(res,query(o << 1 | 1,mid + 1,r,p,x,y));
}

void add(int l,int r,int v)
{
	if (l > r)
		return;
	int vl = label[a[l]],vr = label[a[l]] + r - l,c = bel[a[l]];
	if (r - l + 1 > sz[c])
		vl = st[c],vr = st[c] + sz[c] - 1;
	modify(1,1,2 * n,vl,vr,l,r,v);
}

int main()
{
	node[0].minl = 1e9;
	node[0].sz = 0;
	scanf("%d%d",&n,&m);
	for (int i = 1;i <= n;i++)
		scanf("%d",&a[i]);
	for (int i = 1;i <= n;i++)
		scanf("%d",&b[i]);
	int cnt = 0;
	for (int i = 1;i <= n;i++)
		if (!label[i])
		{
			int cur = i;
			id++;
			st[id] = cnt + 1;
			while (!label[cur])
			{
				label[cur] = ++cnt;
				sz[id]++;
				bel[cur] = id;
				cur = b[cur];
			}
			cnt += sz[id];
		}
	id = 0;
	S.insert(0);
	S.insert(n);
	for (int i = 1;i < n;i++)
		if (b[a[i]] != a[i + 1])
			S.insert(i);
	for (set<int>::iterator it = S.begin();it != S.end();it++)
	{
		set<int>::iterator nxt = it;
		nxt++;
		if (nxt == S.end())
			break;
		add((*it) + 1,(*nxt),1);
	}
	while (m--)
	{
		int tp,l,r,x;
		scanf("%d%d%d",&tp,&l,&r);
		if (tp == 1)
		{
			set<int>::iterator R = S.upper_bound(l);
			if (R == S.end())
				R--;
			set<int>::iterator L = R;
			while ((*L) && (*L) >= l - 1)
				L--;
			int tmpl = *L,tmpr = *R;
			int g = tmpl + 1;
			if (b[a[l - 1]] != a[l])
			{
				add(g,l - 1,-1),g = l;
				S.erase(l - 1);
			}
			if (b[a[l]] != a[l + 1])
			{
				add(g,l,-1),g = l + 1;
				S.erase(l);
			}
			add(g,tmpr,-1);
			a[l] = r;
			g = tmpl + 1;
			if (b[a[l - 1]] != a[l])
			{
				add(g,l - 1,1),g = l;
				S.insert(l - 1);
			}
			if (b[a[l]] != a[l + 1])
			{
				add(g,l,1),g = l + 1;
				S.insert(l);
			}
			add(g,tmpr,1);
		}
		else
		{
			scanf("%d",&x);
			int ans = max(query(1,1,2 * n,label[x],l,r),query(1,1,2 * n,label[x] + sz[bel[x]],l,r));
			if (bel[a[l]] == bel[x])
			{
				int R = min(r,*S.lower_bound(l));
				if ((label[a[l]] <= label[x] && label[a[l]] + R - l >= label[x]) || (label[a[l]] <= label[x] + sz[bel[x]] && label[a[l]] + R - l >= label[x] + sz[bel[x]]))
					ans = max(ans,R - l + 1);
			}
			if (bel[a[r]] == bel[x])
			{
				int L = max(l,*(--S.lower_bound(r)) + 1);
				if ((label[a[L]] <= label[x] && label[a[L]] + r - L >= label[x]) || (label[a[L]] <= label[x] + sz[bel[x]] && label[a[L]] + r - L >= label[x] + sz[bel[x]]))
					ans = max(ans,r - L + 1);
			}
			printf("%d\n",ans);
		}
	}
	return 0;
}