final int MOD = 1000 * 1000 * 1000 + 7;

List<Integer>[] w;
int[] height, subtree;
int[][] cntDistance; // cntDistance[A][d] - in subtree of A, how many vertices are at distance d from A

void dfs(int a, int parent) {
  cntDistance[a][0] = 1;
  height[a] = 0;
  subtree[a] = 1;
  for(int b : w[a]) if(b != parent) {
    dfs(b, a);
    height[a] = max(height[a], height[b] + 1);
    subtree[a] += subtree[b];
    for(int i = 0; i <= height[b]; ++i)
      cntDistance[a][i+1] += cntDistance[b][i];
  }
}

public int solve(int[] parent) {
  final int N = parent.length + 1;
  if(N == 1) return 0;
  int[][] C = new int[N+1][N+1];
  for(int i = 0; i <= N; ++i) {
    C[i][i] = C[i][0] = 1;
    for(int j = 1; j < i; ++j)
      C[i][j] = (C[i-1][j] + C[i-1][j-1]) % MOD;
  }
  w = new List[N];
  for(int a = 0; a < N; ++a)
    w[a] = new ArrayList<Integer>();
  for(int a = 1; a < N; ++a) {
    int b = parent[a-1];
    w[a].add(b);
    w[b].add(a);
  }
  int[] totalGoodSubsets = new int[N+1]; // how many subsets of N vertices are enough to detect the special vertex
  for(int root = 0; root < N; ++root) {
    height = new int[N];
    subtree = new int[N];
    cntDistance = new int[N][N];
    dfs(root, -1);
    List<Integer> childrenAndRoot = new ArrayList<Integer>();
    for(int x : w[root]) childrenAndRoot.add(x);
    childrenAndRoot.add(root);
    height[root] = 0; // fake value
    for(int child : childrenAndRoot)
      for(int my_dist = 0; my_dist <= height[child]; ++my_dist) {
        boolean isRoot = child == root; // treasure is in the root
        if (cntDistance[child][my_dist] == 1 || isRoot) {
          int[][] subsets = new int[N][3]; // subsets[S][SUB] - how many subsets of N-1 vertices have size 'S' and are from 'SUB' subtrees
          subsets[0][0] = 1;
          for (int c : w[root])
            if (c != child)
              for (int S = N - 1; S >= 0; --S)
                for (int SUB = 2; SUB >= 0; --SUB)
                  if (subsets[S][SUB] != 0) {
                    for (int here = 1; here <= subtree[c]; ++here) {
                      int S2 = S + here;
                      int SUB2 = min(SUB + 1, 2);
                      subsets[S2][SUB2] = (int) ((subsets[S2][SUB2] + (long) subsets[S][SUB] * C[subtree[c]][here]) % MOD);
                    }
                    if (height[c] >= my_dist && !isRoot)
                      subsets[S][SUB] = 0; // we must take a vertex from this subtree
                    // so it's forbidden not to take anything (here = 0)
                  }
          // now we must consider taking the root
          for (int size = 0; size <= N - 1; ++size) {
            totalGoodSubsets[size] = (totalGoodSubsets[size] + subsets[size][2]) % MOD; // no root
            for (int SUB = 0; SUB <= 2; ++SUB)
              totalGoodSubsets[size + 1] = (totalGoodSubsets[size + 1] + subsets[size][SUB]) % MOD; // with root
          }

        }
      }
  }
  int[] fac = new int[N+1];
  fac[0] = 1;
  for(int i = 1; i <= N; ++i)
    fac[i] = (int) ((long) fac[i-1] * i % MOD);
  long answer = 0;
  for(int size = 0; size <= N; ++size) {
    long badSubsets = (long) C[N][size] * N - totalGoodSubsets[size];
    answer = (answer + badSubsets % MOD * fac[size] % MOD * fac[N-size]) % MOD;
    if(answer < 0) answer += MOD;
  }
  return (int) answer;
}