/**
 * code generated by JHelper
 * More info: https://github.com/AlexeyDmitriev/JHelper
 * @author cherrypi59
 */

#pragma GCC optimize ("O2")
#pragma GCC optimize ("tree-vectorize")
#pragma GCC target ("sse4")

#include <bits/stdc++.h>
#define FOR(i, a, b) for(int i=(a);i<(b);++i)
#define FFOR(i, a, b) FOR(i, a, b+1)
#define REP(i, n) FOR(i, 0, n)
#define RREP(i, n) FOR(i, 1, n+1)
#define ALL(v) (v).begin(), (v).end()
#define RALL(v) (v).rbegin(), (v).rend()
#define LEN(x) (int)(x).size()
#define DUMP(x) cerr<<__LINE__<<' '<<#x<<"="<<(x)<<endl;
#define pb push_back
#define eb emplace_back
#define mp make_pair

using namespace std;
using lint = long long;
using pii =  pair<int, int>;
using pll =  pair<lint, lint>;
template <typename T> using vc = vector<T>;
template <typename T> using vvc = vector<vector<T>>;
template <typename T> inline bool chmax(T &a, T b){if(a<b){a = b; return true;} return false;}
template <typename T> inline bool chmin(T &a, T b){if(a>b){a = b; return true;} return false;}

constexpr lint ten(int n) {return n==0 ? 1 : ten(n-1)*10;}

struct mint {
    long long x;
    static constexpr long long MOD = (long long)1e9 + 7;

    mint(long long x=0):x((x%MOD+MOD)%MOD){}

    mint& operator+=(const mint a) {
        if ((x += a.x) >= MOD) x -= MOD;
        return *this;
    }
    mint& operator-=(const mint a) {
        if ((x += MOD-a.x) >= MOD) x -= MOD;
        return *this;
    }
    mint& operator*=(const mint a) {
        (x *= a.x) %= MOD;
        return *this;
    }
    mint operator+(const mint a) const {
        mint res(*this);
        return res+=a;
    }
    mint operator-(const mint a) const {
        mint res(*this);
        return res-=a;
    }
    mint operator*(const mint a) const {
        mint res(*this);
        return res*=a;
    }
    mint pow(long long t) const {
        mint res = 1, a(*this);
        while(t){
            if(t&1) res *= a;
            t >>= 1, a *= a;
        }
        return res;
    }
    mint inv() const {
        return pow(MOD-2);
    }
    mint& operator/=(const mint a) {
        return (*this) *= a.inv();
    }
    mint operator/(const mint a) const {
        mint res(*this);
        return res/=a;
    }
    friend istream& operator>>(istream& in, mint& a){
        long long _v; in>>_v;
        a = mint(_v);
        return in;
    }
    friend ostream& operator<<(ostream& out, const mint& a){
        return out<<a.x;
    }
    friend bool operator==(const mint& a, const mint& b){
        return a.x == b.x;
    }
    friend bool operator!=(const mint& a, const mint& b){
        return a.x != b.x;
    }
};

class FSurroundedNodes {
public:
    int N;
    mint ans = 0;
    vc<int> sz;
    vc<mint> ps;
    vvc<int> G;

    void dfs(int s, int p){
        int sum = 0;
        mint pp = 1, allw = 1;
        sz[s] = 1;
        for(auto& u : G[s]){
            if(u==p) continue;
            dfs(u, s);
            sz[s] += sz[u];
            sum += sz[u];
            ps[u] = mint(2).pow(sz[u]).inv();
            allw *= ps[u];
        }
        if(p!=-1){
            ps[p] = mint(2).pow(N-1-sum).inv();
            allw *= ps[p];
        }
        pp -= allw;
        for(auto& u : G[s]){
            if(u!=p) pp -= allw / ps[u] * (mint(1)-ps[u]);
        }
        if(p!=-1){
            mint v1 = allw / ps[p];
            mint v2 = allw / ps[p] * (mint(1)-ps[p]);
            pp -= allw / ps[p] * (mint(1)-ps[p]);
        }
        ans += pp / 2;
    }

    void solve(std::istream& in, std::ostream& out){
        ios_base::sync_with_stdio(false);
        in.tie(nullptr), out.tie(nullptr);
        in>>N;
        G.resize(N);
        sz.resize(N, 0);
        ps.resize(N, 0);
        REP(i, N-1){
            int a, b;
            in>>a>>b;
            a--, b--;
            G[a].pb(b);
            G[b].pb(a);
        }
        dfs(0, -1);
        out<<ans<<'\n';
    }
};


int main() {
	FSurroundedNodes solver;
	std::istream& in(std::cin);
	std::ostream& out(std::cout);
	solver.solve(in, out);
	return 0;
}


Measured memory_bytes: 24704