#include <cstdio>
#include <cstring>
#include <numeric>
#include <algorithm>
#include <cctype>
#include <queue>
#include <vector>
#include <set>
#include <map>
#include <cmath>

namespace uvu
{
// #define LOCAL ________________DONT_DEFINE_ME_______________
#define ll long long
#define inf 0x3f3f3f3f
// #define int long long
// #define inf 0x3f3f3f3f3f3f3f3fll
#define infll 0x3f3f3f3f3f3f3f3fll
#define debug(...) fprintf(stderr, __VA_ARGS__)
#define gline debug("now is #%d\n", __LINE__)
#define pii std::pair <int, int>
#define mkp std::make_pair
#define fi first
#define se second
char _ST_;
const int BUFSIZE = (1 << 20);
char ibuf[BUFSIZE], *iS = ibuf, *iT = ibuf;
char obuf[BUFSIZE], *oS = obuf, *oT = obuf + BUFSIZE;
char getc()
{
#ifdef LOCAL
	return getchar();
#else
	if(iS == iT) iT = (iS = ibuf) + fread(ibuf, 1, BUFSIZE, stdin);
	return (iS == iT) ? EOF : *iS++;
#endif
#define getchar ERR
}
void Flush() { fwrite(obuf, 1, oS - obuf, stdout); oS = obuf; }
struct Flusher { ~Flusher() { Flush(); } }iamflusher;
void putc(char c)
{
#ifdef LOCAL
	putchar(c);
#else
	*oS++ = c;
	if(oS == oT) Flush();
#endif
}
template <typename T = int> T read()
{
	T x = 0, f = 1; char c = getc();
	for(; !isdigit(c); c = getc()) if(c == '-') f = -1;
	for(;  isdigit(c); c = getc()) x = (x << 3) + (x << 1) + (c ^ 48);
	return x * f;
}
template <typename T> void print(T x, char c)
{
static int sta[BUFSIZE], top;
	top = 0;
	if(x < 0) putc('-'), x *= -1;
	if(!x) sta[++top] = 0;
	for(; x; x /= 10) sta[++top] = x % 10;
	for(; top; putc(sta[top--] ^ 48));
	if(c) putc(c);
}
int readstr(char *s, int base)
{
	int idx = base - 1; char c = getc();
	for(; !(isdigit(c) || isalpha(c) || c == '#' || c == '.'); c = getc());
	for(;   isdigit(c) || isalpha(c) || c == '#' || c == '.' ; c = getc()) s[++idx] = c;
	return idx - base + 1;
}
void printf(const char *s) { for(; *s; s++) putc(*s); }
template <typename T, typename ... Args >
void printf(const char *s, T x, Args ... rest)
{
	for(; *s; s++)
	{
		if(*s != '%') { putc(*s); continue; }
		s++; if(*s == 'd') print(x, 0);
		else if(*s == 'c') putc(x);
		printf(s + 1, rest ...);
		return;
	}
}
template <typename T> void ckmin(T &x, T y) { x = x < y ? x : y; }
template <typename T> void ckmax(T &x, T y) { x = x > y ? x : y; }
#define mod 998244353
// #define mod 1000000007
int sm(int x) { return x >= mod ? x - mod : x; }
void plus_(int &x, int y) { x = sm(x + y); }
void mul_(int &x, int y) { x = 1ll * x * y % mod; }
int ksm(int a, int b) { int res = 1; for(; b; b >>= 1, mul_(a, a)) if(b & 1) mul_(res, a); return res; }
#define N 200010
int n;
#define ull unsigned long long
ull val[N];
ull sd = ('x' + 'i' + 'n' + 'y' + 'u' + 'e');
ull rnd()
{
	sd ^= sd << 13;
	sd ^= sd >> 7;
	sd ^= sd << 11;
	return sd;
}
bool vis[N];
struct tree
{
	std::vector <int> vec[N];
	void add(int x, int y) { vec[x].push_back(y), vec[y].push_back(x); }
	int top[N], dfn[N], fdfn[N], dep[N], fa[N], sz[N], hson[N];
	ull dis[N];
	void dfs0(int k, int f) 
	{
		sz[k] = 1; fa[k] = f; dep[k] = dep[f] + 1; dis[k] = dis[f] ^ val[k];
		for(int nx : vec[k]) if(nx != f) { dfs0(nx, k); sz[k] += sz[nx]; if(sz[nx] >= sz[hson[k]]) hson[k] = nx; }
	}
	void dfs1(int k, int tp)
	{
		top[k] = tp; fdfn[dfn[k] = ++dfn[0]] = k;
		if(hson[k]) dfs1(hson[k], tp);
		for(int nx : vec[k]) if(nx != fa[k] && nx != hson[k]) dfs1(nx, nx);
	}
	int LCA(int x, int y) 
	{ 
		for(; top[x] != top[y]; x = fa[top[x]]) if(dep[top[x]] < dep[top[y]]) x ^= y ^= x ^= y;
		return dep[x] < dep[y] ? x : y; 
	}
	void init() { for(int i = 2; i <= n; i++) add(read(), i); dfs0(1, 0); dfs1(1, 1); }
	int full, minnum, root;
	void getroot(int k, int fa)
	{
		int maxnum = 0; sz[k] = 1;
		for(int nx : vec[k]) if(nx != fa && !vis[nx]) { getroot(nx, k); sz[k] += sz[nx]; ckmax(maxnum, sz[nx]); }
		ckmax(maxnum, full - sz[k]); if(maxnum <= minnum) minnum = maxnum, root = k;
	}
	void Getroot(int k, int Full) { full = Full, minnum = inf, root = 0; getroot(k, 0); }
}T1, T2;
ll ans;
bool insta[N];
int sta[N << 1], top, from[N];
ull disA[N], disB[N]; int dep[N];
void dfs2(int k, int fa, int tp)
{
	disA[k] = disA[fa] ^ val[k];  dep[k] = dep[fa] + 1;
	from[k] = tp; sta[++top] = k; T1.sz[k] = 1;
	for(int nx : T1.vec[k]) if(!vis[nx] && nx != fa) dfs2(nx, k, tp), T1.sz[k] += T1.sz[nx];
}
std::map <ull, int> mpA, mpB, mpC;
std::map <std::pair <ull, int>, int> mpf;
void dfs3(int k, int fa, int f1, int p, int f2, int q)
{
	disB[k] = disB[fa] ^ val[k];
	if(f2 && from[k] != f1 && from[k] != f2) return;
	if(from[k] == f1 && dep[k] == dep[p]) return; 
	if(from[k] == f1 && dep[k] > dep[p]) p = k;
	if(from[k] == f2 && dep[k] == dep[q]) return;
	if(from[k] == f2 && dep[k] > dep[q]) q = k;
	if(!f1) f1 = from[k], p = k;
	if(!f2 && from[k] != f1) f2 = from[k], q = k;
	// printf("k = %d (%d %d %d %d)\n", k, f1, p, f2, q);

	// if(!f2 && disB[k] == disA[p]) ans++;//, printf("ans++ (A)\n");
	// if(f2 && disB[k] == (disA[p] ^ disA[q])) ans++;//, printf("ans++ (B)\n");
	// if(!f2) ans += mpA[disB[k] ^ disA[p]], ans += mpB[disB[k]];//, printf("ans += %d (C)\n", mpB[disB[k]]);
	// if(f2)  ans += mpA[disB[k] ^ disA[p] ^ disA[q]];//, printf("ans += %d (D)\n", mpA[disB[k] ^ disA[p] ^ disA[q]]);
	// ans += mpB[disB[k] ^ disA[p]] - mpf[mkp(disB[k] ^ disA[p], f1)];//, printf("ans += %d - %d (E)\n", mpB[disB[k] ^ disA[p]], mpf[mkp(disB[k] ^ disA[p], f1)]);
	// if(f2)  ans += mpB[disB[k] ^ disA[q]] - mpf[mkp(disB[k] ^ disA[q], f2)];//, printf("ans += %d - %d (F)\n", mpB[disB[k] ^ disA[q]], mpf[mkp(disB[k] ^ disA[q], f2)]);
	// ans += mpC[disB[k]];//, printf("ans += %d (G)\n", mpC[disB[k]]);

	for(int nx : T2.vec[k]) if(insta[nx] && !vis[nx] && nx != fa) dfs3(nx, k, f1, p, f2, q); 
}
void dfs4(int k, int fa, int f1, int p, int f2, int q)
{
	disB[k] = disB[fa] ^ val[k];
	if(f2 && from[k] != f1 && from[k] != f2) return;
	if(from[k] == f1 && dep[k] == dep[p]) return; 
	if(from[k] == f1 && dep[k] > dep[p]) p = k;
	if(from[k] == f2 && dep[k] == dep[q]) return;
	if(from[k] == f2 && dep[k] > dep[q]) q = k;
	if(!f1) f1 = from[k], p = k;
	if(!f2 && from[k] != f1) f2 = from[k], q = k;

	// mpA[disB[k]]++;
	//        mpB[disB[k] ^ disA[p]]++, mpf[mkp(disB[k] ^ disA[p], f1)]++;
	// if(f2) mpB[disB[k] ^ disA[q]]++, mpf[mkp(disB[k] ^ disA[q], f2)]++;
	// if(f2) mpC[disB[k] ^ disA[p] ^ disA[q]]++;

	for(int nx : T2.vec[k]) if(insta[nx] && !vis[nx] && nx != fa) dfs4(nx, k, f1, p, f2, q); 
}
int cnt;
void calc(int k)
{
	ans++; mpA.clear(), mpB.clear(), mpC.clear(), mpf.clear();
	top = 0; disA[k] = 0; dep[k] = 0; for(int nx : T1.vec[k]) if(!vis[nx]) dfs2(nx, k, nx);
	// debug("top = %d\n", top);
	if(!top) return;
	cnt += top;
	// printf("k = %d, sta : ", k); for(int i = 1; i <= top; i++) printf("%d(%d) ", sta[i], from[sta[i]]); putc('\n');
	for(int i = 1; i <= top; i++) insta[sta[i]] = 1;
	disB[k] = 0; 
	for(int nx : T2.vec[k]) if(insta[nx] && !vis[nx]) dfs3(nx, k, 0, 0, 0, 0), dfs4(nx, k, 0, 0, 0, 0);
	for(int i = 1; i <= top; i++) insta[sta[i]] = 0;
}
void sv(int k, int dep)
{
	// debug("k = %d, dep = %d ", k, dep);
	vis[k] = 1; calc(k);
	for(int nx : T1.vec[k]) if(!vis[nx]) T1.Getroot(nx, T1.sz[nx]), sv(T1.root, dep + 1);
}
void solve()
{
	n = read(); for(int i = 1; i <= n; i++) val[i] = rnd();
	T1.init(), T2.init();
	T1.Getroot(1, n); sv(T1.root, 1);
	debug("cnt = %d\n", cnt);
	print(ans, '\n');
}
void init()
{

}
char _ED_;
void mian()
{
	debug("%.3f MB\n", abs(&_ST_ - &_ED_) / 1024.0 / 1024);
	init();
	int T = 1;
	for(; T; solve(), T--);
}
#ifdef int
	#undef int
#endif
}

int main()
{
	uvu::mian(); return 0;
}