#include<bits/stdc++.h>
typedef long long ll;
typedef std::pair<ll, ll> P;

#define rep(i,n) for(int i = 0; i < int(n); i++)
using namespace std;

template<class T> inline bool chmax(T& a, const T& b) { if (a < b) { a = b; return 1; } return 0; }
template<class T> inline bool chmin(T& a, const T& b) { if (b < a) { a = b; return 1; } return 0; }

constexpr ll mod = 1e9 + 7;

constexpr ll mpow(ll x, ll n) {
	ll ans = 1; x %= mod;
	while (n != 0) {
		if (n & 1) ans = ans * x % mod;
		x = x * x % mod;
		n = n >> 1;
	}
	return ans;
}

ll inv_mod(ll a) { return mpow(a, mod - 2); }

class modint {
	std::uint_fast64_t Modulus = 1e9 + 7;
	using u64 = std::uint_fast64_t;

public:
	u64 a;
	constexpr modint(const u64 x = 0) noexcept : a(x% Modulus) {}
	constexpr u64& value() noexcept { return a; }
	constexpr const u64& value() const noexcept { return a; }
	constexpr modint operator+(const modint rhs) const noexcept {
		return modint(*this) += rhs;
	}
	constexpr modint operator-(const modint rhs) const noexcept {
		return modint(*this) -= rhs;
	}
	constexpr modint operator*(const modint rhs) const noexcept {
		return modint(*this) *= rhs;
	}

	constexpr modint operator / (const modint p) const noexcept {
		modint tmp(mpow(p.a, Modulus - 2));
		return modint(*this) *= tmp;
	}

	constexpr modint& operator+=(const modint rhs) noexcept {
		a += rhs.a;
		if (a >= Modulus) {
			a -= Modulus;
		}
		return *this;
	}
	constexpr modint& operator-=(const modint rhs) noexcept {
		if (a < rhs.a) {
			a += Modulus;
		}
		a -= rhs.a;
		return *this;
	}
	constexpr modint& operator*=(const modint rhs) noexcept {
		a = a * rhs.a % Modulus;
		return *this;
	}
	constexpr modint& operator /= (const modint& p) noexcept {
		modint tmp(mpow(p.a, mod - 2));
		*this = modint(*this) * tmp;
		return *this;
	}
	constexpr operator u64() const { return a; }
};

vector<unordered_map<ll, ll>> count_child_node_count(vector<vector<int>> g) {
	int n = g.size();
	int root = -1;
	rep(i, n) {
		if (g[i].size() == 1) {
			root = i;
			break;
		}
	}
	//dp[i][j]...jを親としたときの頂点i以下の頂点数
	vector<unordered_map<ll, ll>> dp(n);
	function<ll(int, int)> dfs = [&](int current, int parent) {
		ll sum = 1;
		for (auto child : g[current]) {
			if (child == parent) continue;
			ll c = dfs(child, current);
			sum += c;
		}
		dp[current][parent] = sum;
		return sum;
	};
	dfs(root, -1);
	function<void(int, int, int)> dfs2 = [&](int current, int parent, int c) {
		dp[parent][current] = c;
		ll childSum = 0;
		for (auto child : g[current]) {
			childSum += dp[child][current];
		}
		for (auto child : g[current]) {
			if (child == parent) continue;
			dfs2(child, current, childSum - dp[child][current] + 1);
		}
	};
	dfs2(g[root][0], root, 1);
	return dp;
}


int main() {
	ll n;
	cin >> n;
	vector<vector<int>> g(n);
	rep(i, n - 1) {
		int a, b;
		cin >> a >> b;
		a--; b--;
		g[a].emplace_back(b);
		g[b].emplace_back(a);
	}
	auto node_count = count_child_node_count(g);
	modint sum = 0;
	for (int i = 0; i < n; i++) {
		if (g[i].size() == 1) continue;
		modint all = mpow(2, n - 1);
		//all white
		modint v1 = modint(1);
		all -= v1;
		for (auto p : g[i]) {
			modint vs = node_count[p][i];
			modint anyBlack = mpow(2, vs) - 1 + mod;
			all -= anyBlack;
		}
		modint div = modint(1) / modint(2);
		modint add = all * modint(mpow(div.a, n));
		sum += add;
	}
	cout << sum.a << endl;
	return 0;
}


Measured memory_bytes: 77156