#include <iostream>
#include <iomanip>
#include <string>
#include <vector>
#include <set>
#include <map>
#include <queue>
#include <algorithm>
#include <numeric>
#include <cmath>
#include <cassert>

using namespace std;
typedef long long LL;
template <typename F, typename S> std::ostream& operator<<(ostream& os, const pair<F,S>& p) {
    os << "(" << p.first << "," << p.second << ")"; return os; }
template <typename T> ostream& operator<<(ostream& os, const vector<T>& v) {
    os << "["; for(const T& a: v){ os << a << ", "; } os << "]"; return os; }
template <typename K, typename V> ostream& operator<<(ostream& os, const map<K,V>& m) {
    os << "{"; for(const auto& p: m){ os << p.first <<":"<< p.second << ", "; } os << "}"; return os; }


// 剰余演算クラス
struct ModInt{
    static const LL MOD = 1e+9 + 7;
    LL v;
    ModInt():v(0){}
    ModInt(LL op):v(op){}
    ModInt operator+(ModInt op) const{ return (v + op) % MOD; }
    ModInt operator-(ModInt op) const{ return (v - op + MOD) % MOD; }
    ModInt operator*(ModInt op) const{ return (v * op) % MOD; }
    ModInt operator/(ModInt op) const{ return (v * op.inverse()) % MOD; }
    ModInt operator%(LL op) = delete;
    ModInt operator+=(ModInt op){ return v = (v + op) % MOD; }
    ModInt operator-=(ModInt op){ return v = (v - op + MOD) % MOD; }
    ModInt operator*=(ModInt op){ return v = (v * op) % MOD; }
    ModInt operator/=(ModInt op){ return v = (v * op.inverse()) % MOD; }
    ModInt operator-() const{ return MOD - v; }
    bool operator==(ModInt op) const{ return v == op.v; }
    bool operator!=(ModInt op) const{ return v != op.v; }
    ModInt inverse() const{ return pow(MOD-2); }
    ModInt pow(LL n) const{
        if(n < 0) return pow(MOD-1 + n);
        if(n == 0) return 1;
        ModInt res = pow(n/2);
        return res * res * ((n&1)?ModInt(v): ModInt(1));
    }
    LL get() const{ return v; }
private:
    operator LL() const{ return v; }
};
istream& operator>>(istream& st, ModInt& m){ st>>m.v; return st; }
ostream& operator<<(ostream& st, const ModInt& m){ st<<m.v; return st; }


LL calc_children(LL cur, LL parent, vector<vector<LL>>& edge, vector<LL>& num_children){
    LL cnt = 1;
    for(LL next: edge[cur]){
        if(next == parent) continue;
        cnt += calc_children(next, cur, edge, num_children);
    }
    num_children[cur] = cnt;
    return cnt;
}


int main(){
    LL n;
    cin >> n;
    vector<vector<LL>> edge(n);
    for(LL i = 0; i < n-1; ++i){
        LL a, b;
        cin >> a >> b;
        --a; --b;
        edge[a].push_back(b);
        edge[b].push_back(a);
    }
    vector<LL> num_children(n);
    calc_children(0, -1, edge, num_children);
    ModInt exp(0);
    for(LL i = 0; i < n; ++i){
        if(edge[i].size() == 1) continue;
        ModInt p = ModInt(1);
        for(LL child: edge[i]){
            LL n_child = num_children[child];
            if(n_child > num_children[i]){
                n_child = n - num_children[i]; // parent node
            }
            p *= ModInt(1) / ModInt(2).pow(n_child);
        }
        ModInt p2(0);
        for(LL child: edge[i]){
            LL n_child = num_children[child];
            if(n_child > num_children[i]){
                n_child = n - num_children[i]; // parent node
            }
            p2 += p * ModInt(2).pow(n_child) * (ModInt(1) - ModInt(1) / ModInt(2).pow(n_child));
        }
        exp += ModInt(1) / ModInt(2) * (ModInt(1) - p - p2);
    }
    cout << exp << endl;
    return 0;
}



Measured memory_bytes: 27224