#include <bits/stdc++.h>

using namespace std;

#define MAXN 200 + 10
#define BASE 1000000007

int n;
int Dp[MAXN][MAXN];
vector<int> neighbors[MAXN];
int pa[MAXN][10], in[MAXN], out[MAXN], level[MAXN];
int countIn, countOut;

int getPow(int x, int y) {
  int res = 1;
  while (y > 0) {
    if (y & 1) {
      res = ((long long)res * x) % BASE;
    } 
    x = ((long long)x * x) % BASE;
    y >>= 1;
  }
  return res;
}

int getParent(int child, int level) {
  if (child == -1) return -1;
  return pa[child][level];
}

void init(int pos, int parent) {
  in[pos] = ++countIn;
  if (parent == -1) level[pos] = 1;
  else level[pos] = level[parent] + 1;
  pa[pos][0] = parent;
  for (int i = 1; i < 10; i++) {
    pa[pos][i] = getParent(pa[pos][i - 1], i - 1);
  }
  for (int i = 0; i < neighbors[pos].size(); i++) {
    if (neighbors[pos][i] != parent) {
      init(neighbors[pos][i], pos);
    }
  }
  out[pos] = ++countOut;
}

int getLCA(int a, int b) {
  if (in[a] <= in[b] && out[a] >= out[b]) return a;
  if (in[b] <= in[a] && out[b] >= out[a]) return b;
  for (int i = 9; i >= 0; i--) {
    int pa = getParent(a, i);
    if ((pa == -1) || (in[pa] <= in[b] && out[pa] >= out[b])) continue;
    a = pa;
  }
  return getParent(a, 0);
}

int DpCalc(int x, int y) {
  if (x == 0) return 1;
  if (y == 0) return 0;
  if (Dp[x][y] > -1) return Dp[x][y];
  int res = 0;
  res = ((long long)res + (long long)DpCalc(x - 1, y) * getPow(2, BASE - 2)) % BASE;
  res = ((long long)res + (long long)DpCalc(x, y - 1) * getPow(2, BASE - 2)) % BASE;
  Dp[x][y] = res;
  return res;
}

int main() {
  cin >> n;
  for (int i = 0; i < n - 1; i++) {
    int x, y;
    cin >> x >> y;
    neighbors[x - 1].push_back(y - 1);
    neighbors[y - 1].push_back(x - 1);
  }
  for (int i = 0; i < n; i++) {
    for (int j = 0; j < n; j++) {
      Dp[i][j] = -1;
    }
  }
  int res = 0;
  for (int i = 0; i < n; i++) {
    countIn = countOut = 0;
    init(i, -1);
    for (int a = 0; a < n; a++) {
      for (int b = 0; b < a; b++) {
        int c = getLCA(a, b);
        res = ((long long)res + (long long)DpCalc(level[a] - level[c], level[b] - level[c]) * getPow(n, BASE - 2)) % BASE;
      }
    }
  }
  cout << res << endl;
  return 0;
}