#include<bits/stdc++.h>

#define int long long
using namespace std;
#define rep(i, n) for(int i=0;i<(n);++i)
typedef pair<int, int> pii;
const int INF = 1l << 60;

template<int M = 1000000007>
struct ModInt {
    int data;

    ModInt(int data) : data(data) {}

    ModInt() : data(0) {}

    inline ModInt<M> operator+(ModInt<M> const &right) const {
        int temp = data + right.data;
        return ModInt(temp > M ? temp - M : temp);
    }

    inline ModInt<M> &operator+=(ModInt<M> const &right) {
        data += right.data;
        data = data > M ? data - M : data;
        return *this;
    }

    inline ModInt<M> operator-(ModInt<M> const &right) const {
        int temp = data - right.data;
        return ModInt(temp < 0 ? temp + M : temp);
    }

    inline ModInt<M> &operator-=(ModInt<M> const &right) {
        data -= right.data;
        data = data < 0 ? data + M : data;
        return *this;
    }

    inline ModInt<M> operator*(ModInt<M> const &right) const {
        int temp = data * right.data % M;
        return ModInt(temp < 0 ? temp + M : temp);
    }

    inline ModInt<M> &operator*=(ModInt<M> const &right) {
        data = data * right.data % M;
        data = data < 0 ? data + M : data;
        return *this;
    }

    inline bool operator==(ModInt<M> const &right) const {
        return data == right.data;
    }

    inline bool operator!=(ModInt<M> const &right) const {
        return data != right.data;
    }


};

template<int M = 1000000007>
inline ostream &operator<<(ostream &os, const ModInt<M> mi) {
    os << mi.data;
    return os;
}

int N;
vector<int> G[200200];
int size[200200];
ModInt<> ALN;
ModInt<> two_n[200200];
ModInt<> two_n_inv[200200];
const ModInt<> one = 1;

int dfs(int v, int p) {
    int s = 1;
    ALN += two_n_inv[1];
    vector<int> vec;
    for (int to:G[v]) {
        if (to == p)continue;
        int tmp = dfs(to, v);
        vec.push_back(tmp);
        s += tmp;
    }
    size[v] = s;
    if (N - s != 0)vec.push_back(N - s);
    if (vec.size() == 1)return s;
    else {
        ModInt<> p = two_n_inv[N - 1];
        for (int c:vec) {
            p += two_n_inv[N - c - 1] - two_n_inv[N - 1];
        }
        ALN += two_n_inv[1] * (one - p);
    }
    return s;
}

ModInt<> power(ModInt<> a, int b) {
    ModInt<> res = 1;
    while (b) {
        if (b & 1)res *= a;
        a *= a;
        b /= 2;
    }
    return res;
}

signed main() {
    cin >> N;
    //2^N通りある

    two_n[0] = 1;
    for (int i = 1; i < N + 10; ++i) {
        two_n[i] = two_n[i - 1] * 2;
    }

    two_n_inv[N + 9] = power(two_n[N + 9], 1000000005);
    for (int i = N + 8; i >= 0; --i) {
        two_n_inv[i] = two_n_inv[i + 1] * 2;
    }

    rep(i, N - 1) {
        int a, b;
        cin >> a >> b;
        --a, --b;
        G[a].push_back(b);
        G[b].push_back(a);
    }
    dfs(0, -1);
    /*
    ModInt<> aln = 0;
    for (int i = 0; i < N; ++i) {
        int s = size[i];
        const ModInt<> one = 1;
        ModInt<> p = two_n_inv[1] + two_n_inv[1] * (one - two_n_inv[s - 1]) * (one - two_n_inv[N - s]);
        aln += p;
    }
     */
    ModInt<> black = N;
    black *= two_n_inv[1];//黒の頂点:全体の半分
    ModInt<> ans = ALN - black;
    cout << ans << endl;
    return 0;
}


Measured memory_bytes: 29696