#include <bits/stdc++.h>
#include <bits/extc++.h>
using namespace std;
#define For(Ti,Ta,Tb) for(auto Ti=(Ta);Ti<=(Tb);++Ti)
#define Dec(Ti,Ta,Tb) for(auto Ti=(Ta);Ti>=(Tb);--Ti)
#define debug(...) fprintf(stderr,__VA_ARGS__)
#define range(Tx) begin(Tx),end(Tx)
using ll=long long;
using ull=unsigned long long;
const int N=5e5+5,Base=13331;
struct HashSeq{
	vector<ull> pw,hsh;
	HashSeq(const vector<int>& a):pw(a.size()+1),hsh(a.size()+1){
		pw[0]=1;
		For(i,1,int(a.size())){
			pw[i]=pw[i-1]*Base;
		}
		For(i,0,int(a.size())-1){
			hsh[i+1]=hsh[i]*Base+a[i]+1;
		}
	}
	ull substr(int l,int r){
		return hsh[r+1]-hsh[l]*pw[r-l+1];
	}
};
int n,m,len,fa[N],faw[N],dep[N],siz[N],hson[N];
vector<int> e[N];
void dfs(int u){
	siz[u]=1;
	for(int v:e[u]){
		dep[v]=dep[u]+1;
		dfs(v);
		siz[u]+=siz[v];
		if(siz[v]>siz[hson[u]]){
			hson[u]=v;
		}
	}
}
int rk[N],dfn[N],dfx,top[N],down[N];
void dfs2(int u,int t){
	rk[dfn[u]=++dfx]=u;
	top[u]=t;
	down[t]=u;
	if(hson[u]){
		dfs2(hson[u],t);
	}
	for(int v:e[u]){
		if(v!=hson[u]){
			dfs2(v,v);
		}
	}
}
int lca(int u,int v){
	while(top[u]!=top[v]){
		if(dep[top[u]]<dep[top[v]]){
			swap(u,v);
		}
		u=fa[top[u]];
	}
	return dep[u]<dep[v]?u:v;
}
int kth_anc(int u,int k){
	while(1){
		int x=dep[u]-dep[top[u]]+1;
		if(k>=x){
			k-=x;
			u=fa[top[u]];
		}else{
			return rk[dfn[u]-k];
		}
	}
}
int match(const vector<int>& vec,ull x){
	HashSeq hsh(vec);
	int ans=0;
	For(i,0,int(vec.size())-len){
		ans+=(hsh.substr(i,i+len-1)==x);
	}
	return ans;
}
ull get_hash(const string& s){
	ull x=0;
	For(i,0,len-1){
		x=x*Base+s[i]-'0'+1;
	}
	return x;
}
struct BIT{
	__gnu_pbds::gp_hash_table<ull,int> t[N];
	void add(int p,ull x,int w){
		for(;p<=n;p+=p&-p){
			t[p][x]+=w;
		}
	}
	int query(int p,ull x){
		int res=0;
		for(;p;p&=p-1){
			auto it=t[p].find(x);
			res+=(it!=t[p].end()?it->second:0);
		}
		return res;
	}
}bit;
int solve(int u,int lca,const string& s){
	if(dep[u]-dep[lca]<len){
		return 0;
	}
	int ans=0;
	ull x=get_hash(s);
	vector<pair<int,int>> vec;
	{
		int x=u;
		while(top[x]!=top[lca]){
			vec.emplace_back(dfn[top[x]],dfn[x]);
			x=fa[top[x]];
		}
		if(x!=lca){
			vec.emplace_back(dfn[lca]+1,dfn[x]);
		}
	}
	For(i,0,int(vec.size())-2){
		auto [l,r]=vec[i];
		vector<int> a;
		Dec(j,min(r,l+len-2),l){
			a.push_back(faw[rk[j]]);
		}
		for(int v=fa[rk[l]];dep[v]>max(dep[lca],dep[rk[l]]-len);v=fa[v]){
			a.push_back(faw[v]);
		}
		ans+=match(a,x);
	}
	ans+=bit.query(dfn[u],x)-bit.query(dfn[kth_anc(u,dep[u]-dep[lca]-len+1)],x);
	return ans;
}
ull val[N];
void modify(int u,int lca,const string& s){
	for(int v=u,i=0;v!=lca;v=fa[v],++i){
		faw[v]=s[i]-'0';
	}
	auto update=[&](int l,int r){
		int L=max(l,dfn[top[rk[l]]]+len-1),R=min(r+len-1,dfn[down[rk[l]]]);
		vector<int> a;
		Dec(i,R,L-len+1){
			a.push_back(faw[rk[i]]);
		}
		HashSeq hsh(a);
		For(i,L,R){
			int u=rk[i];
			bit.add(i,val[u],-1);
			bit.add(i+siz[u],val[u],1);
			val[u]=hsh.substr(R-i,R-i+len-1);
			bit.add(i,val[u],1);
			bit.add(i+siz[u],val[u],-1);
		}
	};
	while(top[u]!=top[lca]){
		update(dfn[top[u]],dfn[u]);
		u=fa[top[u]];
	}
	if(u!=lca){
		update(dfn[lca]+1,dfn[u]);
	}
}
int main(){
	cin.tie(nullptr)->sync_with_stdio(false);
	// assert(freopen("data.in","r",stdin));
	// assert(freopen("data.out","w",stdout));
	cin>>n>>m>>len;
	For(i,2,n){
		cin>>fa[i];
		e[fa[i]].push_back(i);
	}
	{
		string s;
		cin>>s;
		For(i,2,n){
			faw[i]=s[i-2]-'0';
			// debug("%d %d %d\n",i,fa[i],faw[i]);
		}
	}
	dfs(1);
	dfs2(1,1);
	For(u,1,n){
		down[u]=down[top[u]];
		if(down[u]==u){
			// debug("down=%d,top=%d\n",u,top[u]);
			vector<int> a;
			for(int v=0;v!=top[u];){
				v=(v?fa[v]:u);
				a.push_back(faw[v]);
			}
			HashSeq hsh(a);
			for(int v=u;v&&dep[v]-dep[top[u]]+1>=len;v=fa[v]){
				val[v]=hsh.substr(dep[u]-dep[v],dep[u]-dep[v]+len-1);
				// debug("%d %llu\n",v,val);
				bit.add(dfn[v],val[v],1);
				bit.add(dfn[v]+siz[v],val[v],-1);
			}
		}
	}
	// debug("done\n");
	For($,1,m){
		int op,u,v;
		string s;
		cin>>op>>u>>v>>s;
		if(op==1){
			int lca=::lca(u,v);
			modify(u,lca,s.substr(0,dep[u]-dep[lca]));
			modify(v,lca,string(s.rbegin(),s.rbegin()+(dep[v]-dep[lca])));
		}else{
			if(dep[u]<dep[v]){
				reverse(range(s));
				swap(u,v);
			}
			int lca=::lca(u,v);
			if(dep[u]+dep[v]-2*dep[lca]<len){
				cout<<"0\n";
				continue;
			}
			int ans=solve(u,lca,s);
			if(lca!=v){
				ans+=solve(v,lca,string(s.rbegin(),s.rend()));
				int u_=kth_anc(u,max(0,dep[u]-dep[lca]-(len-1)));
				int v_=kth_anc(v,max(0,dep[v]-dep[lca]-(len-1)));
				vector<int> vec,vec_;
				for(;u_!=lca;u_=fa[u_]){
					vec.push_back(faw[u_]);
				}
				for(;v_!=lca;v_=fa[v_]){
					vec_.push_back(faw[v_]);
				}
				reverse(range(vec_));
				vec.insert(vec.end(),range(vec_));
				ans+=match(vec,get_hash(s));
			}
			cout<<ans<<'\n';
		}
	}
	return 0;
}