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 Common Lisp (SBCL 1.1.14) (judge verdict: Accepted)

;; F - Surrounded Nodes

(defparameter *modulus* (+ (expt 10 9) 7))
(defparameter *2-inv* (/ (1+ *modulus*) 2)) ; 2^-1 (mod *modulus*)

(defun main ()
  (let* ((N (read))  ; 頂点数
         (tree (read-tree N)))
    (princ (solve N tree))
    (fresh-line)))

(defun solve (N tree)
  (let ((expt-2 (make-array N))
        (parent (make-array N :initial-element nil))
        (subtree-size (make-array N :initial-element nil))
        (sum-expt-2-subtree 0))
    ; 1, 2, 4, 8, ..., 2^(N - 1) をexpt-2に保存
    (loop for i below N for e = 1 then (mod (* e 2) *modulus*)
          do (setf (aref expt-2 i) e))
    (labels
      ((dfs (stack)
         (when stack
           (let* ((v (pop stack))
                  (p (aref parent v)) ; vの親
                  (size (aref subtree-size v))) ; vを根とする部分木の頂点数
             (if (aref subtree-size v)
               ; 帰りがけ
               (when p
                 (incf sum-expt-2-subtree (1- (aref expt-2 size)))
                 (incf sum-expt-2-subtree (1- (aref expt-2 (- N size))))
                 (incf (aref subtree-size p) size))
               ; 行きがけ
               (loop
                 initially (push v stack) ; 帰りがけ用に残す
                           (setf (aref subtree-size v) 1)
                 for next in (aref tree v) ; vの隣接頂点
                 unless (eql next (aref parent v)) ; 親以外
                   do (push next stack)
                      (setf (aref parent next) v))))
           (dfs stack))))
      ; sum-expt-2-subtree (2^(部分木の頂点数) - 1の総和) を計算
      (dfs (list 0))

      (loop repeat (1+ N)
            for e = (+ (* N (1- (aref expt-2 (1- N))))
                       (- *modulus* (mod sum-expt-2-subtree *modulus*)))
                then (mod (* e *2-inv*) *modulus*)
            finally (return e)))))

(defun read-tree (N)
  "N頂点の木をreadして作る. 頂点番号は0〜N-1"
  (let ((tree (make-array N))) ; 隣接リスト
    (loop for i below N do (setf (aref tree i) nil))
    (loop repeat (1- N)
      do (let ((a (read-fixnum))
               (b (read-fixnum)))
           (push (1- b) (aref tree (1- a)))
           (push (1- a) (aref tree (1- b)))))
    tree))

(defun read-fixnum (&optional (in *standard-input*))
  "readより速い非負整数専用read (整数間に空白または改行1個に限る)
   cf. https://qiita.com/sansaqua/items/0b6417cb541047e29da4"
  (loop with acc = 0
        for byte = (read-byte in)
        if (<= 48 byte 57)
          do (setf acc (+ (* acc 10) (- byte 48)))
        else return acc))

(main)