#include <bits/stdc++.h>


using namespace std;


using ll = long long;

#define rep(i, n) for(int i = 0; i < (n); i += 1)
#define rng(i, start, end, step) for(int i = start; i < end; i += step)
#define len(a) ((int)(a).size())


mt19937 rnd(234);


struct edge {
    int to;
    int i;
};

const int maxn = 300;
const ll mod = 1e9 + 7;


ll bin_pow(ll x, ll n) {
    ll rs = 1;
    for (ll i = 1; i <= n; i *= 2, x = x * x % mod)
        if (n & i) rs = rs * x % mod;
    return rs;
}


ll inv(ll x) {
    return bin_pow(x, mod - 2);
}

int n;
vector<vector<edge>> g;
vector<pair<int, int>> edges;
int dists[maxn][maxn];
int cnt[2 * maxn - 2][maxn];
int dp1[(maxn - 1) / 2 + 1][2 * maxn - 2][maxn + 1];
int dp2[(maxn - 1) / 2 + 1][2 * maxn - 2][maxn + 1];

ll f[maxn + 1], invf[maxn + 1];


ll cnk(ll n, ll k) {
    if (n < 0 or k < 0 or k > n) return 0;
    assert(n <= maxn);
    return f[n] * invf[k] % mod * invf[n - k] % mod;
}


void dfs(int v, int p, int start, int d) {
    dists[start][v] = d;
    for (auto [to, i] : g[v]) {
        if (to == p) continue;
        dfs(to, v, start, d + 1);
    }
}


void add(int& a, int b) {
    a += b;
    if (a >= mod) a -= mod;
}

void sub(int& a, int b) {
    a -= b;
    if (a < 0) a += mod;
}


ll solve() {
    if (n == 1) {
        return 1;
    }
    f[0] = invf[0] = 1;
    for (int i = 1; i <= maxn; i += 1) {
        f[i] = f[i - 1] * i % mod;
        invf[i] = inv(f[i]);
    }
    memset(dists, 0, sizeof(dists));
    rep(v, n) dfs(v, -1, v, 0);
    memset(cnt, 0, sizeof(cnt));
    rep(e, 2 * n - 2) {
        auto [u, v] = edges[e];
        rep(x, n) if (dists[u][x] == dists[v][x] + 1) cnt[e][dists[v][x]] += 1;
    }

    int diam = -1;
    int du = -1;
    int dv = -1;
    rep(u, n) rep(v, n)
        if (dists[u][v] > diam) {
            diam = dists[u][v];
            du = u;
            dv = v;
        }
    int maxd = diam / 2;
    memset(dp1, 0, sizeof(dp1));
    memset(dp2, 0, sizeof(dp2));
    rep(e, 2 * n - 2) dp1[0][e][0] = 1;
    rep(e, 2 * n - 2) dp2[0][e][0] = 2;
    for (int d = 1; d <= maxd; d += 1) {
        rep(e, 2 * n - 2) {
            auto [u, v] = edges[e];
            if (cnt[e][d] == 0 or cnt[e ^ 1][d - 1] == 0) continue;
            rep(rest, cnt[e ^ 1][d - 1]) {
                for (auto [to, ne] : g[v]) {
                    if (to == u) continue;
                    if (cnt[ne][d - 1] == 0) continue;
                    int drest = cnt[ne ^ 1][d] - cnt[e ^ 1][d - 1];
                    assert(drest >= 0);
                    for (int take = 0; take <= rest + drest; take += 1) {
                        ll coeff = cnt[ne][d - 1] * f[cnt[ne][d - 1] - 1 + take] % mod;
                        coeff = coeff * cnk(rest + drest, take) % mod;
                        add(dp1[d][ne][rest + drest - take],
                            dp2[d - 1][e][rest] * coeff % mod);
                    }
                    if (drest == 0) continue;
                    for (int take = 0; take <= rest + drest - 1; take += 1) {
                        ll coeff = drest * f[cnt[ne][d - 1] + take] % mod;
                        coeff = coeff * cnk(rest + drest - 1, take) % mod;
                        add(dp1[d][ne][rest + drest - 1 - take],
                            dp2[d - 1][e][rest] * coeff % mod);
                    }
                }
                int can_take = cnt[e][d];
                assert(can_take > 0);
                for (int take = 1; take <= can_take; take += 1) {
                    ll coeff = can_take * f[rest + take - 1] % mod;
                    coeff = coeff * cnk(can_take - 1, take - 1) % mod;
                    add(dp1[d][e ^ 1][can_take - take],
                        dp2[d - 1][e][rest] * coeff % mod);
                }
            }
        }
        rep(e, 2 * n - 2) {
            auto [u, v] = edges[e];
            if (cnt[e][d] == 0 or cnt[e ^ 1][d] == 0) continue;
            rep(rest, cnt[e ^ 1][d]) {
                for (int take = 0; take <= rest; take += 1) {
                    ll coeff = cnt[e][d] * f[cnt[e][d] - 1 + take] % mod;
                    coeff = coeff * cnk(rest, take) % mod;
                    add(dp2[d][e][rest - take],
                        dp1[d][e][rest] * coeff % mod);
                }
                for (int take = 1; take <= cnt[e][d]; take += 1) {
                    ll coeff = cnt[e][d] * f[take - 1 + rest] % mod;
                    coeff = coeff * cnk(cnt[e][d] - 1, take - 1) % mod;
                    add(dp2[d][e ^ 1][cnt[e][d] - take],
                        dp1[d][e][rest] * coeff % mod);
                }
            }
        }
    }
    int result = 0;
    if (diam % 2 == 1) {
        int ce = -1;
        rep(e, 2 * n - 2) {
            auto [u, v] = edges[e];
            if (dists[du][u] + 1 != dists[du][v]) continue;
            if (dists[u][dv] != dists[v][dv] + 1) continue;
            if (dists[u][du] != diam / 2) continue;
            if (dists[v][dv] != diam / 2) continue;
            ce = e;
            break;
        }
        assert(ce != -1);
        int d = diam / 2;
        for (auto e : { ce, ce ^ 1 }) {
            rep(rest, cnt[e ^ 1][d]) {
                ll coeff = cnt[e][d] * f[cnt[e][d] - 1 + rest] % mod;
                add(result, dp1[d][e][rest] * coeff % mod);
            }
        }
    } else {
        int cv = -1;
        rep(v, n) {
            if (dists[v][du] != diam / 2) continue;
            if (dists[v][dv] != diam / 2) continue;
            cv = v;
            break;
        }
        assert(cv != -1);
        int d = diam / 2 - 1;
        for (auto [_, xe] : g[cv]) {
            int e = xe ^ 1;
            rep(rest, cnt[e ^ 1][d]) {
                if (cnt[e][d + 1] == 0) continue;
                ll coeff = cnt[e][d + 1] * f[cnt[e][d + 1] - 1 + rest] % mod;
                add(result, dp2[d][e][rest] * coeff % mod);
            }
        }
    }
    return result;
}


int32_t main() {
    // cerr << (sizeof(dp1) + sizeof(dp2)) / 1e6 << "\n";
    if (1) {
        ios::sync_with_stdio(0);
        cin.tie(0);
        cout.tie(0);
    }
    cin >> n;
    g.assign(n, vector<edge>());
    edges.resize(2 * n - 2);
    rep(i, n - 1) {
        int u, v;
        cin >> u >> v;
        --u;
        --v;
        edges[2 * i] = { u, v };
        edges[2 * i + 1] = { v, u };
        g[u].push_back(edge{ v, 2 * i });
        g[v].push_back(edge{ u, 2 * i + 1 });
    }
    ll result = solve();
    cout << result << "\n";
    return 0;
}