﻿#include <iostream>
#include <vector>
#include <set>
#include <map>
#include <algorithm>
#include <cassert>
#include <iomanip>

using namespace std;

typedef long long ll;
typedef long double ld;

#define int ll
#define mp make_pair
#define pb push_back
#define pi pair<int, int>
#define vi vector<int>
#define vpi vector<pi>
#define vvpi vector<vpi>
#define vs vector<string>
#define ff first
#define ss second
#define vvi vector<vi>
#define len(v) int(v.size())
#define all(v) v.begin(), v.end()
#define in_rng(i, n) i >= n ? i - n : ((i >= 0) ? i : i + n)


ll bin_pow(ll base, ll deg, ll md) {
    if (!deg)
        return 1;
    if (deg % 2)
        return base * bin_pow(base, deg - 1, md) % md;
    ll res = bin_pow(base, deg / 2, md);
    return res * res % md;
}

//const int max_a = 3e5 + 7;
template <typename T1, typename T2>
bool cmin(T1& a, const T2& b) {
    if (a <= b)
        return false;
    a = b;
    return true;
}

template <typename T1, typename T2>
bool cmax(T1& a, const T2& b) {
    if (a >= b)
        return false;
    a = b;
    return true;
}

int get_rand_int(int mn, int mx) {
    return rand() % (mx - mn + 1) + mn;
}


const int md = 1e9 + 7;

int inv(int a) {
    return bin_pow(a, md - 2, md);
}

int gcd(int a, int b) {
    if (!b)
        return a;
    return gcd(b, a % b);
}

int get_bit(int m, int index) {
    return (bool)(m >> index) & 1;
}

const int max_n = 200 + 13;

int n;
vvi g;

int us = 0;
int used[max_n] = { 0 };
int parent[max_n] = { 0 };
int line_used[max_n] = { 0 };

void dfs(int v) {
    used[v] = us;
    for (auto u : g[v]) {
        if (used[u] == us)
            continue;
        parent[u] = v;
        dfs(u);
    }
}

int get_tree_cnt(int v, int p) {
    int result = 1;
    for (auto u : g[v]) {
        if (u == p)
            continue;
        if (line_used[u] == us)
            continue;
        result += get_tree_cnt(u, v);
    }
    return result;
}

int p_chance[max_n][max_n] = { 0 };

void run() {
    cin >> n;
    g.resize(n);
    for (int i = 0; i < n - 1; ++i) {
        int x, y;
        cin >> x >> y;
        --x, --y;
        g[x].push_back(y);
        g[y].push_back(x);
    }
    int div_n = inv(n);
    int div_2 = inv(2);
    for (int i = 0; i < max_n; ++i) {
        p_chance[0][i] = 1;
        p_chance[i][0] = 0;
    }
    for (int i = 1; i < max_n; ++i) {
        for (int j = 1; j < max_n; ++j) {
            p_chance[i][j] = div_2 * p_chance[i - 1][j] % md + div_2 * p_chance[i][j - 1] % md;
            p_chance[i][j] %= md;
        }
    }
    

    int result = 0;
    for (int i = 0; i < n; ++i) {
        // j < i;
        
        for (int j = 0; j < i; ++j) {
            int inv_chance = 0;

            ++us;
            parent[i] = -1;
            dfs(i);
            
            int full_dist = 0;
            int v = j;
            while (v != -1) {
                ++full_dist;
                line_used[v] = us;
                v = parent[v];
            }

            int dist_from_j = 0;
            v = j;
            while (v != -1) {
                int tree_cnt = get_tree_cnt(v, -1);
                inv_chance += tree_cnt * p_chance[full_dist - dist_from_j - 1][dist_from_j] % md;
                inv_chance %= md;

                ++dist_from_j;
                v = parent[v];
            }
            result += inv_chance;
            result %= md;
        }
    }
    cout << result * div_n % md << '\n';
}



signed main() {
    cin.tie(0);
    cout.tie(0);
    ios_base::sync_with_stdio(0);
    /*
    freopen("input.txt", "r", stdin);
    freopen("output.txt", "w", stdout);
    //*/
    //cout << fixed << setprecision(12);
    size_t t = 1;
    //std::cin >> t;
    for (size_t i = 0; i < t; ++i) {
        //arr.clear();
        
        run();
    }
    int tmp;
    //std::cin >> tmp;
}