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

const int mod = 1e9 + 7;

// Based on code of tourist
class Mint {
  private:
    int value;
  public:
    constexpr Mint() : value() {}
    template <typename T>
    Mint(const T& x) {
        value = (-mod <= x && x < mod) ? x : x % mod;
        if (value < 0) value += mod;
    }
    template <typename U>
    explicit operator U() const { return static_cast<U>(value); }

    Mint& operator += (const Mint& a) { if ((value += a.value) >= mod) value -= mod; return *this; }
    Mint& operator -= (const Mint& a) { if ((value -= a.value) < 0) value += mod; return *this; }
    Mint& operator ++ () { return *this += 1; }
    Mint& operator -- () { return *this -= 1; }
    Mint operator ++ (int) { Mint result(*this); *this += 1; return result; }
    Mint operator -- (int) { Mint result(*this); *this -= 1; return result; }
    Mint operator - () const { return Mint(-value); }
    Mint& operator *= (const Mint& a) { value = (long long) value * a.value % mod; return *this; }
    Mint& operator /= (const Mint& a) { assert(a.value != 0); return *this *= inverse(a); }
    friend Mint pow(Mint a, int b) {
        Mint r = 1;
        for (; b; a *= a, b >>= 1) {
            if (b & 1) r *= a;
        }
        return r;
    }
    static Mint inverse(const Mint& a) {
        return pow(a, mod - 2);
    }
    friend bool operator == (const Mint& a, const Mint& b) { return a.value == b.value; }
    friend bool operator != (const Mint& a, const Mint& b) { return a.value != b.value; }
    friend bool operator < (const Mint& a, const Mint& b) { return a.value < b.value; }
    friend Mint operator + (const Mint& a, const Mint& b) { return Mint(a) += b; }
    friend Mint operator - (const Mint& a, const Mint& b) { return Mint(a) -= b; }
    friend Mint operator * (const Mint& a, const Mint& b) { return Mint(a) *= b; }
    friend Mint operator / (const Mint& a, const Mint& b) { return Mint(a) /= b; }
    friend ostream& operator << (ostream& stream, const Mint& a) {
        return stream << a.value;
    }
    friend istream& operator >> (istream& stream, Mint& a) {
        return stream >> a.value;
    }
    friend string to_string(const Mint& a) {
        return to_string(a.value);
    }
};

// Based on tourist's code
class tree {
  public:
    int n;
    vector<vector<int>> g;
    vector<int> pv;
    vector<int> depth;
    vector<int> sz;
    vector<int> order;
    vector<int> pos;
    vector<int> end;
    int root;
    // lca
    int h;
    vector<vector<int>> anc;

    tree(int _n) : n(_n) {
        g.resize(n);
        root = -1;
    }

    void add(int from, int to) {
        assert(0 <= from && from < n && 0 <= to && to < n);
        g[from].push_back(to);
        g[to].push_back(from);
    }

    void init() {
        pv = vector<int>(n, -1);
        depth = vector<int>(n, -1);
        sz = vector<int>(n);
        order.clear();
        pos = vector<int>(n, -1);
        end = vector<int>(n, -1);
    }

    void dfs_from(int v) {
        init();
        root = v;
        pv[v] = -1;
        depth[v] = 0;
        dfs(v);
    }
    
    bool is_anc(int a, int b) {
        return pos[a] <= pos[b] && end[b] <= end[a];
    }

    void prec_kth_anc() {
        assert(!pv.empty());
        int max_depth = 0;
        for (int i = 0; i < n; i++) {
            max_depth = max(max_depth, depth[i]);
        }
        for (h = 1; (1 << h) <= max_depth; h++);
        anc.resize(n);
        for (int i = 0; i < n; i++) {
            anc[i].resize(h);
            anc[i][0] = pv[i];
        }
        for (int j = 1; j < h; j++) {
            for (int i = 0; i < n; i++) {
                anc[i][j] = (anc[i][j - 1] == -1 ? -1 : anc[anc[i][j - 1]][j - 1]);
            }
        }
    }

    int go_up(int v, int up) {
        assert(!anc.empty());
        up = min(up, (1 << h) - 1);
        for (int j = h - 1; j >= 0; j--) {
            if (up & (1 << j)) {
                v = anc[v][j];
                if (v == -1) {
                    break;
                }
            }
        }
        return v;
    }

    int lca(int a, int b) {
        if (depth[a] < depth[b]) {
            swap(a, b);
        }
        a = go_up(a, depth[a] - depth[b]);
        if (a == b) return a;
        for (int i = h - 1; i >= 0; i--) {
            if (anc[a][i] != anc[b][i]) {
                a = anc[a][i];
                b = anc[b][i];
            }
        }
        return anc[a][0]; 
    }

  private:
    void dfs(int v) {
        pos[v] = order.size();
        order.push_back(v);
        sz[v] = 1;
        for (int u : g[v]) {
            if (u == pv[v]) {
                continue;
            }
            pv[u] = v;
            depth[u] = depth[v] + 1;
            dfs(u);
            sz[v] += sz[u];
        }
        end[v] = order.size() - 1;
    }
};

vector<vector<Mint>> dp;

void foo() {
    int n;
    cin >> n;
    tree g(n);
    for (int i = 0; i < n - 1; i++) {
        int x, y;
        cin >> x >> y;
        x--; y--;
        g.add(x, y);
    }
    
    Mint ans = 0;
    for (int root = 0; root < n; root++) {
        g.dfs_from(root);
        g.prec_kth_anc();
        
        for (int i = 0; i < n; i++) {
            for (int j = i + 1; j < n; j++) {
                int L = g.lca(i, j);
                int dl = g.depth[L];
                Mint prob = dp[g.depth[j] - dl][g.depth[i] - dl];
                ans += prob;
            }
        }
    }
    
    ans /= n;
    
    cout << ans << endl;
}

const int NAX = 205;

int main() {
    ios::sync_with_stdio(0);
    cin.tie(0);
    
    dp = vector<vector<Mint>>(NAX, vector<Mint>(NAX));
    dp[0] = vector<Mint>(NAX, 1);
    for (int i = 1; i < NAX; i++) {
        for (int j = 1; j < NAX; j++) {
            dp[i][j] += Mint(1) / 2 * dp[i - 1][j];
            dp[i][j] += Mint(1) / 2 * dp[i][j - 1];
        }
    }
    
    foo();
}
