#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define db double
#define pii pair<int,int>
#define pli pair<ll,int>
#define pil pair<int,ll>
#define pll pair<ll,ll>
#define mat vector<vector<double>>
const ll mod = 1e9 + 7;
const int inf = 1 << 30;
const ll linf = 1e18;
const db EPS = 1e-7;
template<class T> void chmin(T& x, T y){if(x > y) x = y;}
template<class T> void chmax(T& x, T y){if(x < y) x = y;}

template<long long mod>
struct modint{
    long long num;

    constexpr modint(long long x = 0) : num((x + mod) % mod) {}

    constexpr modint &operator += (const modint& rhs){
        num = (num + rhs.num) % mod;
        return *this;
    }
    constexpr modint &operator -= (const modint& rhs){
        num  -= rhs.num;
        while(num < 0) num += mod;
        num %= mod;
        return *this;
    }
    constexpr modint &operator *= (const modint& rhs){
        num = num * rhs.num % mod;
        return *this;
    }
    constexpr modint &operator /= (modint rhs){
        int exp = mod - 2;
        while(exp > 0){
            if(exp % 2){
                *this *= rhs;
            }
            rhs *= rhs;
            exp /= 2;
        }
        return *this;
    }

    constexpr modint operator ++ (){
        ++num;
        return *this;
    }
    constexpr modint operator ++ (int n){
        modint tmp = *this;
        ++(*this);
        return tmp;
    }
    constexpr modint operator -- (){
        --num;
        return *this;
    }
    constexpr modint operator -- (int n){
        const modint tmp = *this;
        --(*this);
        return tmp;
    }

    void modpow(ll y){
        modint tmp = (*this);
        (*this) = 1;
        while(y > 0){
            if(y % 2){
                (*this) *= tmp;
            }
            tmp *= tmp;
            y /= 2;
        }
    }

    constexpr modint operator + (const modint& rhs) const {
        return modint(*this) += rhs;
    }
    constexpr modint operator - (const modint& rhs) const {
        return modint(*this) -= rhs;
    }
    constexpr modint operator * (const modint& rhs) const {
        return modint(*this) *= rhs;
    }
    constexpr modint operator / (const modint& rhs) const {
        return modint(*this) /= rhs;
    }

    
    friend ostream &operator << (ostream& lhs, const modint& rhs){
        return lhs << rhs.num;
    }

    friend istream &operator >> (istream& lhs, modint& rhs){
        long long tmp;
        lhs >> rhs.num;
        return lhs;
    }
};

#define mint modint<1000000007>

struct comb_perm{
    int N;
    const ll mod = 1e9 + 7;
    vector<mint> fac;
    vector<mint> rec;

    mint modpow(mint x, int y){
        if(y == 0) return 1;
        mint e = modpow(x, y / 2);
        e = e * e;
        return e * (y % 2 == 0 ? 1 : x);
    }

    comb_perm(int N): N(N), fac(N + 1), rec(N + 1){
        fac[0] = rec[0] = 1;
        for(int i = 1; i <= N; i++){
            fac[i] = fac[i - 1] * i;
            rec[i] = modpow(fac[i], mod - 2);
        }
    }

    mint comb(int p, int r){
        return fac[p] * rec[r] * rec[p - r];
    }

    mint perm(int p, int r){
        return fac[p] * rec[p - r];
    }
};

int N, T;
int son[200010];
vector<int> G[200010];
mint y;


mint modpow(mint x, int y){
    if(y == 0) return 1;
    mint e = modpow(x, y / 2);
    e = e * e;
    return e * (y % 2 == 0 ? 1 : x);
}

void dfs(int v, int p){
    y += modpow(2, N - 1);
    son[v] = 1;
    for(auto& u : G[v]){
        if(u == p) continue;
        dfs(u, v);
        son[v] += son[u];
        y -= modpow(2, son[u]) - 1;
    }
    y -= modpow(2, N - son[v]);
}

int main(){
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
    cin >> N;
    for(int i = 1; i < N; i++){
        int A, B;
        cin >> A >> B;
        G[A].push_back(B);
        G[B].push_back(A);
    }
    mint z = modpow(2, N);
    z.modpow(mod - 2);
    dfs(1, 0);
    cout << z * y << endl;
    return 0;
}

Measured memory_bytes: 20864