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

typedef long long ll;
typedef pair<int, int> pii;
typedef vector<int> vi;
const ll inf = 1e9 + 7;

template<class T>
struct RMQ {
	vector<vector<T>> jmp;
	RMQ(const vector<T>& V) : jmp(1, V) {
		for (int pw = 1, k = 1; pw * 2 <= V.size(); pw *= 2, ++k) {
			jmp.emplace_back(V.size() - pw * 2 + 1);
			for (int j = 0; j < jmp[k].size(); j++)
				jmp[k][j] = min(jmp[k - 1][j], jmp[k - 1][j + pw]);
		}
	}
	T query(int a, int b) {
		assert(a <= b); // or return inf if a == b
		int dep = 31 - __builtin_clz(b - a);
		return min(jmp[dep][a], jmp[dep][b - (1 << dep)]);
	}
};

struct LCA {
	int T = 0;
	vi time, path, ret, depth;
	RMQ<int> rmq;
 
	LCA(int st, vector<vi>& C) : time(C.size()), depth(C.size()), rmq((dfs(C,st,-1, 0), ret)) {}
	void dfs(vector<vi>& C, int v, int par, int d) {
		depth[v] = d;
		time[v] = T++;
		for (auto& y: C[v]) if (y != par) {
			path.push_back(v), ret.push_back(time[v]);
			dfs(C, y, v, d+1);
		}
	}
 
	int lca(int a, int b) {
		if (a == b) return a;
		tie(a, b) = minmax(time[a], time[b]);
		return path[rmq.query(a, b)];
	}
};

ll pow(ll a, ll n, ll mod = inf) {
	ll res = 1;
	while (n) {
		if (n & 1LL) res = res * a % mod;
		a = a * a % mod;
		n >>= 1LL;	
	}
	return res;
}
 
int main(){
	ios_base::sync_with_stdio(false), cin.tie(nullptr);
	int n;
	cin >> n;
	vector<vector<int> > edges(n);
	for(int i = 0; i < n-1; i++){
		int u, v;
		cin >> u >> v;
		u--; v--;
		edges[u].push_back(v);
		edges[v].push_back(u);
	}
	const int K = 210;
	vector<vector<ll>> dp(K, vector<ll>(K, 0));
	for (int i = 0; i < K; ++i) {
		for (int j = 0; j < K; ++j) {
			ll& c = dp[i][j];
			if (i==0) c = 0;
			else if (j==0) c = 1;
			else dp[i][j] = (dp[i][j-1] + dp[i-1][j]) % inf * pow(2, inf-2, inf) % inf;
		}
	}

	ll ans = 0;
	for (int r = 0; r < n; r++) {
		LCA lca(r, edges);
		for (int i = 0; i < n; i++) {
			for (int j = i + 1; j < n; j++) {
				int k = lca.lca(i, j);
				ans += dp[lca.depth[i] - lca.depth[k]][lca.depth[j] - lca.depth[k]];
				ans %= inf;
			}
		}
	}
	cout << ans * pow(n, inf-2, inf) % inf; 
}