/*    Author - Satwik_Tiwari  */

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

#define sim template < class c
#define ris return * this
#define dor > debug & operator <<
#define eni(x) sim > typename \
  enable_if<sizeof dud<c>(0) x 1, debug&>::type operator<<(c i) {
sim > struct rge { c b, e; };
sim > rge<c> range(c i, c j) { return rge<c>{i, j}; }
sim > auto dud(c* x) -> decltype(cerr << *x, 0);
sim > char dud(...);
struct debug {
#ifndef ONLINE_JUDGE
    ~debug() { cerr << endl; }
    eni(!=) cerr << boolalpha << i; ris; }
    eni(==) ris << range(begin(i), end(i)); }
    sim, class b dor(pair < b, c > d) {
        ris << "(" << d.first << ", " << d.second << ")";
    }
    sim dor(rge<c> d) {
        *this << "[";
        for (auto it = d.b; it != d.e; ++it)
            *this << ", " + 2 * (it == d.b) << *it;
        ris << "]";
    }
#else
    sim dor(const c&) { ris; }
#endif
};
#define print(...) " [" << #__VA_ARGS__ ": " << (__VA_ARGS__) << "] "

#define int long long
#define FastIO ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0)
#define ff first
#define ss second
#define all(x) (x).begin(),(x).end()
#define minheap priority_queue <int, vector<int>, greater<>>
#define endl "\n"
#define google cout << "Case #" << casee << ": " ;

int power(int x, int y, int M) {int res = 1; while (y > 0) {if (y & 1) res = (res * x) % M; y >>= 1; x = (x * x) % M;} return res % M;}
int power(int x, int y) {int res = 1; while (y > 0) {if (y & 1) res = (res * x); y >>= 1; x = (x * x);} return res;}
const int mxn = 201, mod = 1e9+7, inf = 1e18 ; int t,casee = 1;


int dp[mxn][mxn];
int n;
vector<vector<int>> g(mxn,vector<int>());

// LCA - Lowest Common Ancestor.
// Author - Satwik_Tiwari
// whole graph is 0 indexed and queries as well.
// graph is global.

//Range Queries.
// Author - Satwik_Tiwari
template<typename T>
class RangeQuery{
private:
    vector<vector<T>> data;
public:
    void precal(vector<T> &arr){ // make sure not to pass a global vector of size = mxn.
        vector<int> temp; int n = arr.size();
        for(int i=0;i<n;i++){
            temp.push_back(arr[i]);
        }
        data.push_back(temp);
        int i = 1;
        while(2*i <= n){
            vector<int> prev = data[data.size()-1];
            vector<int> put;
            for(int j=0;j<n-2*i+1;j++){
                put.push_back(func(prev[j],prev[j + i]));
            }
            data.push_back(put);
            i <<= 1;
        }
    }

    T func(T aa, T ab){ // change it according to you.
        return min(aa,ab);
    }

    T query(int st,int end){ // ask queries like query[st,end].
        int bits; end++; int x = end - st;
        for(bits = 0;x != 0; ++ bits) x >>= 1; bits--;
        return (func(data[bits][st],data[bits][end - (1 << bits)]));
    }

    T getitem(int idx){
        return (data[0][idx]);
    }
};

template<typename T>
class LCA {
private:
    vector<int> time;
    vector<int> path;
    RangeQuery<int> rmq;
public:
    LCA(int root, int n) {
        vector<int> P;
        for (int i = 0; i < n; i++) {
            time.push_back(-1); path.push_back(-1); P.push_back(-1);
        }
        int tt = -1; vector<int> dfs; dfs.push_back(root);
        while (!dfs.empty()) {
            int node = dfs.back(); dfs.pop_back();
            path[tt == -1 ? n - 1 : tt] = P[node];
            time[node] = ++tt;
            for (int nie : g[node]) {
                if (time[nie] == -1) {
                    P[nie] = node;
                    dfs.push_back(nie);
                }
            }
        }
        vector<int> aa;
        for (int i : path) aa.push_back(time[i == -1 ? n - 1 : i]);
        rmq.precal(aa);
    }

    int query(int a, int b) {
        if (a == b) return a;
        a = time[a]; b = time[b];
        if (a > b) swap(a, b);
        return path[rmq.query(a, b - 1)];
    }
};

int rec(int i, int j){
    if(i == 0) return 1;
    if(j == 0) return 0;
    if(dp[i][j] != -1) return dp[i][j];
    return dp[i][j] = ((rec(i-1,j) + rec(i,j-1))*power(2,mod-2,mod))%mod;
}

int dist[mxn][mxn];

void dfs(int root, int st, int par, int h = 0){
    dist[root][st] = h;
    for(int to: g[st]){
        if(to == par) continue;
        dfs(root,to,st,h + 1);
    }
}

void test_case() {
    for(int i=0;i<mxn;i++){
        for(int j=0;j<mxn;j++){
            dp[i][j] = -1;
        }
    }

    cin >> n;
    for(int i=0;i<n-1;i++){
        int u,v; cin >> u >> v; u--; v--;
        g[u].push_back(v);
        g[v].push_back(u);
    }

    for(int i=0;i<n;i++){
        dfs(i,i,-1);
    }

    int ans = 0;
    for(int i=0;i<n;i++){
        for(int j=i+1;j<n;j++){
            // find probability of j occuring before i.
            // will create 1 inversion.
            int curr = 0;
            LCA<int> lca(j,n);

            // part of subtree of j and not in path of i to j.
            for(int k=0;k<n;k++){
                if(lca.query(k,i) == j) curr ++, curr%=mod;
            }

            // in path from i to j.
            for(int k=0;k<n;k++){
                int ances = lca.query(k,i);
                if(ances != i and ances != j){
                    curr += rec(dist[j][ances], dist[i][ances]);
                    curr %= mod;
                }
            }

            ans += (curr * power(n,mod-2,mod))%mod;
            ans %= mod;
        }
    }

    cout << ans << endl;
}

int32_t main() {
    FastIO;
    t = 1;
//    cin >> t;
    while (t--) {
        test_case();
        casee++;
    }
    return 0;
}

