#include<bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
#define FOR(i,a,b) for(int i=(a);i<(b);++i)
#define IFOR(i,a,b) for(int i=(b-1);i>=(a);--i)
#define RPT(i,a,b) for(int i=(a);i<((a)+(b));++i)
#define IRPT(i,a,b) for(int i=((a)+(b)-1);i>=(a);--i)

namespace qweqwe {
  using i32 = int;
  using i64 = long long int;
  using ui32 = unsigned int;
  using ui64 = unsigned long long int;
  using d32 = float;
  using d64 = double;
  using d128 = long double;
  namespace constnumber{//ver 1.1
    constexpr qweqwe::i32  INF_i32 = ((qweqwe::i32)1)<<29;
    constexpr qweqwe::i64  INF_i64 = ((qweqwe::i64)1)<<60;
    constexpr qweqwe::d64  PI_d64 = 3.14159265358979323846264338327950288;
    constexpr qweqwe::d128 PI_d128 = 3.14159265358979323846264338327950288;
    constexpr qweqwe::d64  LN2_d64 = 0.693147180559945309417232121458;
    constexpr qweqwe::d128 LN2_d128 = 0.693147180559945309417232121458;
    constexpr qweqwe::d64  LN10_d64  = 2.302585092994045684017991454684;
    constexpr qweqwe::d128 LN10_d128 = 2.302585092994045684017991454684;
    constexpr qweqwe::d64  GOLDRATIO_d64  = 1.61803398874989484820458683436563811;
    constexpr qweqwe::d128 GOLDRATIO_d128 = 1.61803398874989484820458683436563811;
    constexpr qweqwe::d64  SILVERRATIO_d64  = 2.414213562373095048801688724210;
    constexpr qweqwe::d128 SILVERRATIO_d128 = 2.414213562373095048801688724210;
    constexpr qweqwe::d64  E_d64  = 2.71828182845904523536028747135266249;
    constexpr qweqwe::d128 E_d128 = 2.71828182845904523536028747135266249;
    constexpr qweqwe::d64  OMEGA_d64  = 0.5671432904097838729999686622;
    constexpr qweqwe::d128 OMEGA_d128 = 0.5671432904097838729999686622;
  }
  namespace stdplus{//ver 1.3
    namespace iosplus{
      inline void iosFast(){
        std::cin.tie(0);
        std::ios::sync_with_stdio(false);
      }
      inline void iosDouble(i32 N){
        std::cout << std::fixed << std::setprecision(N);
      }
      template<typename T> std::istream &operator>>(std::istream &is, std::vector<T> &vec){ for (auto &v : vec) is >> v; return is; }
      template<typename T> std::ostream &operator<<(std::ostream &os, const std::vector<T> &vec){ os << "["; for (auto v : vec) os << v << ","; os << "]"; return os; }
      template<typename T> std::ostream &operator<<(std::ostream &os, const std::deque<T> &vec){ os << "deque["; for (auto v : vec) os << v << ","; os << "]"; return os; }
      template<typename T> std::ostream &operator<<(std::ostream &os, const std::set<T> &vec){ os << "{"; for (auto v : vec) os << v << ","; os << "}"; return os; }
      template<typename T> std::ostream &operator<<(std::ostream &os, const std::unordered_set<T> &vec){ os << "{"; for (auto v : vec) os << v << ","; os << "}"; return os; }
      template<typename T> std::ostream &operator<<(std::ostream &os, const std::multiset<T> &vec){ os << "{"; for (auto v : vec) os << v << ","; os << "}"; return os; }
      template<typename T> std::ostream &operator<<(std::ostream &os, const std::unordered_multiset<T> &vec){ os << "{"; for (auto v : vec) os << v << ","; os << "}"; return os; }
      template<typename T1, typename T2> std::ostream &operator<<(std::ostream &os, const std::pair<T1, T2> &pa){ os << "(" << pa.first << "," << pa.second << ")"; return os; }
      template<typename TK, typename TV> std::ostream &operator<<(std::ostream &os, const std::map<TK, TV> &mp){ os << "{"; for (auto v : mp) os << v.first << "=>" << v.second << ","; os << "}"; return os; }
      template<typename TK, typename TV> std::ostream &operator<<(std::ostream &os, const std::unordered_map<TK, TV> &mp){ os << "{"; for (auto v : mp) os << v.first << "=>" << v.second << ","; os << "}"; return os; }
    }
    namespace math{
      template<typename T> bool chmax(T &m, const T q) { if (m < q) {m = q; return true;} else return false; }
      template<typename T> bool chmin(T &m, const T q) { if (q < m) {m = q; return true;} else return false; }
      template<typename T1, typename T2> std::pair<T1, T2> operator+(const std::pair<T1, T2> &l, const std::pair<T1, T2> &r) { return std::make_pair(l.first + r.first, l.second + r.second); }
      template<typename T1, typename T2> std::pair<T1, T2> operator-(const std::pair<T1, T2> &l, const std::pair<T1, T2> &r) { return std::make_pair(l.first - r.first, l.second - r.second); }
      inline i64 Bit_i64(i64 x,i32 a){return (((x)>>(a))&((i64)1));}
      inline i32 Bit_i32(i32 x,i32 a){return (((x)>>(a))&((i64)1));}
    }
    namespace others{
      template<typename T> void ndarray(std::vector<T> &vec, int len) { vec.resize(len); }
      template<typename T, typename... Args> void ndarray(std::vector<T> &vec, int len, Args... args) { vec.resize(len); for (auto &v : vec) ndarray(v, args...); }
    }
  }
  namespace strlib{
    template<typename T> bool kaibun(T s);//v1.0 20.03.23
  }
  namespace math{
    template<qweqwe::i32 mod> struct modint;//ver 1.0
  }
}

template<qweqwe::i32 mod>
struct qweqwe::math::modint {
  i64 x;
  modint() : x(0) {}
  modint(i64 n) : x(n){
    if(x>=mod) x %= mod;
    else if(x<0) x = (x%mod + mod) % mod;
  }
  static int GetMod() { return mod; }
  operator i64() const { return x;}
  operator i32() const { return (i32)x;}
  constexpr modint &_setval(i64 v) { x = (v >= mod ? v % mod : v); return *this; }
  constexpr modint operator+(const modint &z) const { return modint()._setval((i64)x + z.x); }
  constexpr modint operator-(const modint &z) const { return modint()._setval((i64)x - z.x + mod); }
  constexpr modint operator*(const modint &z) const { return modint()._setval((i64)x * z.x % mod); }
  constexpr modint operator/(const modint &z) const { return modint()._setval((i64)x * z.inv() % mod); }
  constexpr modint operator-() const { return modint()._setval(mod - x); }
  constexpr modint &operator+=(const modint &z) { return *this = *this + z; }
  constexpr modint &operator-=(const modint &z) { return *this = *this - z; }
  constexpr modint &operator*=(const modint &z) { return *this = *this * z; }
  constexpr modint &operator/=(const modint &z) { return *this = *this / z; }
  static i32 get_primitive_root() {
    static i32 primitive_root = 0;
    if (!primitive_root) {
      primitive_root = [&](){
        std::set<i32> fac;
        i32 v = mod - 1;
        for (i64 i = 2; i * i <= v; i++) while (v % i == 0) fac.insert(i), v /= i;
        if (v > 1) fac.insert(v);
        for (i32 g = 1; g < mod; g++) {
          bool ok = true;
          for (auto i : fac) if (modint(g).power((mod - 1) / i) == 1) { ok = false; break; }
          if (ok) return g;
        }
        return -1;
      }();
    }
    return primitive_root;
  }
  constexpr i64 power(i64 n) const {
    i64 ans = 1, tmp = this->x;
    while (n) {
      if (n & 1) ans = ans * tmp % mod;
      tmp = tmp * tmp % mod;
      n /= 2;
    }
    return ans;
  }
  constexpr i64 inv() const { return this->power(mod - 2); }
  constexpr modint operator^(i64 n) const { return modint(this->power(n)); }
  constexpr modint &operator^=(i64 n) { return *this = *this ^ n; }
  bool operator<(const modint &z) const { return x < z.x; }  // To use std::map<ModInt, T>
  friend std::istream &operator>>(std::istream &is, modint &z) { i64 t; is >> t; z = modint(t); return is; }
  friend std::ostream &operator<<(std::ostream &os, const modint &z) { os << z.x;  return os; }
};


constexpr int mod = 1000000007;
using Edges = vector<int>;

int dfs(vector<Edges> &g, vector<int> &par, vector<int> &siz,int n, int pre) {
	par[n] = pre;
	ll res = 1;
	for (auto nxt : g[n]) {
		if (nxt == pre)continue;
		res += dfs(g,par,siz,nxt, n);
	}
	return siz[n] = res;
}


void solve(){
  using namespace qweqwe::stdplus::iosplus;
  using namespace qweqwe::stdplus::math;
  using namespace qweqwe::math;
  using mint = modint<mod>;
  //using Edge = pair<int,int>;
  //using Edges = vector<Edge>;
  int n;
  cin >> n;
  vector<Edges> g(n); vector<int> dg(n+5),sz(n+5),par(n+5,0);
  FOR(i,0,n-1){
    int a, b;
    cin >> a >> b;
    --a; --b;
    g[a].push_back(b);
    g[b].push_back(a);
    ++dg[a];
    ++dg[b];
  }
  dfs(g, par, sz, 0, 0);
  
  vector<mint> pow2s(n+10); mint tninv(0), one(1), two(2);
  pow2s[0] = one;
  FOR(i,0,n+5) pow2s[i+1] = pow2s[i]*two;
  tninv = pow2s[n].inv();
  
  mint ans(0);
  FOR(i,0,n){
    if(dg[i]==1) continue;
    mint tmp(0);
    for(auto x: g[i]){
      if(x==par[i]) tmp += pow2s[n-sz[i]]-one;
      else tmp += pow2s[sz[x]] - one;
    }
    tmp += one;
    ans += pow2s[n-1] - tmp;
  }
  ans *= tninv;
  cout << ans << endl;
}


 

int main(void){
  qweqwe::stdplus::iosplus::iosFast();
  solve();
  return 0;
}

Measured memory_bytes: 28416