#include <iostream>
#include <sstream>
#include <stack>
#include <iomanip>
#include <numeric>
#include <string>
#include <cstring>
#include <algorithm>
#include <functional>
#include <cstdlib>
#include <map>
#include <set>
#include <vector>
#include <utility>
#include <queue>
#include <cmath>

#define BEGIN(x) x.begin()
#define END(x) x.end()
#define ALL(x) BEGIN(x), END(x)
#define PAIR make_pair
#define VEC(type) vector<type >
#define endl '\n'

#define FOR(i, A, B) for(auto i = (A);i != (B); i++)
#define FORD(i, A, B) for(auto i = (A);i != (B); i--)

#define READRANGE(begin, end) FOR(it, begin, end) cin >> *it
#define READVEC(V) READRANGE(BEGIN(V), END(V))

using namespace std;

typedef long long lint;
typedef pair<int, int> Pii;
typedef pair<int, lint> Pil;
typedef pair<lint, lint> Pll;
typedef pair<lint, int> Pli;

template<class U, class V>
istream& operator >>(istream& in, pair<U, V>& pr) {
    return in >> pr.first >> pr.second;
}

// ---- BEGIN LIBRARY CODE ----
// ---- END LIBRARY CODE ----
void io_init()
{
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
};

const int MOD = 1000000007;

void Dfs(int node, int par, VEC(VEC(int))& Edges,
         VEC(int)& parents,
         VEC(int)& Sizes, int& count)
{
    int curc = count++;
    parents[node] = par;
    for (int child : Edges[node])
        if (child != par) {
            Dfs(child, node, Edges, parents, Sizes, count);
        }

    Sizes[node] = count - curc;
};

int modpow(int a, int x)
{
    if (x == 0)
        return 1;

    if (x % 2 == 1)
        return (int)(a * 1LL * modpow(a, x - 1) % MOD);

    int ret = modpow(a, x / 2);
    return (int)(ret * 1LL * ret % MOD);
};

int modinv(int a)
{
    return modpow(a, MOD - 2);
};

int F(int x)
{
    int a = modpow(2, x);
    int numer = (MOD + a - 1) % MOD;
    int denom = a;
    return (int)(numer * 1LL * modinv(denom) % MOD);
};

int G(int x)
{
    return modinv(modpow(2, x));
};

int main(int argc, char **argv)
{
    io_init();

    // Actual program code starts here.
    int N;
    cin >> N;
    VEC(VEC(int)) Edges(N);
    FOR(i, 0, N - 1) {
        int u, v;
        cin >> u >> v;
        u--; v--;
        Edges[u].push_back(v);
        Edges[v].push_back(u);
    }

    VEC(int) Sizes(N, 0);
    VEC(int) Parents(N);
    int count = 0;
    Dfs(0, -1, Edges, Parents, Sizes, count);

    int ret = 0;
    FOR(i, 0, N) {
        VEC(int) A, B;
        int cnt = 0;
        for (int next : Edges[i])
            if (next != Parents[i]) {
                cnt += Sizes[next];
                A.push_back(F(Sizes[next]));
                B.push_back(G(Sizes[next]));
            }

        if (Parents[i] >= 0) {
            cnt = N - cnt - 1;
            A.push_back(F(cnt));
            B.push_back(G(cnt));
        }

        if (A.size() < 2)
            continue;

        int none = 1;
        for (int b : B)
            none = (int)(none * 1LL * b % MOD);

        // 1 - none - one.
        int one = 0;
        FOR(j, 0, A.size()) {
            int rest = (int)(none * 1LL * modinv(B[j]) % MOD);
            one += (int)(rest * 1LL * A[j] % MOD);
            one %= MOD;
        }

        ret += (MOD + 1 - none + MOD - one) % MOD;
        ret %= MOD;
    }

    ret = (int)(ret * 1LL * modinv(2) % MOD);
    cout << ret << endl;
    return 0;
};

Measured memory_bytes: 26112