#include <bits/stdc++.h>

using namespace std;

using ll = long long;

const int mod = 1e9 + 7;
int norm(int x) { return x >= mod ? x - mod : x; }
int reduce(int x) { return x < 0 ? x + mod : x; }
int neg(int x) { return x ? mod - x : 0; }
int quo2(int x) { return (x + (x & 1 ? mod : 0)) >> 1; }
void add(int &x, int y) { x += y, x = x >= mod ? x - mod : x; }
void sub(int &x, int y) { x -= y, x = x < 0 ? x + mod : x; }
void fam(int &x, int y, int z) { x = (x + (ll)y * z) % mod; }
int mpow(int a, int b) {
  int ret = 1;
  for (; b; b >>= 1) {
    if (b & 1) ret = (ll)ret * a % mod;
    a = (ll)a * a % mod;
  }
  return ret;
}

const int N = 1599;

int n, m;
int fac[N + 5], ifac[N + 5], inv[N + 5], binom[N + 5][N + 5];
vector<pair<int, int>> e[N + 5];
pair<int, int> edge[N * 2 + 5];
int d0[N + 5], d1[N + 5], r0, r1, r, rt;
int dis[N + 5][N + 5];
int dfs(int u, int fa, int *dep) {
  int ret = u;
  for (auto [v, _] : e[u])
    if (v != fa) {
      dep[v] = dep[u] + 1;
      int w = dfs(v, u, dep);
      if (dep[w] > dep[ret]) ret = w;
    }
  return ret;
}

int c0[N + 5][N + 5], c1[N + 5][N * 2 + 5];
int ans;
int f[N * 2 + 5][N + 5];

int main() {
  scanf("%d", &n), fac[0] = 1;
  for (int i = 1; i <= n; ++i) fac[i] = (ll)fac[i - 1] * i % mod;
  ifac[n] = mpow(fac[n], mod - 2);
  for (int i = n; i; --i) ifac[i - 1] = (ll)ifac[i] * i % mod;
  for (int i = 1; i <= n; ++i) inv[i] = (ll)ifac[i] * fac[i - 1] % mod;
  for (int i = 0; i <= n; ++i) {
    binom[i][0] = 1;
    for (int j = 1; j <= i; ++j) add(binom[i][j] = binom[i - 1][j - 1], binom[i - 1][j]);
  }
  for (int i = 1; i < n; ++i) {
    int u, v; scanf("%d%d", &u, &v),
    e[u].emplace_back(i + n, m), edge[m++] = {u, i + n},
    e[i + n].emplace_back(u, m), edge[m++] = {i + n, u},
    e[v].emplace_back(i + n, m), edge[m++] = {v, i + n},
    e[i + n].emplace_back(v, m), edge[m++] = {i + n, v};
  }
  r0 = dfs(1, 0, d0), d0[r0] = 0, r1 = dfs(r0, 0, d0), dfs(r1, 0, d1), r = d0[r1] >> 1;
  for (rt = 1; d0[rt] != r || d1[rt] != r; ++rt);
  for (int u = 1; u < n * 2; ++u) dfs(u, 0, dis[u]);
  for (int u = 1; u < n * 2; ++u) {
    for (int v = 1; v < n * 2; ++v)
      if (dis[u][v] <= r) ++c0[dis[u][v]][u];
    for (auto [v, eId] : e[u])
      for (int w = 1; w < n * 2; ++w)
        if (dis[u][w] <= r && dis[v][w] < dis[u][w])
          ++c1[dis[u][w]][eId];
  }
  for (int k = r; k; --k) {
    if (k == r) {
      auto [_, i] = e[rt][0];
      f[i][c0[k][rt] - c1[k][i]] = 1;
    }
    for (int i = 0; i < m; ++i)
      if ((edge[i].first <= n) != (k & 1)) {
        auto [u, v] = edge[i];
        for (int j = 1; j <= c0[k][u] - c1[k][i]; ++j) {
          if (!f[i][j]) continue;
          for (int l = 1; l <= c1[k][i]; ++l)
            f[i ^ 1][l] = (
              f[i ^ 1][l] + (ll)f[i][j] * binom[j - 1 + c1[k][i] - l][j - 1] % mod * fac[c0[k][u] - c1[k][i]]
            ) % mod;
          for (auto [w, eId] : e[u]) {
            if (eId == i) continue;
            int t = (ll)f[i][j] * fac[c1[k][i]] % mod * fac[c0[k][u] - c1[k][i] - c1[k][eId]] % mod;
            for (int l = 1; l <= j && l <= c1[k][eId]; ++l)
              f[eId ^ 1][l] = (
                f[eId ^ 1][l] + (
                  (ll)binom[j - l + c1[k][i]][c1[k][i]] *
                    binom[c0[k][u] - c1[k][i] - l][c0[k][u] - c1[k][i] - c1[k][eId]] +
                  (ll)(mod - binom[j - l + c1[k][i] - 1][c1[k][i]]) *
                    binom[c0[k][u] - c1[k][i] - l - 1][c0[k][u] - c1[k][i] - c1[k][eId]]
                ) % mod * t
              ) % mod;
          }
          f[i][j] = 0;
        }
      }
  }
  for (int i = 0; i < m; ++i) add(ans, f[i][1]);
  printf("%d\n", ans);
}