#include <bits/stdc++.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;
mt19937_64 eng(random_device{}());
const int N=2e5+5,LogN=18;
int n,a[N];
ull val[N];
struct Tree{
	int fa[N];
	vector<int> e[N],son[N];
	ull pre[N];
	void input(){
		For(i,2,n){
			cin>>fa[i];
			e[fa[i]].push_back(i);
			e[i].push_back(fa[i]);
		}
	}
	int dep[N],siz[N],dfn[N],rk[N],dfx,mn[N][LogN];
	void dfs(int u){
		pre[u]=pre[fa[u]]^val[u];
		dep[u]=dep[fa[u]]+1;
		rk[dfn[u]=++dfx]=u;
		siz[u]=1;
		for(int v:e[u]){
			if(v!=fa[u]){
				dfs(v);
				siz[u]+=siz[v];
			}
		}
	}
	int argmin(int u,int v){
		return dfn[u]<dfn[v]?u:v;
	}
	void build(){
		For(i,1,n){
			son[i]=e[i];
			if(i>1){
				son[i].erase(find(range(son[i]),fa[i]));
			}
		}
		dfs(1);
		For(i,1,n) mn[i][0]=fa[rk[i]];
		For(j,1,LogN-1){
			For(i,1,n-(1<<j)+1){
				mn[i][j]=argmin(mn[i][j-1],mn[i+(1<<(j-1))][j-1]);
			}
		}
	}
	bool subtree(int u,int v){
		return dfn[u]<=dfn[v]&&dfn[v]<dfn[u]+siz[u];
	}
	int lca(int u,int v){
		if(u==v) return u;
		if((u=dfn[u])>(v=dfn[v])) swap(u,v);
		int k=__lg(v-(u++));
		return argmin(mn[u][k],mn[v-(1<<k)+1][k]);
	}
	int toward(int u,int v){
		if(!subtree(u,v)) return fa[u];
		if(u==v) return u;
		int l=0,r=int(son[u].size())-1;
		while(l<r){
			int mid=(l+r+1)/2;
			if(dfn[son[u][mid]]<=dfn[v]) l=mid;
			else r=mid-1;
		}
		return son[u][l];
	}
	ull chain_val(int u,int v){
		return pre[u]^pre[v]^val[lca(u,v)];
	}
}t1,t2;
struct Path{
	int u,v;
	bool include(int x){
		int lca=t2.lca(u,v);
		return x==lca||t2.subtree(x,u)!=t2.subtree(x,v);
	}
	bool insert(int x){
		if(include(x)) return 1;
		if(Path{u,x}.include(v)) v=x;
		else if(Path{v,x}.include(u)) u=x;
		else return 0;
		return 1;
	}
}; 
int siz[N],mxsiz[N],vis[N];
void get_root(int u,int fa,int tot,int& rt){
	siz[u]=1;
	mxsiz[u]=0;
	for(int v:t1.e[u]){
		if(v!=fa&&!vis[v]){
			get_root(v,u,tot,rt);
			siz[u]+=siz[v];
			mxsiz[u]=max(mxsiz[u],siz[v]);
		}
	}
	mxsiz[u]=max(mxsiz[u],tot-siz[u]);
	if(!rt||mxsiz[u]<mxsiz[rt]) rt=u;
}
template<typename T>
ll calc(vector<T>& vec){
	sort(range(vec));
	ll ans=0;
	for(int i=0;i<int(vec.size());){
		int l=i;
		while(i<int(vec.size())&&vec[i]==vec[l]) ++i;
		ans+=1LL*(i-l)*(i-l-1)/2;
	}
	return ans;
}
template<typename T>
ll calc(vector<T>& vec1,vector<T>& vec2){
	sort(range(vec1));
	sort(range(vec2));
	ll ans=0;
	for(int i=0;i<int(vec1.size());++i){
		auto [L,R]=equal_range(range(vec2),vec1[i]);
		ans+=R-L;
	}
	return ans;
}
ll ans;
void solve(int u){
	int rt=0;
	get_root(u,0,siz[u],rt);
	vis[u=rt]=1;
	vector<tuple<ull,int,int>> vec;
	vector<pair<ull,int>> nvec1,nvec2;
	auto dfs=[&](auto dfs,int u,int fa,ull cur,Path pth){
		if(!pth.insert(u)) return;
		cur^=val[u];
		ull z=cur^t2.chain_val(pth.u,pth.v);
		if(!z) ++ans;
		if(pth.u!=rt&&pth.v!=rt){
			nvec1.emplace_back(z,t1.toward(rt,u));
		}
		nvec2.emplace_back(cur^val[rt],t1.toward(rt,u));
		for(int x:{pth.u,pth.v}){
			vec.emplace_back(cur^t2.chain_val(x,rt),t1.toward(rt,u),t2.toward(rt,x));
		}
		for(int v:t1.e[u]){
			if(v!=fa&&!vis[v]){
				dfs(dfs,v,u,cur,pth);
			}
		}
	};
	for(int v:t1.e[u]){
		if(!vis[v]){
			dfs(dfs,v,u,val[u],{u,u});
		}
	}
	vector<ull> vec1;
	vector<pair<ull,int>> vec2,vec3;
	for(auto [v1,v2,v3]:vec){
		vec1.push_back(v1);
		vec2.emplace_back(v1,v2);
		vec3.emplace_back(v1,v3);
	}
	ans+=calc(vec1)-calc(vec2)-calc(vec3)+calc(vec);
	vector<ull> nvec1_,nvec2_;
	for(auto [v1,v2]:nvec1){
		nvec1_.push_back(v1);
	}
	for(auto [v1,v2]:nvec2){
		nvec2_.push_back(v1);
	}
	ans+=calc(nvec1_,nvec2_)-calc(nvec1,nvec2);
	for(int v:t1.e[u]){
		if(!vis[v]) solve(v);
	}
}
int main(){
	cin.tie(nullptr)->sync_with_stdio(false);
	cin>>n;
	ans=n;
	For(i,1,n) val[i]=eng();
	t1.input();
	t2.input();
	t1.build();
	t2.build();
	siz[1]=n;
	solve(1);
	cout<<ans<<'\n';
	return 0;
}