#include <algorithm>
#include <iostream>
#include <numeric>
#include <cstdlib>
#include <cassert>
#include <cstring>
#include <iomanip>
#include <cstdio>
#include <limits>
#include <string>
#include <vector>
#include <cmath>
#include <deque>
#include <queue>
#include <stack>
#include <map>
#include <set>
using namespace std;

typedef long long LL;
typedef long long ll;
typedef long double LD;
typedef vector<int> vi;
typedef pair<LL, LL> PLL;
typedef pair<LL, int> PLI;
typedef pair<int, int> PII;
typedef pair<int, int> pii;
typedef vector<vector<LL>> VVL;

#define rep(i, a, b) for(int i = a; i < (b); ++i)
#define trav(a, x) for(auto& a : x)
#define all(x) begin(x), end(x)
#define sz(x) (int)(x).size()
#define popf pop_front
#define pf push_front
#define popb pop_back
#define mp make_pair
#define pb push_back
#define remove erase
#define fi first
#define se second

// If the time limit is strict, try not to use long double

// Remember to undefine if the problem is interactive
#define endl '\n'
#define DEBUG(X) cout << ">>> DEBUG(" << __LINE__ << ") " << #X << " = " << (X) << endl

const double EPS = 1e-9;
const int INFMEM = 63;
const int INF = 1061109567;
const LL LINF = 4557430888798830399LL;
const double DINF = numeric_limits<double>::infinity();
const int dx[8] = {0, 0, 1, -1, 1, -1, 1, -1};
const int dy[8] = {1, -1, 0, 0, 1, -1, -1, 1};
// Do dir^1 to get reverse direction
const char dch[4] = {'R', 'L', 'D', 'U'};
// const string ds[8] = {"E","W","S","N","SE","NW","SW","NE"};
const double PI = 3.141592653589793;

inline void open(string a) {
  freopen((a + ".in").c_str(), "r", stdin);
  freopen((a + ".out").c_str(), "w", stdout);
}

inline void fasterios() {
  // Do not use if interactive
  ios_base::sync_with_stdio(0);
  cin.tie(0); cout.tie(0);
  // cout << fixed << setprecision(10);
}

template<int MOD>
class ModInt {
 public:
  int v;

  ModInt() : v(0) {}
  ModInt(long long _v) {
    v = int((-MOD < _v && _v < MOD) ? (_v) : (_v % MOD));
    if (v < 0) v += MOD;
  }

  friend bool operator==(const ModInt &a, const ModInt &b) { return a.v == b.v; }
  friend bool operator!=(const ModInt &a, const ModInt &b) { return a.v != b.v; }
  friend bool operator<(const ModInt &a, const ModInt &b) { return a.v < b.v; }
  friend bool operator<=(const ModInt &a, const ModInt &b) { return a.v <= b.v; }
  friend bool operator>(const ModInt &a, const ModInt &b) { return a.v > b.v; }
  friend bool operator>=(const ModInt &a, const ModInt &b) { return a.v >= b.v; }

  ModInt& operator+=(const ModInt &a) {
    if ((v += a.v) >= MOD) v -= MOD;
    return *this;
  }
  ModInt& operator-=(const ModInt &a) {
    if ((v -= a.v) < 0) v += MOD;
    return *this;
  }
  ModInt& operator*=(const ModInt &a) {
    v = 1ll * v * a.v % MOD;
    return *this;
  }
  ModInt& operator/=(const ModInt &a) {
    return (*this) *= inverse(a);
  }

  friend ModInt pow(ModInt a, long long x) {
    ModInt res = 1; assert(x >= 0);
    for (; x; x /= 2, a *= a) if (x & 1) res *= a;
    return res;
  }
  friend ModInt inverse(ModInt a) {
    assert(a.v != 0);
    return pow(a, MOD - 2);
  }

  ModInt operator+() const { return ModInt(v); }
  ModInt operator-() const { return ModInt(-v); }
  ModInt operator++() const { return *this += 1; }
  ModInt operator--() const { return *this -= 1; }

  friend ModInt operator+(ModInt a, const ModInt &b) { return a += b; }
  friend ModInt operator-(ModInt a, const ModInt &b) { return a -= b; }
  friend ModInt operator*(ModInt a, const ModInt &b) { return a *= b; }
  friend ModInt operator/(ModInt a, const ModInt &b) { return a /= b; }

  friend istream& operator>>(istream &is, ModInt &v) { is >> v.v; return is; }
  friend ostream& operator<<(ostream &os, const ModInt &v) { os << v.v; return os; }
};

const int MOD = 1000000007;
using Mint = ModInt<MOD>;

const int mxsz = 2e5 + 10;
const int MX = 2e5 + 1;
LL fact[mxsz], inv[mxsz], finv[mxsz];
LL sumComb[205][205];


inline LL perm(LL a, LL b) {
  return (fact[a] * finv[a - b]) % MOD;
}

inline LL comb(LL a, LL b) {
  if (a < b) return 0;
  return (perm(a, b) * finv[b]) % MOD;
}


inline void prec(LL mod = MOD) { // factorial / inverse
  fact[0] = inv[0] = finv[0] = 1;
  fact[1] = inv[1] = finv[1] = 1;
  for (int i = 2; i <= MX; i++) {
    fact[i] = (fact[i - 1] * i) % mod;
    inv[i] = mod - (mod / i) * inv[mod % i] % mod;
    finv[i] = (finv[i - 1] * inv[i]) % mod;
  }
  for(int i = 0;i <= 200;i++){
    sumComb[i][0] = 1;
    for(int j = 1;j <= i;j++){
      sumComb[i][j] = (comb(i, j) + sumComb[i][j - 1])%MOD;
    }
  }
}
LL n;

const LL logN = 10;
const LL maxN = 215;
LL depth[maxN];
vector <LL> edge[maxN];
LL sparset[maxN][logN + 3];
LL precTwoInv[maxN];

void dfs(LL pos, LL par) {
  for (int i = 0; i < edge[pos].size(); i++) {
    LL nx = edge[pos][i];
    if (par == nx) continue;
    depth[nx] = depth[pos] + 1;
    sparset[nx][0] = pos;
    dfs(nx, pos);
  }
  return;
}

LL lca(LL a, LL b) {
  if (depth[a] > depth[b]) swap(a, b);
  for (int i = logN; i >= 0; i--) {
    if (depth[b] - (1LL << i) < depth[a]) continue;
    b = sparset[b][i];
  }
  if (a == b) return a;
  for (int i = logN; i >= 0; i--) {
    if (sparset[a][i] == sparset[b][i]) continue;
    a = sparset[a][i];
    b = sparset[b][i];
  }
  return sparset[a][0];
}

LL expo(LL a, LL b, LL MODULO = MOD) {
  LL ret = 1;
  while (b > 0) {
    if (b & 1) ret = (ret * a) % MODULO;
    a = (a * a) % MODULO; b >>= 1;
  }
  return ret;
}

Mint solve(LL pos) {
  memset(sparset, -1, sizeof(sparset));
  dfs(pos, -1);
  for (int i = 0; i < logN; i++) {
    for (int j = 1; j <= n; j++) {
      if (sparset[j][i] == -1) continue;
      sparset[j][i + 1] = sparset[sparset[j][i]][i];
    }
  }
  // cout << pos << endl;
  Mint ans = 0;
  // When pos is the head count all pairs i, j
  for (int i = 1; i <= n; i++) {
    for (int j = i + 1; j <= n; j++) {
      int curlca = lca(i, j);
      int depthA = depth[j] - depth[curlca];
      int depthB = depth[i] - depth[curlca];
      if(depthB == 0) continue;
      int total = depthA + depthB - 1;
      Mint curans = sumComb[total][depthB - 1];
      curans *= precTwoInv[total];
      // cout << "Computing " << i << " " << j << endl;
      // cout << curlca << " " << depthA << " " << depthB << " " << total << endl;
      // Possibility of A gets emptied first is sum of the first binoms
      // for (int l = 0; l < depthB; l++) {
        // cout << "Here " << comb(total, l) << endl;
        // curans += comb(total, l);
      // }
      ans += curans;
    }
  }
  // cout << "Current " << ans << endl;
  return ans;
}

int main() {
  fasterios();
  prec();
  precTwoInv[0] = 1;
  precTwoInv[1] = expo(2, MOD - 2);
  for(int i = 2;i <= 200;i++){
    precTwoInv[i] = precTwoInv[i - 1] * precTwoInv[1] % MOD;
  }
  cin >> n;
  for (int i = 1; i < n; i++) {
    int u, v; cin >> u >> v;
    edge[u].pb(v);
    edge[v].pb(u);
  }

  Mint ans = 0;

  for (int i = 1; i <= n; i++) {
    ans += solve(i);
  }
  // cout << ans << endl;
  cout << ans/n << endl;
}