#include<bits/stdc++.h>
using namespace std;

typedef long long int ll;
typedef long double ld;
typedef pair<int,int> pi;
typedef pair<ll,ll> pll;

#define endl '\n'
#define ff first
#define ss second
#define sz(v) (int)v.size()
#define int long long
#define pb push_back
#define f(i,l,r) for(ll i=l;i<=r;i++)
#define rf(i,r,l) for(ll i=r;i>=l;i--)
#define Max 5000001
#define inf 2147483647
#define llinf 9223372036854775807
#define all(v) v.begin(),v.end()
#define bp(n) __builtin_popcountll(n)
#define fast ios_base::sync_with_stdio(false),cin.tie(NULL),cout.tie(NULL)

#define d0(a) cout<<a<<' ';
#define d1(a) cout<<a<<endl;
#define d2(a,b) cout<<a<<' '<<b<<endl;
#define d3(a,b,c) cout<<a<<' '<<b<<' '<<c<<endl;
#define d4(a,b,c,d) cout<<a<<' '<<b<<' '<<c<<' '<<d<<endl;
#define d5(a,b,c,d,e) cout<<a<<' '<<b<<' '<<c<<' '<<d<<' '<<e<<endl;
#define d6(a,b,c,d,e,f) cout<<a<<' '<<b<<' '<<c<<' '<<d<<' '<<e<<' '<<f<<endl;

const ll N=2e5+5,mod=1e9+7,bit=61;

ll ans=0,pw[N],n,sub[N];
vector<ll> adj[N];

ll powerm(ll a,ll b,ll m=mod)
{
	a%=m;
	ll res=1%m;
	while(b>0)
	{
		if(b & 1)
		{
			res=(res*a)%m;
		}
		b>>=1;
		a=(a*a)%m;
	}
	return res;
}

void dfs(ll u,ll p)  // Find number of vertices in the subtree of u including it.
{
    sub[u]=1;
    for(auto v:adj[u])
    {
        if(v==p)
        {
            continue;
        }
        dfs(v,u);
        sub[u]+=sub[v];
    }
}

// How many subsets will include u as white colored in the optimal strategy.
//
// For this first of all we need to make u as a root of tree.
//
// This can be easily done by some + , - in the size of its parent.
//
// Now to have u as a white and included in subset we must have at least two vertices
// from the subtree of different children of u colored black.
//
// Which means you will have to take at least one vertex from them.
//
// Say if there are sub[v] vertices in the subtree of v (v is a child of u), then you can
// choose (2^(sub[v])-1), subsets in which you will have at least one vertex will be
// present from subtree of v and colored black.
//
// Now you just need to take subsets of children of u (with size > 1) and take at least one
// element from it, think in how many ways it can be done.
//
// So, basically find product over all the subsets and subtract case of size 1.


void solve(ll u,ll p)
{
    ll add=1,sum=0;
    for(auto v:adj[u])
    {
        add=(add * pw[sub[v]])%mod;
        sum=(sum + pw[sub[v]] - 1 + mod)%mod;
    }
    add=(add-1+mod)%mod;
    add=(add-sum+mod)%mod;
    ans=(ans + add)%mod;
    for(auto v:adj[u])
    {
        if(v==p)
        {
            continue;
        }
        // Go from u ---> v
        sub[u]-=sub[v];  // Making v as a root of tree
        sub[v]+=sub[u];
        solve(v,u);
        sub[v]-=sub[u];  // Making u again as a root of tree
        sub[u]+=sub[v];
    }
}

signed main()
{
    fast;

    pw[0]=1;
    f(i,1,N-1)
    {
        pw[i]=(pw[i-1]<<1)%mod;
    }
    ll t=1;
    //cin>>t;
    while(t--)
    {
        cin>>n;
        f(i,1,n-1)
        {
            ll u,v;
            cin>>u>>v;
            adj[u].pb(v);
            adj[v].pb(u);
        }
        dfs(1,0); // Assuming 1 as a root
        solve(1,0);
        ans=(ans * powerm(pw[n],mod-2))%mod;  // Divide by the total number of ways
        cout<<ans<<endl;
    }
    return 0;
}


















Measured memory_bytes: 21376