#include<bits/stdc++.h>

#define reg register int

#define il inline

#define fi first

#define se second

#define mk(a,b) make_pair(a,b)

#define numb (ch^'0')

using namespace std;

typedef long long ll;

template<class T>il void rd(T &x){

    char ch;x=;bool fl=false;

    while(!isdigit(ch=getchar()))(ch=='-')&&(fl=true);

    for(x=numb;isdigit(ch=getchar());x=x*+numb);

    (fl==true)&&(x=-x);

}

template<class T>il void output(T x){if(x/)output(x/);putchar(x%+'');}

template<class T>il void ot(T x){if(x<) putchar('-'),x=-x;output(x);putchar(' ');}

template<class T>il void prt(T a[],int st,int nd){for(reg i=st;i<=nd;++i) ot(a[i]);putchar('\n');}

namespace Miracle{

const int N=2e5+;

int n,q;

struct node{

    int nxt,to;

}e[*N];

int hd[N],cnt;

void add(int x,int y){

    e[++cnt].nxt=hd[x];

    e[cnt].to=y;

    hd[x]=cnt;

}

int dep[N];

int a[*N],tot;

int dfn[N];

int f[*N][];

int lg[*N];

int id[N],fid[N];

void dfs(int x,int d){

    dep[x]=d;

    a[++tot]=x;

    dfn[x]=tot;

    for(reg i=hd[x];i;i=e[i].nxt){

        int y=e[i].to;

        dfs(y,d+);

        a[++tot]=x;

    }

}

int big(int x,int y){

    return dep[x]<dep[y]?x:y;

}

int lca(int x,int y){

    if(dfn[x]>dfn[y]) swap(x,y);

    int len=lg[dfn[y]-dfn[x]+];

    return big(f[dfn[x]][len],f[dfn[y]-(<<len)+][len]);

}

int on(int p1,int p2,int p3){

    int y=lca(p1,p2);

//    cout<<" p1 "<<p1<<" p2 "<<p2<<" p3 "<<p3<<" y "<<y<<endl;

    return ((lca(p1,p3)==p3||lca(p2,p3)==p3)&&(lca(y,p3)==y));

}

struct tr{

    int p[];

    int can;

    void init(){

        can=p[]=p[]=;

    }

    void op(){

        cout<<" can "<<can<<" p[0] "<<p[]<<" p[1] "<<p[]<<endl;

    }

}t[*N];

#define ls (x<<1)

#define rs (x<<1|1)

#define mid ((l+r)>>1)

void pushup(int x){

    t[x].init();

    if(t[x<<].can&&t[x<<|].can){

        t[x].can|=on(t[ls].p[],t[ls].p[],t[rs].p[])&&on(t[ls].p[],t[ls].p[],t[rs].p[]);

        if(t[x].can==) {t[x].p[]=t[ls].p[],t[x].p[]=t[ls].p[];return;}

        t[x].can|=on(t[rs].p[],t[rs].p[],t[ls].p[])&&on(t[rs].p[],t[rs].p[],t[ls].p[]);

        if(t[x].can==) {t[x].p[]=t[rs].p[],t[x].p[]=t[rs].p[];return;}

        if(!t[x].can){

            for(reg i=;i<=;++i){

                for(reg j=;j<=;++j){

                    t[x].can|=on(t[ls].p[i],t[rs].p[j],t[ls].p[i^])&&on(t[ls].p[i],t[rs].p[j],t[rs].p[j^]);

                    if(t[x].can==) {t[x].p[]=t[ls].p[i],t[x].p[]=t[rs].p[j];return;}

                }

            }

        }

    }

}

tr merge(tr A,tr B){

    tr C;C.can=C.p[]=C.p[]=;

//    cout<<" A ";A.op();

//    cout<<" B ";B.op();

    if(A.can&&B.can){

        C.can|=on(A.p[],A.p[],B.p[])&&on(A.p[],A.p[],B.p[]);

        if(C.can==) {C.p[]=A.p[],C.p[]=A.p[];return C;}

        C.can|=on(B.p[],B.p[],A.p[])&&on(B.p[],B.p[],A.p[]);

        if(C.can==) {C.p[]=B.p[],C.p[]=B.p[];return C;}

        if(!C.can){

            for(reg i=;i<=;++i){

                for(reg j=;j<=;++j){

                    C.can|=on(A.p[i],B.p[j],A.p[i^])&&on(A.p[i],B.p[j],B.p[j^]);

                    if(C.can==) {C.p[]=A.p[i],C.p[]=B.p[j];return C;}

                }

            }

        }

    }

    return C;

}

void build(int x,int l,int r){

    if(l==r){

        t[x].p[]=t[x].p[]=fid[l];

        t[x].can=;return;

    }

    t[x].can=;

    build(x<<,l,mid);

    build(x<<|,mid+,r);

    pushup(x);

}

void upda(int x,int l,int r,int p,int c){//pos to c

    if(l==r){

        t[x].p[]=c;t[x].p[]=c;

        t[x].can=;return;

    }

    if(p<=mid) upda(ls,l,mid,p,c);

    else upda(rs,mid+,r,p,c);

    pushup(x);

}

tr tmp;

int query(int x,int l,int r){

//    cout<<" query "<<x<<" "<<l<<" "<<r<<" : ";t[x].op();

    tr C;

    if(l==r){

        if(tmp.can==-){

            C=t[x];

        }else{

            C=merge(tmp,t[x]);

        }

        return C.can==?l:l-;

    }

//    cout<<" ls ";t[ls].op();

    if(tmp.can==-){

        C=t[ls];

    }else{

        C=merge(tmp,t[ls]);

    }

//    C.op();

    if(C.can){

        tmp=C;

        return query(rs,mid+,r);

    }else{

        return query(ls,l,mid);

    }

}

int main(){

    rd(n);

    for(reg i=;i<=n;++i){

        rd(id[i]);fid[id[i]]=i;

    }

    int y;

    for(reg i=;i<=n;++i){

        rd(y);add(y,i);

    }

    dfs(,);

    for(reg i=;i<=*n-;++i){

        lg[i]=(i>>(lg[i-]+))?lg[i-]+:lg[i-];

        f[i][]=a[i];

    }

//    cout<<" tot "<<tot<<endl;

//    prt(a,1,tot);

//    prt(lg,1,2*n-1);

    for(reg j=;j<=;++j){

        for(reg i=;i+(<<j)-<=tot;++i){

            f[i][j]=big(f[i][j-],f[i+(<<(j-))][j-]);

        }

    }

    build(,,n-);

    rd(q);

    int op,x;

    while(q--){

        rd(op);

        if(op==){

            rd(x);rd(y);

            upda(,,n-,id[x],y);

            upda(,,n-,id[y],x);

            swap(id[x],id[y]);

        }else{

            tmp.init();

            tmp.can=-;

            printf("%d\n",query(,,n-)+);

        }

    }

    return ;

}

}

signed main(){

    Miracle::main();

    return ;

}

/*

   Author: *Miracle*

   Date: 2019/4/11 16:56:19

*/