#pragma GCC optimize("Ofast")
#include <bits/stdc++.h>
using namespace std;

#define ff               first
#define ss               second
#define pb               push_back
#define all(x)           (x).begin(), (x).end()
#define mem0(x)          memset(x, 0, sizeof (x))
#define mem1(x)          memset(x, -1, sizeof (x))

typedef long long ll;
#define int ll
typedef vector <int> vi;
typedef vector<vi> vvi;
typedef pair<int, int> ii;
typedef vector <ii> vii;
typedef vector<vii> vvii;

const int MOD = 1e9+7;
vvi g;

ll bin_exp(int a, int b){
    long long ans = 1, pa = a % MOD;
    while (b){
        if (b & 1) ans = ans*pa%MOD; 
        pa = pa*pa%MOD; b /= 2;
    }
    return ans%MOD;
}

int inv(int u){
    return bin_exp(u, MOD-2);
}

int memo[220][220];

int dp(int u, int v){ // prob de sacar u antes que v
    if (!u) return 1;
    if (!v) return 0;
    if (~memo[u][v]) return memo[u][v];
    int ans = 0;
    ans += inv(2)*dp(u-1,v)%MOD;
    ans += inv(2)*dp(u,v-1)%MOD;
    return memo[u][v] = ans%MOD;
}

int H[220];

#define MAXN 220
#define MAXLOG 11
int h[MAXN];
int anc[MAXN][MAXLOG]; //ancestor[V][ceil(log2(V))] inicializado en -1
int val[MAXN][MAXLOG]; //value, max value in this example

void dfs_preprocess(int u, int p = -1){ //se llama desde la raiz
    anc[u][0] = p;
    if (~p) {
        h[u] = h[p] + 1;
        //val[u][0] = value(u, p); //calcular valor inicial
    }
    for (int i = 1; i < MAXLOG; ++i) {
        if (~anc[u][i - 1]) {
            anc[u][i] = anc[anc[u][i - 1]][i - 1];
            //val[u][i] = max(val[anc[u][i-1]][i-1], val[u][i-1]);
        }
    }
    for (auto v: g[u]){
        if (v != p) dfs_preprocess(v, u);
    }
}

int LCA(int v, int u){
    if (h[v] < h[u]) swap(u, v);
    for (int i = MAXLOG-1; i >= 0; --i) {
        if (anc[v][i] + 1 && h[anc[v][i]] >= h[u]) {
            //val_ans = max(val_ans, val[v][i]);
            v = anc[v][i];
        }
    }
    if (v == u) return v;
    //return val_ans;
    for (int i = MAXLOG-1; i >= 0; --i) {
        if (anc[v][i] != anc[u][i]) {
            //val_ans = max({val_ans, val[v][i], val[u][i]});
            v = anc[v][i];
            u = anc[u][i];
        }
    }
    //val_ans = max({val_ans, val[v][0], val[u][0]});
    //return val_ans;
    return anc[v][0];
}

int32_t main(){
    ios::sync_with_stdio(false);
    cin.tie(0);
    mem1(memo);
    int T=1, n;
    while (T--){
        cin >> n;
        g.clear();
        g.assign(n, vi());
        for (int i = 0; i < n-1; ++i) {
            int u, v; cin >> u >> v;
            u--, v--;
            g[u].pb(v);
            g[v].pb(u);
        }
        int ans = 0;
        for (int i = 0; i < n; ++i) {
            h[i] = 0;
            mem1(anc);
            dfs_preprocess(i);
            for (int u = 0; u < n; ++u) {
                for (int v = u+1; v < n; ++v) { //u < v
                    int lca = LCA(u, v);
                    int hlca = h[lca];
                    int hu = h[u] - hlca;
                    int hv = h[v] - hlca;
                    ans += dp(hv, hu);
                    ans %= MOD;

                }
            }
        }
        cout << ans*inv(n)%MOD << "\n";
    }
}