#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define REP(i,n) for (ll i = 0; i < (n); ++i)

struct mint{
    static const long long MOD = 1000000007;

    long long v;

    mint() : v(0) {}
    mint(long long x){
        x = x % MOD;
        if(x < 0){ x += MOD; }
        v = x;
    }
    mint& operator+=(mint a){
        v += a.v;
        if(v >= MOD){ v -= MOD; }
        return *this;
    }
    mint& operator*=(mint a){
        v *= a.v;
        v %= MOD;
        return *this;
    }
    mint& operator-=(mint a){
        v -= a.v;
        if(v < 0){ v += MOD; }
        return *this;
    }
    mint& operator/=(mint a){
        return (*this) *= a.inv();
    }

    mint operator*(mint a) const{
        return mint(v) *= a;
    }

    mint operator+(mint a) const {
        return mint(v) += a;
    }

    mint operator-(mint a) const {
        return mint(v) -= a;
    }

    mint operator/(mint a) const {
        return mint(v) /= a;
    }

    mint pow(long long k) const {
        mint res(1),tmp(v);
        while(k){
            if(k&1) res *= tmp;
            tmp *= tmp;
            k >>= 1;
        }
        return res;
    }
    mint inv(){return pow(MOD - 2); }

    static mint comb(long long n, int k){
        mint res(1);
        for(int i = 0; i < k; ++i){
            res *= mint(n - i);
            res /= mint(i + 1);
        }
        return res;
    }

    static mint factorial(long long n){
        mint res(1);
        for(int i = n; i > 1; --i){
            res *= mint(i);
        }
        return res;
    }

    bool operator<(const mint &a) const {
        return v < a.v;
    };
};

mint operator*(long long l, mint r){ return r * l; }

std::ostream& operator<<(std::ostream& stream, const mint& m){
    stream << m.v;
    return stream;
}

vector<vector<ll>> net;
vector<map<ll, ll>> num;

void count(ll cur, ll par){
    for(ll nxt : net.at(cur)){
        if(nxt == par){ continue; }
        count(nxt, cur);
        ll tmp = 1;
        for(ll x : net.at(nxt)){
            if(x == cur){ continue; }
            tmp += num.at(nxt).at(x);
        }
        num.at(cur)[nxt] = tmp;
    }
    if(par != -1){
        ll tmp = 0;
        for(ll nxt : net.at(cur)){
            if(nxt != par){
                tmp += num.at(cur).at(nxt);
            }
        }
        num.at(cur)[par] = (ll)net.size() - 1 - tmp;
    }
}

void solve(long long N, std::vector<long long> A, std::vector<long long> B){
    net.resize(N);
    REP(i, N - 1){
        ll a = A.at(i) - 1;
        ll b = B.at(i) - 1;
        net.at(a).push_back(b);
        net.at(b).push_back(a);
    }

    num.resize(N);
    count(0, -1);

    vector<mint> pow2(N), pow2inv(N);
    pow2.at(0) = 1;
    pow2inv.at(0) = 1;
    for(ll i = 1; i < N; ++i){
        pow2.at(i) = pow2.at(i - 1) * 2;
        pow2inv.at(i) = pow2.at(i).inv();
    }

    mint ans = 0;
    REP(i, N){
        mint tmp = 0;
        for(auto p : num.at(i)){
            assert(p.second < N);
            tmp += pow2.at(p.second);
        }
        tmp -= net.at(i).size();
        tmp += 1;
        for(auto p : num.at(i)){
            tmp *= pow2inv.at(p.second);
        }
        ans += (mint(1) - tmp) / 2;
    }
    cout << ans << endl;
}

// Generated by 1.1.6 https://github.com/kyuridenamida/atcoder-tools
int main(){
    long long N;
    scanf("%lld",&N);
    std::vector<long long> A(N-1);
    std::vector<long long> B(N-1);
    for(int i = 0 ; i < N-1 ; i++){
        scanf("%lld",&A[i]);
        scanf("%lld",&B[i]);
    }
    solve(N, std::move(A), std::move(B));
    return 0;
}


Measured memory_bytes: 72192