#include <cstdio>
#include <vector>
#include <algorithm>

int n;
std::vector<std::pair<int, int> > g[200000];

constexpr int mod = 1000000007;

template <int MOD>
struct Mint {
  int n;
  constexpr Mint(int n = 0): n(n) {}
  constexpr Mint operator -() const {
    return n ? MOD - n: 0;
  }
  constexpr Mint operator ++() {
    n++;
    if(n == MOD) n = 0;
    return *this;
  }
  constexpr Mint operator --() {
    n--;
    if(n < 0) n = MOD - 1;
    return *this;
  }
  constexpr Mint &operator -= (const Mint &rhs){
    if(n >= rhs.n) n -= rhs.n;
    else n = MOD - (rhs.n - n);
    return *this;
  }
  constexpr Mint &operator += (const Mint &rhs){
    n += rhs.n;
    if(n >= MOD) n -= MOD;
    return *this;
  }
  constexpr Mint &operator *= (const Mint &rhs){
    n = (long long) n * rhs.n % MOD;
    return *this;
  }
  constexpr Mint &operator /= (const Mint &rhs){
    n = (long long) n * rhs.inv().n % MOD;
    return *this;
  }
  constexpr bool operator == (const Mint &rhs) const {
    return n == rhs.n;
  }
  constexpr bool operator != (const Mint &rhs) const {
    return n != rhs.n;
  }
  friend constexpr Mint operator - (const Mint &lhs, const Mint &rhs){
    Mint r = lhs;
    r -= rhs;
    return r;
  }
  friend constexpr Mint operator + (const Mint &lhs, const Mint &rhs){
    Mint r = lhs;
    r += rhs;
    return r;
  }
  friend constexpr Mint operator * (const Mint &lhs, const Mint &rhs){
    Mint r = lhs;
    r *= rhs;
    return r;
  }
  friend constexpr Mint operator / (const Mint &lhs, const Mint &rhs){
    Mint r = lhs;
    r /= rhs;
    return r;
  }
  constexpr Mint pow(int n) const {
    Mint r = 1;
    Mint x = *this;
    for(; n; n >>= 1){
      if(n & 1) r *= x;
      x *= x;
    }
    return r;
  }
  constexpr Mint inv() const {
    return pow(MOD - 2);
  }
};

/*
\sum_v E[v is punc] = 1/2 \sum_v Prob[v cut black nodes] = 1/2 \sum_v 1 - Prob[v does not cut black nodes]
= 1/2 \sum_v 1 - (\sum_{w -- v} 2^{-(n-Nw-1)} - (dv-1)2^{-n})
= 1/2 [n - (\sum_{(v,w)} 2^{-(n-Nw-1)} - (dv-1)2^{-n})]
*/

int dfs0(int v, int p){
  int sum = 1;
  for(auto &c: g[v]){
    if(c.first == p) continue;
    c.second = dfs0(c.first, v);
//printf("%d %d %d\n", v, c.first, c.second);
    sum += c.second;
  }
  return sum;
}

void dfs1(int v, int p, int t){
  int sum = 1;
  for(auto &c: g[v]){
    if(c.first == p){
      c.second = t;
//printf("%d %d %d\n", v, p, t);
    }
    sum += c.second;
  }
  for(auto c: g[v]){
    if(c.first == p) continue;
    dfs1(c.first, v, sum - c.second);
  }
}

constexpr Mint<mod> inv2 = (1+mod)/2;

int main(){
  scanf("%d", &n);

  for(int i = 0; i < n-1; i++){
    int a, b;
    scanf("%d%d", &a, &b);
    g[a-1].emplace_back(std::pair<int, int>({b-1, -1}));
    g[b-1].emplace_back(std::pair<int, int>({a-1, -1}));
  }

  dfs0(0, -1);
  dfs1(0, -1, 0);

  
  Mint<mod> ans = 0;
  for(int i = 0; i < n; i++){
    Mint<mod> tmp = 0;
    for(auto e: g[i]){
      ans += inv2.pow(n-1-e.second);
      tmp += inv2.pow(n-1-e.second);
//printf("CC %d\n", n-1-e.second);
    }
    ans -= (g[i].size() - 1) * inv2.pow(n-1);
    tmp -= (g[i].size() - 1) * inv2.pow(n-1);
// printf("ZZ %d %d %d\n", i, tmp.n, g[i].size());
  }

  ans = n - ans;
  ans /= 2;

  printf("%d\n", ans.n);

  
  return 0;
}


Measured memory_bytes: 18176