#include <stdio.h>
#include <cstdio>
#include <iostream>
#include <iomanip>
#include <queue>
#include <set>
#include <vector>
#include <string>
#include <cstring>
#include <algorithm>
#include <cmath>

int make_rooted_tree(std::vector<std::vector<long long int> > &G, long long int N, long long int root_index, std::vector<std::vector<long long int> > &G_rooted, std::vector<long long int> &par);
// subroutine of make_rooted_tree must not be called in other places
int sub_make_rooted_tree(std::vector<std::vector<long long int> > &G, long long int N, long long int root_index, std::vector<std::vector<long long int> > &G_rooted, std::vector<long long int> &par);

long long int count_decendents(std::vector<std::vector<long long int> > &G_rooted, long long int ind, std::vector<long long int> &n_decendents);

long long int mod(long long int x, long long int m);

long long int MOD = 1e9 + 7;

int main(){

  // read problem
  long long int N, tmp1, tmp2;
  scanf("%lld", &N);

  std::vector<std::vector<long long int> > G(N);
  for(long long int i = 0; i < N-1; i++){
    scanf("%lld%lld", &tmp1, &tmp2);
    G[tmp1-1].push_back(tmp2-1);
    G[tmp2-1].push_back(tmp1-1);
  }

  std::vector<long long int> par(N);
  std::vector<std::vector<long long int> > G_rooted(N);

  make_rooted_tree(G, N, 0, G_rooted, par);

  // count number of offsprings
  std::vector<long long int> n_decendents(N);
  for(long long int i = 0; i < N; i++){
    n_decendents[i] = -1;
  }
  count_decendents(G_rooted, 0, n_decendents);

  // prepare mod2_inverse
  std::vector<long long int> power2_inverse(N), power2(N);
  power2_inverse[0] = 1;
  power2_inverse[1] = (MOD+1)/2;
  power2[0] = 1;
  power2[1] = 2;
  for(long long int i = 2; i < N; i++){
    power2_inverse[i] = (power2_inverse[i-1]*power2_inverse[1] + MOD)%MOD;
    power2[i] = (power2[i-1]*2 + MOD)%MOD;
  }

  std::vector<long long int> subtree_sizes(N);
  long long int n_subtree;
  
  long long int ans = 0;

  // solve problem

  // calculate root value
  if(G[0].size() > 1){
    n_subtree = G[0].size();
    tmp1 = 0;
    for(long long int i = 0; i < G[0].size(); i++){
      subtree_sizes[i] = n_decendents[G[0][i]]+1;
      tmp1 += subtree_sizes[i];
    }
    //std::cerr << "check: tmp1 should be N-1 = " << tmp1 << std::endl;

    tmp2 = -(n_subtree-1)*power2_inverse[N-1]; // all the others are white
    tmp2 = mod(tmp2, MOD);
    for(long long int i = 0; i < G[0].size(); i++){
      tmp2 += power2_inverse[N-1] * power2[subtree_sizes[i]];
      tmp2 = (tmp2+MOD)%MOD;
    }
    //tmp2 = ((tmp2 * power2_inverse[1]) + MOD)%MOD;
    tmp2 = power2_inverse[1] * (1-tmp2);
    tmp2 = mod(tmp2, MOD);

    ans += tmp2;
  }

  // calculate other vertices
  for(long long int i = 1; i < N; i++){
    // no need to calculate for leaf vertex
    if(G[i].size() == 1){
      continue;
    }

    //std::cerr << "investigate i = " << i << std::endl;

    n_subtree = G[i].size();
    tmp1 = 0;
    for(long long int j = 0; j < n_subtree-1; j++){
      subtree_sizes[j] = n_decendents[G_rooted[i][j]]+1;
      tmp1 += subtree_sizes[j];
    }
    subtree_sizes[n_subtree-1] = N-1-tmp1;

    //std::cerr << "subtree_sizes: " << std::endl;
    //for(long long int i = 0; i < n_subtree; i++)std::cerr << subtree_sizes[i] << " ";
    //std::cerr << std::endl;

    tmp2 = -(n_subtree-1)*power2_inverse[N-1]; // all the others are white
    tmp2 = mod(tmp2, MOD);
    for(long long int i = 0; i < n_subtree; i++){
      tmp2 += power2_inverse[N-1] * power2[subtree_sizes[i]];
      tmp2 = (tmp2+MOD)%MOD;
    }
    //tmp2 = ((tmp2 * power2_inverse[1]) + MOD)%MOD;
    tmp2 = power2_inverse[1] * (1-tmp2);
    tmp2 = mod(tmp2, MOD);

    ans += tmp2;
    ans = (ans+MOD)%MOD;
  }

  std::cerr << "Answer: " << std::endl;
  std::cout << ans << std::endl;
  
  return 0;
}



int make_rooted_tree(std::vector<std::vector<long long int> > &G, long long int N, long long int root_index, std::vector<std::vector<long long int> > &G_rooted, std::vector<long long int> &par){
  // initialize par and call sub_make_rooted_tree
  par[root_index] = root_index;
  sub_make_rooted_tree(G, N, root_index, G_rooted, par);

  return 0;
}

int sub_make_rooted_tree(std::vector<std::vector<long long int> > &G, long long int N, long long int root_index, std::vector<std::vector<long long int> > &G_rooted, std::vector<long long int> &par){

  for(long long int i = 0; i < G[root_index].size(); i++){
    // for all connected nodes but parent node
    if(G[root_index][i] != par[root_index]){
      par[G[root_index][i]] = root_index;
      G_rooted[root_index].push_back(G[root_index][i]);
      sub_make_rooted_tree(G, N, G[root_index][i], G_rooted, par);
    }
  }

  return 0;
}

long long int count_decendents(std::vector<std::vector<long long int> > &G_rooted, long long int ind, std::vector<long long int> &n_decendents){
  // already calculated
  if(n_decendents[ind] >= 0){
    return n_decendents[ind];
  }

  // no decendents
  if(G_rooted[ind].size() == 0){
    n_decendents[ind] = 0;
    return 0;
  }

  // count decendents
  long long int ans = 0;
  for(long long int i = 0; i < G_rooted[ind].size(); i++){
    ans++;
    ans += count_decendents(G_rooted, G_rooted[ind][i], n_decendents);
  }
  n_decendents[ind] = ans;
  return ans;
}

long long int mod(long long int x, long long int m){
  if(x>0){
    return x%m;
  }
  else if(x==0){
    return 0;
  }
  else if((-x)%m == 0){
    return 0;
  }
  else{
    return m - (-x)%m;
  }
}

Measured memory_bytes: 43008