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

template <int _mod = 998244353>
class Modular {

 private:
  static constexpr int mod = _mod;
  static_assert(_mod > 0, "mod must be positive");
  
  int value;

 public:

  Modular() : value(0) {}
  template <typename U> Modular(const U& _value) {
    value = normalize(_value);
  }
    
  template <typename U> static int normalize(const U& _value) {
    int v;
    if (-mod <= _value && _value < mod) v = static_cast<int>(_value);
    else v = static_cast<int>(_value % mod);
    if (v < 0) v += mod;
    return v;
  }
  template <typename U> static U inverse(U a, U m) {
    U u = 0, v = 1;
    while (a != 0) {
      U t = m / a;
      m -= t * a; swap(a, m);
      u -= t * v; swap(u, v);
    }
    assert(m == 1);
    return u;
  }
    
  const int& operator ()() const { return value; }
  template <typename U> explicit operator U() const { return static_cast<U>(value); }

  template <typename U> friend U& operator << (U& stream, const Modular& number) {
    return stream << number();
  }
  template <typename U> friend U& operator >> (U& stream, Modular& number) {
    long long x;
    stream >> x;
    number.value = normalize(x);
    return stream;
  }

  Modular& operator -= (const Modular& other) { if ((value -= other.value) < 0) value += mod; return *this; }
  template <typename U> Modular& operator -= (const U& other) { return *this -= Modular(other); }
  Modular& operator += (const Modular& other) { return *this -= Modular(mod - other.value); }
  template <typename U> Modular& operator += (const U& other) { return *this += Modular(other); }
  Modular& operator ++ () { return *this += 1; }
  Modular& operator -- () { return *this -= 1; }
  Modular operator ++ (int) { Modular result(*this); *this += 1; return result; }
  Modular operator -- (int) { Modular result(*this); *this -= 1; return result; }
  Modular operator - () const { return Modular(-value); }
    
  Modular& operator *= (const Modular& other) {
    value = normalize(static_cast<long long>(value) * static_cast<long long>(other.value));
    return *this;
  }
  template <typename U> Modular& operator *= (const U& other) { return *this *= Modular(other); }
  Modular& operator /= (const Modular& other) { return *this *= Modular(inverse(other.value, mod)); }
  template <typename U> Modular& operator /= (const U& other) { return *this /= Modular(other); }
    
  friend bool operator == (const Modular& first, const Modular& second) { return first.value == second.value; }
  template <typename U> friend bool operator == (const Modular& first, const U& second) { return first == Modular(second); }
  template <typename U> friend bool operator == (const U& first, const Modular& second) { return Modular(first) == second; }
    
  friend bool operator != (const Modular& first, const Modular& second) { return !(first.value == second.value); }
  template <typename U> friend bool operator != (const Modular& first, const U& second) { return first != Modular(second); }
  template <typename U> friend bool operator != (const U& first, const Modular& second) { return Modular(first) != second; }

  friend Modular operator + (const Modular& first, const Modular& second) { return Modular(first) += second; }
  template <typename U> friend Modular operator + (const Modular& first, const U& second) { return Modular(first) += second; }
  template <typename U> friend Modular operator + (const U& first, const Modular& second) { return Modular(first) += second; }

  friend Modular operator - (const Modular& first, const Modular& second) { return Modular(first) -= second; }
  template <typename U> friend Modular operator - (const Modular& first, const U& second) { return Modular(first) -= second; }
  template <typename U> friend Modular operator - (const U& first, const Modular& second) { return Modular(first) -= second; }

  friend Modular operator * (const Modular& first, const Modular& second) { return Modular(first) *= second; }
  template <typename U> friend Modular operator * (const Modular& first, const U& second) { return Modular(first) *= second; }
  template <typename U> friend Modular operator * (const U& first, const Modular& second) { return Modular(first) *= second; }

  friend Modular operator / (const Modular& first, const Modular& second) { return Modular(first) /= second; }
  template <typename U> friend Modular operator / (const Modular& first, const U& second) { return Modular(first) /= second; }
  template <typename U> friend Modular operator / (const U& first, const Modular& second) { return Modular(first) /= second; }
  
  template <typename U> friend Modular power(const Modular& base, const U& exponent) {
    assert(exponent >= 0);
    Modular x = base, res = 1;
    U p = exponent;
    while (p > 0) {
      if(p & 1) res *= x;
      x *= x;
      p >>= 1;
    }
    return res;
  } 
};

using Mint = Modular<int(1e9)+7>;
// <, >, <=, >= comparisons not available
int main() {
  ios::sync_with_stdio(false);
  cin.tie(nullptr);
  int n;
  cin >> n;
  const int inf = 1e9 + 5;
  vector<vector<int>> dis(n, vector<int>(n, inf));
  for (int i = 0; i < n; i++) {
    dis[i][i] = 0;
  }
  for (int i = 0; i < n - 1; i++) {
    int u, v;
    cin >> u >> v;
    --u, --v;
    dis[u][v] = dis[v][u] = 1;
  }
  for (int k = 0; k < n; k++) {
    for (int i = 0; i < n; i++) {
      for (int j = 0; j < n; j++) {
        dis[i][j] = min(dis[i][j], dis[i][k] + dis[k][j]);
      }
    }
  }
  vector<vector<Mint>> dp(n + 1, vector<Mint>(n + 1));
  for (int i = 1; i <= n; i++) {
    dp[i][0] = 1;
    for (int j = 1; j <= n; j++) {
      dp[i][j] = (dp[i - 1][j] + dp[i][j - 1]) / 2;
    }
  }
  Mint ans = 0;
  for (int r = 0; r < n; r++) {
    for (int i = 0; i < n; i++) {
      for (int j = i + 1; j < n; j++) {
        int x = dis[i][r], y = dis[r][j];
        int d = (x + y - dis[i][j]) / 2;
        x -= d, y -= d;
        ans += dp[x][y];
      }
    }
  }
  ans /= n;
  cout << ans << '\n';
  return 0;
}
