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 C# (Mono 4.6.2.0) (judge verdict: Time Limit Exceeded)

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;

namespace Surrounded_Nodes
{
    class Program
    {
        private const long MOD = 1000000007;
        private const long Z_VALUE = 500000004;

        class LongClass
        {
            public long? LongValue = null;
        }

        class Node : SortedList<int, LongClass>
        {
            public long? _value { get; private set; } = null;
            private SortedList<int, Node> _parent = null;
            private int _myNode = 0;
            public Node(int myNode, SortedList<int, Node> parent)
            {
                _parent = parent;
                _myNode = myNode;
            }
            public void AddNode(int node)
            {
                this.Add(node, new LongClass());
            }

            public void SetZValue()
            {

                foreach (var child in this)
                {
                    child.Value.LongValue = _parent[child.Key].GetZValue(_myNode);
                }
            }

            public long GetZValue(int direction)
            {
                long value = Z_VALUE;
                foreach (var child in this)
                {
                    if (child.Key == direction)
                    {
                        continue;
                    }
                    else
                    {
                        long tmp = 0;
                        if (!child.Value.LongValue.HasValue)
                        {
                            child.Value.LongValue = _parent[child.Key].GetZValue(_myNode);
                        }
                        value = (value * child.Value.LongValue.Value) % MOD;
                    }
                }
                return value;
            }

            public long GetExpectedValue()
            {
                long value = 1;
                if (this.Count < 2)
                {
                    return 0;
                }
                else if(this.Count == 2)
                {
                    foreach (var item in this)
                    {
                        var tmp = MOD + 1 - item.Value.LongValue.Value;
                        value = (value * tmp) % MOD;
                    }
                }
                else 
                {
                    foreach(var item in this)
                    {
                        value = (value * item.Value.LongValue.Value) % MOD;
                    }
                    var org = value;
                    foreach (var item in this)
                    {
                        var inv = modinv(item.Value.LongValue.Value, MOD);
                        var tmp = (org * inv) % MOD;
                        tmp = (tmp * (MOD + 1 - item.Value.LongValue.Value)) % MOD;
                        value = (value + tmp) % MOD;
                    }
                    value = MOD + 1 - value;
                }
                value = (Z_VALUE * value) % MOD;
                return value;
            }

            static long modinv(long a, long m)
            {
                long b = m, u = 1, v = 0;
                while (b != 0)
                {
                    long t = a / b;
                    a -= t * b;
                    Swap(ref a, ref b);
                    u -= t * v;
                    Swap(ref u, ref v);
                }
                u %= m;
                if (u < 0)
                {
                    u += m;
                }
                return u;
            }

            static void Swap<T>(ref T lhs, ref T rhs)
            {
                T temp;
                temp = lhs;
                lhs = rhs;
                rhs = temp;
            }
        }
        static void Main(string[] args)
        {
            var nodeList = new SortedList<int, Node>();
            var _N = int.Parse(Console.ReadLine());
            for(var i = 1; i <= _N; i++)
            {
                nodeList.Add(i, new Node(i, nodeList));
            }

            for(long i = 0; i < _N - 1; i++)
            {
                var input = Console.ReadLine().Split().Select(x => int.Parse(x)).ToArray();
                nodeList[input[0]].AddNode(input[1]);
                nodeList[input[1]].AddNode(input[0]);
            }
            foreach(var item in nodeList)
            {
                item.Value.SetZValue();
            }

            long value = 0;
            foreach(var item in nodeList)
            {
                var tmp = item.Value.GetExpectedValue();
                value = (value + tmp) % MOD;
            }
            Console.WriteLine(value);
        }
    }
}