Problem:
Score : 600 points

Problem Statement

Given is a tree T with N vertices. The i-th edge connects Vertex A_i and B_i (1 \leq A_i,B_i \leq N).

Now, each vertex is painted black with probability 1/2 and white with probability 1/2, which is chosen independently from other vertices. Then, let S be the smallest subtree (connected subgraph) of T containing all the vertices painted black. (If no vertex is painted black, S is the empty graph.)

Let the holeyness of S be the number of white vertices contained in S. Find the expected holeyness of S.

Since the answer is a rational number, we ask you to print it \bmod 10^9+7, as described in Notes.

Notes

When you print a rational number, first write it as a fraction \frac{y}{x}, where x, y are integers, and x is not divisible by 10^9 + 7
(under the constraints of the problem, such representation is always possible).

Then, you need to print the only integer z between 0 and 10^9 + 6, inclusive, that satisfies xz \equiv y \pmod{10^9 + 7}.

Constraints

2 \leq N \leq 2 \times 10^5

1 \leq A_i,B_i \leq N

The given graph is a tree.

Input

Input is given from Standard Input in the following format:

N
A_1 B_1
:
A_{N-1} B_{N-1}

Output

Print the expected holeyness of S, \bmod 10^9+7.

Sample Input 1

3
1 2
2 3

Sample Output 1

125000001

If the vertices 1, 2, 3 are painted black, white, black, respectively, the holeyness of S is 1.

Otherwise, the holeyness is 0, so the expected holeyness is 1/8.

Since 8 \times 125000001 \equiv 1 \pmod{10^9+7}, we should print 125000001.

Sample Input 2

4
1 2
2 3
3 4

Sample Output 2

375000003

The expected holeyness is 3/8.

Since 8 \times 375000003 \equiv 3 \pmod{10^9+7}, we should print 375000003.

Sample Input 3

4
1 2
1 3
1 4

Sample Output 3

250000002

The expected holeyness is 1/4.

Sample Input 4

7
4 7
3 1
2 6
5 2
7 1
2 7

Sample Output 4

570312505

Solution in Python (3.4.3) (judge verdict: Time Limit Exceeded)

import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,copy,functools
import time,random

sys.setrecursionlimit(10**7)
inf = 10**20
eps = 1.0 / 10**10
mod = 10**9+7
dd = [(-1,0),(0,1),(1,0),(0,-1)]
ddn = [(-1,0),(-1,1),(0,1),(1,1),(1,0),(1,-1),(0,-1),(-1,-1)]

def LI(): return list(map(int, sys.stdin.readline().split()))
def LLI(): return [list(map(int, l.split())) for l in sys.stdin.readlines()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def S(): return input()
def pf(s): return print(s, flush=True)
def pe(s): return print(str(s), file=sys.stderr)
def JA(a, sep): return sep.join(map(str, a))
def JAA(a, s, t): return s.join(t.join(map(str, b)) for b in a)


def MF(n,d): return ModFraction(n,d)

class ModFraction():
    def __init__(self, n, d):
        self.n = n
        self.d = d

    def __add__(self, x):
        xf = ModFraction.xf(x)
        a = self.n * xf.d % mod
        b = xf.n * self.d % mod
        c = self.d * xf.d % mod
        return ModFraction((a+b) % mod, c)

    def __sub__(self, x):
        xf = ModFraction.xf(x)
        a = self.n * xf.d % mod
        b = -xf.n * self.d % mod
        c = self.d * xf.d % mod
        return ModFraction((a+b) % mod, c)

    def __mul__(self, x):
        xf = ModFraction.xf(x)
        a = self.n * xf.n % mod
        b = self.d * xf.d % mod
        return ModFraction(a, b)

    def __truediv__(self, x):
        xf = ModFraction.xf(x)
        a = self.n * xf.d % mod
        b = self.d * xf.n % mod
        return ModFraction(a, b)

    @classmethod
    def xf(cls, x):
        if isinstance(x, int):
            return ModFraction(x, 1)
        return x

    @classmethod
    def inv(cls, x):
        return pow(x, mod - 2, mod)

    def int(self):
        return self.n * ModFraction.inv(self.d) % mod

    def __str__(self):
        return "{} / {}".format(self.n, self.d)


def main():
    n = I()
    ab = [LI_() for _ in range(n-1)]
    e = collections.defaultdict(list)
    for a,b in ab:
        e[a].append(b)
        e[b].append(a)

    m = {}
    def f(i,p):
        k = (i,p)
        if k in m:
            return m[k]
        r = 1
        for c in e[i]:
            if c == p:
                continue
            r += f(c,i)
        m[k] = r
        m[(p,i)] = n - r
        return r

    pw = [1]
    for i in range(n):
        pw.append(pw[-1]*2%mod)

    r = 0
    for i in range(n):
        cs = []
        for c in e[i]:
            cs.append(f(c,i))
        t = sum(cs)
        for i in range(len(cs)-1):
            t -= cs[i]
            k = pw[cs[i]] - 1
            l = pw[t] - 1
            r += k * l % mod
            r %= mod

    rf = MF(r, pw[n])

    return rf.int()


print(main())