#include <bits/stdc++.h>
using namespace std;
#ifdef LOCAL
#define debug(...) fprintf(stderr, ##__VA_ARGS__)
#else
#define endl "\n"
#define debug(...) void(0)
#endif
using LL = long long;
mt19937_64 rng{random_device{}()};
using word = mt19937_64::result_type;
constexpr int N = 2e5 + 10;
word wei[N];
int n;
bool cut[N];
struct tree {
  basic_string<int> g[N];
  int dfn[N], siz[N], smx[N], dep[N], cnt, st[19][N];
  word sum[N];
  void dfs(int u, int fa) {
    dfn[u] = ++cnt, st[0][cnt] = fa, dep[u] = dep[fa] + 1, siz[u] = 1, sum[u] = sum[fa] ^ wei[u];
    for (int v : g[u]) if (v != fa) dfs(v, u), siz[u] += siz[v];
  }
  int lca(int u, int v) {
    if (u == v) return u;
    int l = min(dfn[u], dfn[v]) + 1, r = max(dfn[u], dfn[v]);
    int k = __lg(r - l + 1);
    auto cmp = [&](int _u, int _v) { return dfn[_u] < dfn[_v]; };
    return min(st[k][l], st[k][r - (1 << k) + 1], cmp);
  }
  int dist(int u, int v) { return dep[u] + dep[v] - 2 * dep[lca(u, v)]; }
  word P(int u, int v) { return sum[u] ^ sum[v] ^ wei[lca(u, v)]; }
  void init() {
    for (int i = 1; i <= n; i++) g[i].clear();
    cnt = 0;
    smx[0] = 1e9;
    for (int i = 2, fa; i <= n; i++) cin >> fa, g[i] += fa, g[fa] += i, debug("%d %d\n", i, fa);
    dfs(1, 0);
    auto cmp = [&](int u, int v) { return dfn[u] < dfn[v]; };
    for (int j = 1; j < 19; j++) {
      for (int i = 1; i + (1 << j) - 1 <= n; i++) {
        st[j][i] = min(st[j - 1][i], st[j - 1][i + (1 << (j - 1)) - 1], cmp);
      }
    }
  }
  int findcen(int u, int fa, int T) {
    siz[u] = 1, smx[u] = 0;
    int rt = 0;
    for (int v : g[u]) if (v != fa && !cut[v]) {
      int nrt = findcen(v, u, T);
      if (smx[nrt] < smx[rt]) rt = nrt;
      siz[u] += siz[v], smx[u] = max(smx[u], siz[v]);
    }
    smx[u] = max(smx[u], T - siz[u]);
    if (smx[u] < smx[rt]) rt = u;
    return rt;
  }
} t1, t2;
using robot = array<int, 2>;
constexpr robot ERR{-1, -1};
robot expand(robot bt, int x) {
  int d1 = t2.dist(bt[0], x), d2 = t2.dist(bt[1], x), d3 = t2.dist(bt[0], bt[1]);
  if (d1 + d2 == d3) return bt;
  if (d1 + d3 == d2) return {x, bt[1]};
  if (d2 + d3 == d1) return {bt[0], x};
  return ERR;
}
LL ans = 0;
void solve(int rt) {
  map<word, int> mp[3];
  auto insert = [&](robot bt, word S) {
    word T[] = {t2.P(rt, bt[0]) ^ wei[rt], t2.P(rt, bt[1]) ^ wei[rt]};
    mp[0][S ^ T[0] ^ T[1]] += 1;
    mp[1][S] += 1;
    if (T[0]) mp[2][S ^ T[0]] += 1;
    if (T[1]) mp[2][S ^ T[1]] += 1;
  };
  auto query = [&](robot bt, word S) {
    word T[] = {t2.P(rt, bt[0]) ^ wei[rt], t2.P(rt, bt[1]) ^ wei[rt]};
    ans += mp[0][S];
    ans += mp[1][S ^ T[0] ^ T[1]];
    if (T[0]) ans += mp[2][S ^ T[0]];
    if (T[1]) ans += mp[2][S ^ T[1]];
  };
  vector<int> dfnr;
  for (int v : t2.g[rt]) if (t2.dfn[v] > t2.dfn[rt]) dfnr.push_back(t2.dfn[v]);
  sort(dfnr.begin(), dfnr.end());
  auto gid = [&](int u) {
    if (t2.dfn[rt] <= t2.dfn[u] && t2.dfn[u] < t2.dfn[rt] + t2.siz[rt]) {
      return (int)(upper_bound(dfnr.begin(), dfnr.end(), t2.dfn[u]) - dfnr.begin() - 1);
    }
    return (int)dfnr.size();
  };
  struct node {
    int b;
    word S;
    int op;
  };
  vector<vector<node>> buc(dfnr.size() + 1);
  auto dfs1 = [&](auto dfs1, int u, int fa, robot bt, word S, int op) {
    bt = expand(bt, u), S ^= wei[u];
    debug("dfs1(%d, %d, {%d, %d}, %lx, %d)\n", u, fa, bt[0], bt[1], S, op);
    if (bt == ERR) return ;
    if (op) ans += (S ^ wei[rt]) == t2.P(bt[0], bt[1]);
    if (op) debug("P1(%d, %d) -> P2(%d, %d)\n", u, rt, bt[0], bt[1]);
    node state{-1, S, op};
    if (bt[0] != rt) state.b = bt[0], buc[gid(bt[0])].push_back(state);
    if (bt[1] != rt) state.b = bt[1], buc[gid(bt[1])].push_back(state);
    if (op) query(bt, S);
    else insert(bt, S);
    for (int v : t1.g[u]) if (v != fa && !cut[v]) dfs1(dfs1, v, u, bt, S, op);
  };
  for (int v : t1.g[rt]) if (!cut[v]) dfs1(dfs1, v, rt, {rt, rt}, 0, +1), dfs1(dfs1, v, rt, {rt, rt}, 0, 0);
  for (auto bc : buc) {
    mp[2].clear();
    for (auto opt : bc) {
      auto b = opt.b;
      auto S = opt.S;
      word T = t2.P(rt, b) ^ wei[rt];
      if (opt.op) {
        if (T) ans -= mp[2][S ^ T];
      } else {
        if (T) mp[2][S ^ T] += 1;
      }
    }
  }
}
void dfz(int u) {
  solve(u), cut[u] = true;
  for (int v : t1.g[u]) if (!cut[v]) dfz(t1.findcen(v, u, t1.siz[v]));
}
int main() {
#ifndef LOCAL
  cin.tie(nullptr)->sync_with_stdio(false);
#endif
  while (cin >> n) {
    ans = 0;
    memset(cut, false, sizeof cut);
    for (int i = 1; i <= n; i++) wei[i] = rng(), debug("wei[%d] = %lx\n", i, wei[i]);
    t1.init(), t2.init();
    dfz(t1.findcen(1, 0, n));
    cout << ans + n << endl;
  }
  return 0;
}