#include <bits/stdc++.h>
using namespace std;
#define rep(a, b, c) for (int a = (b); a < (c); a++)
#define sz(x) int(size(x))
#define all(x) begin(x), end(x)
using ll = long long;
using vi = vector<int>;
using pii = pair<int, int>;

const ll MOD = (119 << 23) + 1;
ll modpow(ll a, ll n) {
    ll ans = 1;
    for (; n > 0; n /= 2, a = a * a % MOD)
        if (n & 1) ans = ans * a % MOD;
    return ans;
}


const ll mod = (119 << 23) + 1, root = 62;
typedef vector<ll> vl;
void ntt(vl& a) {
    int n = sz(a), L = 31 - __builtin_clz(n);
    static vl rt(2, 1);
    for (static int k = 2, s = 2; k < n; k *= 2, s++) {
        rt.resize(n);
        ll z[] = {1, modpow(root, mod >> s)};
        rep (i, k, 2*k) rt[i] = rt[i / 2] * z[i & 1] % mod;
    }
    vi rev(n);
    rep (i,0,n) rev[i] = (rev[i / 2] | (i & 1) << L) / 2;
    rep (i,0,n) if (i < rev[i]) swap(a[i], a[rev[i]]);
    for (int k = 1; k < n; k *= 2)
        for (int i = 0; i < n; i += 2*k) rep (j, 0, k) {
            ll z = rt[j + k] * a[i + j + k] % mod, &ai = a[i + j];
            a[i + j + k] = ai - z + (z > ai ? mod : 0);
            ai += (ai + z >= mod ? z - mod : z);
        }
}

// const int LIM = 1024;
// template<int K = 32>
// vl slowConv(const vl& a, const vl& b) {
//     if (K < sz(a) + sz(b) - 1) return slowConv<min(2*K, LIM)>(a, b);
//     using bs = bitset<K>;
    
//     bs B, C;
//     rep (i, 0, sz(b)) B[i] = b[i];
    
//     rep (i, 0, sz(a)) if (a[i]) C |= B << i;

//     vl c(sz(a) + sz(b) - 1);
//     rep (i, 0, sz(c)) c[i] = C[i];
//     return c;
// }
const int LIM = 2048;
// template<int K = 32>
vl slowConv(const vl& a, const vl& b) {
    // if (K < sz(a) + sz(b) - 1) return slowConv<min(2*K, LIM)>(a, b);
    using bs = bitset<LIM>;
    
    bs B, C;
    rep (i, 0, sz(b)) B[i] = b[i];
    
    rep (i, 0, sz(a)) if (a[i]) C |= B << i;

    vl c(sz(a) + sz(b) - 1);
    rep (i, 0, sz(c)) c[i] = C[i];
    return c;
}

vl conv(const vl& a, const vl& b) {
    if (a.empty() || b.empty()) return {};
    int s = sz(a) + sz(b) - 1, B = 32 - __builtin_clz(s), n = 1 << B;

    if (s <= LIM) return slowConv(a, b);

    int inv = modpow(n, mod - 2);
    vl L(a), R(b), out(n);
    L.resize(n), R.resize(n);
    ntt(L), ntt(R);
    rep (i, 0, n) out[-i & (n-1)] = (ll)L[i] * R[i] % mod * inv % mod;
    ntt(out);
    rep (i, 0, s) out[i] = !!out[i];
    return {out.begin(), out.begin() + s};
}

void solve() {
    int n;
    cin >> n;

    vi p(n, -1);
    rep (i, 1, n) cin >> p[i], p[i]--;

    vi sub(n, 1), big(n);

    for (int i = n-1; i > 0; i--) {
        if (i > 0) {
            sub[p[i]] += sub[i];
            big[p[i]] = max(big[p[i]], sub[i]);
        }
        big[i] = max(big[i], n - sub[i]);
    }

    int rt = min_element(all(big)) - begin(big);

    vector<vl> f;
    priority_queue<pii> q;

    vi num(n+1);

    int cap = min(n / 2, n - 1 - big[rt]) + 1;
    ll ans = big[rt] * ll(n - 1 - big[rt]);

    rep (i, 0, n) if (p[i] == rt) {
        int k = sub[i];
        num[k]++;
    }

    if (n - sub[rt] > 0) {
        int k = n - sub[rt];
        num[k]++;
    }

    {
        vector<bool> dp(1);
        dp[0] = 1;

        for (int k = 1; k <= n; k++) if (num[k]) {
            int full = sz(dp) - 1 + num[k]*k;
            vector<vector<bool>> next(k, vector<bool>((full + k - 1) / k));
            dp.resize(full);

            rep (i, 0, k)
                for (int p = 0, j = i; j < sz(dp); p++, j += k)
                    next[i][p] = dp[j];

            rep (i, 0, k) {
                int on = 0;
                rep (j, 0, sz(next[i])) {
                    
                    on += next[i][j];

                    if (i + j*k < sz(dp))
                        dp[i + j*k] = dp[i + j*k] || !!on;

                    if (j >= num[k]) 
                        on -= next[i][j - num[k]];
                    
                }
            }
        }

        rep (i, 0, sz(dp)) if (dp[i]) ans = max(ans, i * ll(n - 1 - i));
    }

    vi down(n, -1);
    for (int x = rt, y = p[x]; x != 0; x = y, y = p[x]) {
        down[y] = x;
        p[x] = -1;
    }
    
    vector<ll> dp(n, 1);

    for (int i = n-1; i >= 0; i--) {
        if (p[i] != -1) 
            dp[p[i]] += dp[i];

        if (down[i] == -1 && i != rt) ans += dp[i];
    }

    for (int i = 0; i < n; i++) {
        if (down[i] != -1) {
            dp[down[i]] += dp[i];
            ans += dp[i];
        }
    }

    ans += dp[rt];
    cout << ans << "\n";
}

int main() {
    cin.tie(0)->sync_with_stdio(0);
    cin.exceptions(cin.failbit);

    // int t; cin >> t; while (t--)
    solve();

    return 0;
}