#include <bits/stdc++.h>

using namespace std;

template <class T> void mini(T &l, T r) {l = min(l, r);}
template <class T> void maxi(T &l, T r) {l = max(l, r);}

string to_string(string s) {
  return '"' + s + '"';
}
 
string to_string(const char* s) {
  return to_string((string) s);
}
 
template <typename A, typename B>
string to_string(pair<A, B> p) {
  return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}
 
template <typename A>
string to_string(A v) {
  bool first = true;
  string res = "{";
  for (const auto &x : v) {
    if (!first) {
      res += ", ";
    }
    first = false;
    res += to_string(x);
  }
  res += "}";
  return res;
}
 
void debug_out() { cerr << endl; }
 
template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T) {
  cerr << " " << to_string(H);
  debug_out(T...);
}
 
#ifdef LOCAL
#define debug(...) cerr << "[" << #__VA_ARGS__ << "]:", debug_out(__VA_ARGS__)
#else
#define debug(...) 42
#endif

using ll = long long;
const int N = 5010, B = 1e9 + 7;

int n;
vector <int> e[N];
ll ans;
int sz[N];
int mx[N];

ll mypw(ll a, int b) {
  ll ret = 1;
  while (b) {
    if (b & 1) ret = ret * a % B;
    b >>= 1;
    a = a * a % B;
  }
  return ret;
}

struct Modint {
  ll x;

  Modint(ll a = 0) {
    x = a % B;
    if (x < 0) x += B;
  }

  Modint inv() {
    return Modint(mypw(x, B - 2));
  }

  Modint operator+(Modint b) {
    return Modint(x + b.x);
  }

  Modint operator-(Modint b) {
    return Modint(x - b.x);
  }

  Modint operator*(Modint b) {
    return Modint(x * b.x);
  }

  Modint operator/(Modint b) {
    return (*this) * b.inv();
  }

};

string to_string(Modint a) {
  return to_string(a.x);
}

Modint f[N][N];
Modint fac[N], inv[N];

void upd(Modint &x, Modint y) {
  x = x + y;
}

void init() {
  fac[0] = 1;
  for (int i = 1; i < N; ++i) {
    fac[i] = fac[i - 1] * i;
  }
  for (int i = 0; i < N; ++i) {
    inv[i] = fac[i].inv();
  }
}

Modint C(int a, int b) {
  return fac[a] * inv[b] * inv[a - b];
}

void dfs(int u, int p = 0) {
  sz[u] = 1;
  int &mx = ::mx[u];
  for (auto v : e[u]) {
    if (v == p) continue;
    dfs(v, u);
    sz[u] += sz[v];
    mx = max(mx, sz[v]);
  }
  mx = max(mx, n - sz[u]);
}


void run() {
  init();

  cin >> n;
  for (int i = 1; i < n; ++i) {
    int x, y;
    cin >> x >> y;
    e[x].push_back(y);
    e[y].push_back(x);
  }

  dfs(1);

  int z = *min_element(mx + 1, mx + n + 1);
  debug(z);
  vector <int> cent;

  for (int i = 1; i <= n; ++i) if (mx[i] == z) {
    cent.push_back(i);
  }
  debug(cent);

  
  if ((int)cent.size() > 1) {
    cout << (fac[n / 2] * fac[n / 2]).x << endl;
    return;
  }
  
  dfs(cent.back());

  vector <int> vv;

  vv.push_back(0);
  for (auto v : e[cent.back()]) {
    vv.push_back(sz[v]);
  }
  
  debug(vv);
  int k = vv.size() - 1;

  f[0][0] = 1;
  int sum = 0;
  for (int i = 0; i < k; ++i) {
    sum += vv[i];
    for (int x = 0; x <= sum; ++x) {
      debug(f[i][x], i, x);
      for (int y = 0; y <= vv[i + 1]; ++y) {
        upd(f[i + 1][x + y], f[i][x] * C(vv[i + 1], y) * C(vv[i + 1], y) * fac[y]);
      }
    }
  }
  for (int x = 0; x < n; ++x) {
    debug(k, x, f[k][x]);
  }

  debug(C(5, 2));
  Modint ans = 0;
  int fl = 1;
  for (int i = 0; i < n; ++i) {
    upd(ans, fac[n - i] * f[k][i] * fl);
    debug(ans, fac[n - i], f[k][i]);
    fl *= -1;
  }

  cout << ans.x << endl;

}

int main() {
  run();
  return 0;
}


Measured memory_bytes: 196992