#pragma GCC optimize("Ofast")
#pragma GCC target("avx,avx2,fma")
#pragma GCC optimization ("unroll-loops")
#include <iostream>
#include <fstream>
#include <algorithm>
#include <vector>
#include <set>
#include <stack>
#include <map>
#include <unordered_map>
#include <iomanip>
#include <cmath>
#include <queue>
#include <bitset>
#include <numeric>
#include <array>
#include <cstring>
#include <random>
#include <chrono>
#define fi first
#define se second
#define pb push_back
#define mp make_pair
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define make_unique(x) sort(all((x))); (x).resize(unique(all((x))) - (x).begin())
typedef long long ll;
typedef long double ld;
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
// #include <ext/pb_ds/assoc_container.hpp>
// #include <ext/pb_ds/tree_policy.hpp>
// using namespace __gnu_pbds;
// template<class T>
// using ordered_set = tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
const int N = 203, K = 8;
const ll m = 1e9 + 7;
ll add(ll x, ll y) {
  x = (1ll * x + m + y) % m;
  return x;
}
ll mul(ll x, ll y) {
  ll ans = (x * 1ll * y) % m;
  while(ans < 0) ans += m;
  return ans;
}
ll binpow(ll x, ll y) {
  ll z = 1;
  while(y) {
    if(y & 1) z = mul(z, x);
    x = mul(x, x);
    y >>= 1;
  }
  return z;
}
ll inv(ll x) {
  return binpow(x, m - 2);
}
ll divide(ll x, ll y) {
  return mul(x, inv(y));
}
vector<int> g[N];
ll prob[N][N];
int n;
int tin[N], tout[N], timer;
int dep[N];
int up[N][K + 1];
ll ans = 0;
void dfs(int v, int p) {
  tin[v] = timer++;
  up[v][0] = p;
  for(int j = 1; j <= K; j++)
    up[v][j] = up[up[v][j - 1]][j - 1];
  for(auto& x : g[v])
    if(x != p) {
      dep[x] = dep[v] + 1;
      dfs(x, v);
    }
  tout[v] = timer++;
}
char isanc(int a, int b) {
  return (tin[a] <= tin[b] && tout[a] >= tout[b]);
}
int lca(int a, int b) {
  if(isanc(a, b)) return a;
  if(isanc(b, a)) return b;
  for(int i = K; i >= 0; i--)
    if(!isanc(up[a][i], b))
      a = up[a][i];
  return up[a][0];
}
int dp(int a, int b) {
  if(a == 0) return 0;
  if(b == 0) return 1;
  if(prob[a][b] != -1) return prob[a][b];
  prob[a][b] = divide(add(dp(a - 1, b), dp(a, b - 1)), 2);
  return prob[a][b];
}
int main() {

  ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);

  for(int i = 0; i < N; i++)
    for(int j = 0; j < N; j++)
      prob[i][j] = -1;

  cin >> n;

  for(int i = 1; i < n; i++) {
    int a, b; cin >> a >> b;
    g[a].pb(b);
    g[b].pb(a);
  }

  for(int i = 1; i <= n; i++) {
    for(int j = 0; j <= n; j++)
      for(int k = 0; k <= K; k++)
        up[j][k] = 0;
    timer = 0;
    dep[i] = 0;
    dfs(i, i);
    for(int a = 1; a <= n; a++)
      for(int b = a + 1; b <= n; b++) {
        int clca = lca(a, b);
        int da = dep[a] - dep[clca], db = dep[b] - dep[clca];
        ans = add(ans, dp(da, db));
      }
  }

  cout << divide(ans, n);

  return 0;
}
/*

*/
