#include <bits/stdc++.h>
using namespace std;

typedef long long int ll;
typedef pair<ll, ll> pll;

#define FOR(i, n, m) for (ll(i) = (m); (i) < (n); ++(i))
#define REP(i, n) FOR(i, n, 0)
#define OF64 std::setprecision(10)

const ll MOD = 1000000007;
const ll INF = (ll)1e15;

struct Combination
{
    void init(ll n)
    {
        mNumTbl.resize(n + 1);
        mInverseNumTbl.resize(n + 1);
        mNumTbl[0] = 1;
        mInverseNumTbl[0] = 1;
        FOR(i, n + 1, 1)
        {
            mNumTbl[i] = (mNumTbl[i - 1] * i) % MOD;
        }
        FOR(i, n + 1, 1)
        {
            mInverseNumTbl[i] = modpow(mNumTbl[i]);
        }
    }

    ll get(ll n, ll r)
    {
        if (n < r || n < 0)
            return 0;
        return (((mNumTbl[n] * mInverseNumTbl[r]) % MOD) * mInverseNumTbl[n - r]) % MOD;
    }

    //! バイナリ方で累乗を計算
    ll modpow(ll n)
    {
        ll s = 1, p = n;
        for (ll i = 0; (1 << i) <= MOD - 2; ++i, p = (p * p) % MOD)
        {
            if (((MOD - 2) & (1 << i)) == 0)
                continue;
            s *= p;
            s %= MOD;
        }
        return s;
    }

    vector<ll> mInverseNumTbl;
    vector<ll> mNumTbl;
};

struct Vertex
{
    vector<int> n;
    ll depth = INF;
};

Vertex V[200005];
ll dp[200005];
ll N;
Combination cmb;

ll get(int n)
{
    int d = V[n].depth;
    ll c = 0;
    FOR(i, N + 1, 1)
    {
        c += cmb.get(i - 1, d);
        c %= MOD;
    }
    return (((dp[d] * c) % MOD) * dp[N - 1 - d]) % MOD;
}

int main()
{
    cin >> N;
    REP(i, N - 1)
    {
        int a, b;
        cin >> a >> b;
        a--;
        b--;
        V[a].n.push_back(b);
        V[b].n.push_back(a);
    }

    queue<pll> q;
    q.push(pll(0, 0));
    while (!q.empty())
    {
        pll t = q.front();
        q.pop();
        V[t.first].depth = t.second;
        int nd = t.second + 1;
        REP(i, V[t.first].n.size())
        {
            int n = V[t.first].n[i];
            if (nd >= V[n].depth)
                continue;
            q.push(pll(n, nd));
        }
    }
    ll t = 1;
    memset(dp, 0, sizeof(dp));
    cmb.init(N + 1);
    FOR(i, N + 1, 1)
    {
        t = (t * i) % MOD;
        dp[i] = t;
    }
    dp[0] = 1;

    // for (int i = N - 1; i >= 0; --i)
    // {
    //     dp[i] += dp[i + 1];
    //     dp[i] %= MOD;
    // }
    // dp[0] = (t * N) % MOD;
    ll ans = 0;
    REP(i, N)
    {
        ans += get(i); //dp[V[i].depth];
        ans %= MOD;
    }
    cout << ans << endl;
    return 0;
}