#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
#define ALL(v) v.begin(),v.end()
#define dbg(x) cerr << #x << ": " << (x) << endl;

template<class S, class W, S(*op)(S,S), S(*addRoot)(S,W,int,int), S(*e)()>
struct Rerooting {
    const vector<vector<pair<int,W>>>& g;
    vector<vector<S>> dp;
    vector<S> a;
    Rerooting(const vector<vector<pair<int,W>>>& g) : g(g), dp(g.size()), a(g.size(), e()) {
        dfs(0);
        dfs2(0, e());
    }
    S ans(int idx) {
        return a[idx];
    }
    S dfs(int v, int p = -1) {
        S cum = e();
        int deg = g[v].size();
        dp[v] = vector<S>(deg, e());
        W pw = 0;
        for (int i = 0; i < deg; ++i) {
            int u = g[v][i].first;
            if (u == p) {
                pw = g[v][i].second;
                continue;
            }
            dp[v][i] = dfs(u, v);
            cum = op(cum, dp[v][i]);
        }
        return addRoot(cum, pw, p, v);
    }
    void dfs2(int v, const S& s, int p = -1) {
        int deg = g[v].size();
        for (int i = 0; i < deg; ++i) if (g[v][i].first == p) {
            dp[v][i] = s;
        }
        vector<S> dpl(deg + 1, e()), dpr(deg + 1, e());
        for (int i = 0; i < deg; ++i) {
            dpl[i + 1] = op(dpl[i], dp[v][i]);
        }
        for (int i = deg - 1; i >= 0; --i) {
            dpr[i] = op(dp[v][i], dpr[i + 1]);
        }
        a[v] = addRoot(dpl[deg], 0, -1, v);
        for (int i = 0; i < deg; ++i) {
            auto [u,w] = g[v][i];
            if (u == p) continue;
            dfs2(u, addRoot(op(dpl[i], dpr[i + 1]), w, u, v), v);
        }
    }
};

int n;
vector<vector<pair<int,int>>> g;

struct S {
    ll cnt;
    ll sum;
};
S op(S a, S b) {
    a.cnt += b.cnt;
    a.sum += b.sum;
    return a;
}
S addRoot(S s, int w, int p, int c) {
    s.sum += s.cnt;
    s.cnt += 1;
    return s;
}
S e() {
    return S{0,0};
}

ll solve(vector<int>& cnt) {
    for (int i = 1; i < n; i++) {
        if (cnt[i] == 0) continue;

        int tmp = cnt[i];
        cnt[i] = 0;

        int x = 1;
        while (tmp > 0) {
            int mn = min(tmp,x);
            cnt[mn*i]++;
            tmp -= mn;
            x *= 2;
        }
    }

    vector<int> vv;
    for (int i = 1; i < n; i++) {
        for (int j = 0; j < cnt[i]; ++j) {
            vv.emplace_back(i);
        }
    }

    bitset<1000001> bs;
    bs.set(0);
    for (int i = 0; i < vv.size(); i++) {
        bs |= bs << vv[i];
    }

    ll ans = 0;
    for (int i = 0; i < n; ++i) {
        if (bs.test(i)) {
            ans = max(ans, (ll)i * (n - 1 - i));
        }
    }
    return ans;
}

int main() {
    cin >> n;
    g.resize(n);
    for (int i = 1; i < n; ++i) {
        int p;
        cin >> p;
        --p;
        g[i].emplace_back(p, 1);
        g[p].emplace_back(i, 1);
    }

    Rerooting<S,int,op,addRoot,e> rr(g);
    // for (int i = 0; i < n; ++i) {
    //     cerr << rr.ans(i).sum << " \n"[i==n-1];
    // }
    vector<bool> iscen(n,true);
    for (int i = 0; i < n; ++i) {
        for (int j = 0; j < g[i].size(); ++j) {
            if (rr.dp[i][j].cnt > n/2) {
                iscen[i] = false;
                break;
            }
        }
    }
    
    ll ans = 0;
    for (int i = 0; i < n; ++i) {
        if (iscen[i]) {
            vector<int> v(n);
            for (int j = 0; j < g[i].size(); ++j) v[rr.dp[i][j].cnt]++;
            ans = max(ans, solve(v) + rr.ans(i).sum);
        }
        else {
            ll k = 0;
            for (int j = 0; j < g[i].size(); ++j) {
                k = max(k, rr.dp[i][j].cnt);
            }
            ans = max(ans, k * (n - 1 - k) + rr.ans(i).sum);
        }
    }
    cout << ans + n << '\n';
}