#include <unistd.h>
#include <vector>
#include <algorithm>

struct IO {
  static const int bufsize=1<<25;
  char ibuf[bufsize], obuf[bufsize];
  char *ip, *op;
  IO(): ip(ibuf), op(obuf) { for(int t = 0, k = 0; (k = read(STDIN_FILENO, ibuf+t, sizeof(ibuf)-t)) > 0; t+=k); }
  ~IO(){ for(int t = 0, k = 0; (k = write(STDOUT_FILENO, obuf+t, op-obuf-t)) > 0; t+=k); }
  long long scan_int(){
    long long x=0;
    bool neg=false;
    for(;*ip<'+';ip++) ;
    if(*ip=='-'){ neg=true; ip++;}
    else if(*ip=='+'){ ip++;}
    for(;*ip>='0';ip++){
      x = 10*x+*ip-'0';
    }
    if(neg) x = -x;
    return x;
  }
  void put_int(long long x, char c=0){
    static char tmp[20];
    if(x==0){
      *op++ = '0';
    }
    else {
      int i;
      if(x<0){
        *op++ = '-';
        x = -x;
      }
      for(i=0; x; i++){
        tmp[i] = x % 10;
        x /= 10;
      }
      for(i--; i>=0; i--)
        *op++ = tmp[i]+'0';
    }
    if(c) *op++ = c;
  }
  void put_double(double x, char c=0){
    unsigned y;
    const int mask = (1<<24) - 1;
    put_int(x);
    *op++ = '.';
    x = x - (int) x;
    if(x < 0) x = -x;
    y = x * (1<<24);

    for(int i=0;i<7;i++){
      y *= 10;
      *op++ = '0' + (y>>24);
      y &= mask;
    }
    if(c) *op++ = c;
  }
  inline char scan_char(){ return *ip++; }
  inline void put_char(char c){ *op++ = c; }
  inline char *scan_string(){ char *s = ip; while(*ip++!='\n'); *(ip-1)='\0'; return s;}
  inline void put_string(char *s, char c=0){ while(*s) *op++=*s++; if(c) *op++=c;}
} io;


int n;
std::vector<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)})
= 1/2 [n - (\sum_{(v,w)} 2^{-(n-Nw-1)} - \sum_v (dv-1)2^{-(n-1)})]
= 1/2 [n - \sum_{(v,w)} 2^{-(n-Nw-1)} + (n-2)*2^{-(n-1)}]
*/

long long int ans = 0;


template<int N, int Mod>
struct Powinv2 {
  static constexpr Mint<Mod> inv2 = (1+mod)/2;
  Mint<Mod> A[N+1];
  constexpr Powinv2(): A() {
    A[0] = 1;
    for(int i = 1; i <= N; i++){
      A[i] = A[i-1] * inv2;
    }
  }
};

Powinv2<200000, mod> powinv2;

int dfs0(int v, int p){
  int sum = 1;
  for(auto c: g[v]){
    if(c == p) continue;
    sum += dfs0(c, v);
  }
  if(p != -1) ans -= powinv2.A[n-sum].n + powinv2.A[sum].n;
  return sum;
}


int main(){
  n = io.scan_int();

  for(int i = 0; i < n-1; i++){
    int a = io.scan_int();
    int b = io.scan_int();
    g[a-1].emplace_back(b-1);
    g[b-1].emplace_back(a-1);
  }

  ans = (Mint<mod>(n) / 2 + (n-2) * powinv2.A[n]).n;

  dfs0(0, -1);

  ans %= mod;
  if(ans < 0) ans += mod;
  io.put_int(ans, '\n');

  
  return 0;
}


Measured memory_bytes: 22656