#include <bits/stdc++.h>

#define rep(i, n) for (ll i = 0; i < (n); i++)
#define rep2(i, a, b) for (ll i = (a); i < (b); i++)
#define chmax(x, v)                                                            \
  do {                                                                         \
    x = max(x, v);                                                             \
  } while (0)
#define chmin(x, v)                                                            \
  do {                                                                         \
    x = min(x, v);                                                             \
  } while (0)
typedef uint64_t ull;
typedef int64_t ll;
typedef std::pair<ll, ll> PLL;

using namespace std;

// {{{ Modint
// using mint = modint<1000000007>;
// mint x = 2;
// std::cout << x.a << std::endl;
template <std::int64_t M>
class modint {
 public:
  int64_t a;

  explicit constexpr modint(const int64_t x = 0) noexcept :
    a((x % M + M) % M) {}
  constexpr int64_t &value() noexcept { return a; }
  constexpr const int64_t &value() const noexcept { return a; }
  constexpr modint operator+(const modint rhs) const noexcept {
    return modint(*this) += rhs;
  }
  constexpr modint operator-(const modint rhs) const noexcept {
    return modint(*this) -= rhs;
  }
  constexpr modint operator*(const modint rhs) const noexcept {
    return modint(*this) *= rhs;
  }
  constexpr modint operator/(const modint rhs) const noexcept {
    return modint(*this) /= rhs;
  }
  constexpr modint &operator+=(const modint rhs) noexcept {
    a += rhs.a;
    if (a >= M) {
      a -= M;
    }
    return *this;
  }
  constexpr modint &operator-=(const modint rhs) noexcept {
    if (a < rhs.a) {
      a += M;
    }
    a -= rhs.a;
    return *this;
  }
  constexpr modint &operator*=(const modint rhs) noexcept {
    a = a * rhs.a % M;
    return *this;
  }
  constexpr modint &operator/=(modint rhs) noexcept {
    int64_t exp = M - 2;
    while (exp) {
      if (exp % 2) {
        *this *= rhs;
      }
      rhs *= rhs;
      exp /= 2;
    }
    return *this;
  }
  constexpr modint pow(ll t) const {
    if (!t) return modint(1);
    modint a = pow(t>>1);
    a *= a;
    if (t&1) a *= *this;
    return a;
  }
};
// }}}

using mint = modint<1000000007>;
ll N;
mint ans(0);
vector<ll> edges[300000];
vector<ll> trees[300000];

// cur以下の要素数を返す
// また、同時にcurを見た時の部分木のサイズtrees[cur]を算出しておく
ll dfs(ll cur=0, ll par=-1) {
  ll sum = 1;
  for (auto child : edges[cur]) {
    if (child == par)
      continue;
    ll t = dfs(child, cur);
    trees[cur].push_back(t);
    sum += t;
  }
  if (cur != 0) {
    trees[cur].push_back(N-sum);
  }
  // cout << "cur=" << cur << endl;
  return sum;
}

void dfs2(ll cur = 0, ll par = -1) {
  for (auto child : edges[cur]) {
    if (child == par)
      continue;
    dfs2(child, cur);
  }
  auto a = mint(2).pow(N-1); // curを除く全通りなので2^(N-1)
  a -= mint(1); // 全部白
  for (auto t : trees[cur]) {
    a -= mint(2).pow(t) - mint(1); // ある部分木で1個以上が黒
  }
  ans += a;
}

signed main() {
  cin >> N;
  rep(i, N-1) {
    ll a, b;
    cin >> a >> b;
    a--; b--;
    // cout << "a=" << a << "b=" << b << endl;
    edges[a].push_back(b);
    edges[b].push_back(a);
  }
  dfs();
  //rep(i, N){
  //  cout << "node" << i << ": " ;
  //  for (auto t : trees[i]) {
  //    cout << t << " ";
  //  }
  //  cout << endl;
  //}
  dfs2();
  ans /= mint(2).pow(N);
  cout << ans.value() << endl;
  return 0;
}


Measured memory_bytes: 40704