#include<cstdio>

#include<cstring>

#include<cctype>

#include<cstdlib>

#include<algorithm>

#define maxn 300050

#define left (rt<<1)

#define right (rt<<1|1)

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

#define lson l,mid,left

#define rson mid+1,r,right

using namespace std;

inline long long read(){

    long long num=,f=;

    char ch=getchar();

    while(!isdigit(ch)){

        if(ch=='-')    f=-;

        ch=getchar();

    }

    while(isdigit(ch)){

        num=num*+ch-'';

        ch=getchar();

    }

    return num*f;

}

int n;

int deep[maxn];

int top[maxn];

int father[maxn];

int dfn[maxn],ID;

int back[maxn];

int size[maxn];

int son[maxn];

struct Edge{

    int next,to;

}edge[maxn*];

int head[maxn],num;

inline void add(int from,int to){

    edge[++num]=(Edge){head[from],to};

    head[from]=num;

}

void findfs(int x,int fa){

    deep[x]=deep[fa]+;

    father[x]=fa;

    size[x]=;

    for(int i=head[x];i;i=edge[i].next){

        int to=edge[i].to;

        if(to==fa)    continue;

        findfs(to,x);

        size[x]+=size[to];

        if(son[x]==||size[son[x]]<size[to])    son[x]=to;

    }

}

void unidfs(int x,int Top){

    dfn[x]=++ID;    back[ID]=;

    top[x]=Top;

    if(!son[x])    return;

    unidfs(son[x],Top);

    for(int i=head[x];i;i=edge[i].next){

        int to=edge[i].to;

        if(to==father[x]||to==son[x])    continue;

        unidfs(to,to);

    }

}

int tree[maxn*],tag[maxn*];

inline void pushup(int rt){

    tree[rt]=tree[left]+tree[right];

}

void pushdown(int rt,int m){

    if(tag[rt]==-)    return;

    tag[left]=tag[rt];

    tag[right]=tag[rt];

    tree[left]=tag[rt]*(m-(m>>));

    tree[right]=tag[rt]*(m>>);

    tag[rt]=-;

    return;

}

void update(int from,int to,int num,int l,int r,int rt){

    if(from<=l&&to>=r){

        tree[rt]=num*(r-l+);

        tag[rt]=num;

        return;

    }

    pushdown(rt,r-l+);

    if(from<=mid)    update(from,to,num,lson);

    if(to>mid)        update(from,to,num,rson);

    pushup(rt);

    return;

}

void updatesum(int from,int to,int num){

    while(top[from]!=top[to]){

        if(deep[top[from]]<deep[top[to]])    swap(from,to);

        update(dfn[top[from]],dfn[from],num,,n,);

        from=father[top[from]];

    }

    if(deep[from]>deep[to])    swap(from,to);

    update(dfn[from],dfn[to],num,,n,);

    return;

}

int query(int from,int to,int l,int r,int rt){

    if(from<=l&&to>=r)    return tree[rt];

    int ans=;

    pushdown(rt,r-l+);

    if(from<=mid)    ans+=query(from,to,lson);

    if(to>mid)        ans+=query(from,to,rson);

    return ans;

}

int querysum(int from,int to){

    int ans=;

    while(top[from]!=top[to]){

        if(deep[top[from]]<deep[top[to]])    swap(from,to);

        ans+=query(dfn[top[from]],dfn[from],,n,);

        from=father[top[from]];

    }

    if(deep[from]>deep[to])    swap(from,to);

    ans+=query(dfn[from],dfn[to],,n,);

    return ans;

}

void updatetree(int from,int num){

    update(dfn[from],dfn[from]+size[from]-,num,,n,);

}

int querytree(int from){

    return query(dfn[from],dfn[from]+size[from]-,,n,);

}

int main(){

    memset(tag,-,sizeof(tag));

    n=read();

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

        int x=read();

        add(x+,i+);

        add(i+,x+);

    }

    findfs(,);

    unidfs(,);

    int m=read();

    for(int i=;i<=m;++i){

        char ch[];int x;

        scanf("%s%d",ch,&x);

        x++;

        if(ch[]=='i'){

            int last=querysum(,x);

            updatesum(,x,);

            int now=querysum(,x);

            printf("%d\n",now-last);

        }

        else{

            int last=querytree(x);

            updatetree(x,);

            int now=querytree(x);

            printf("%d\n",last-now);

        }

    }

    return ;

}