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

namespace ABC149F
{
    class Program
    {
        static void Main(string[] args)
        {
            var N = int.Parse(Console.ReadLine());
            int mod = 1000000007;

            //エッジ一覧
            List<int>[] map = new List<int>[N].Select(x => new List<int>()).ToArray();
            for (int i = 0; i < N - 1; i++)
            {
                var input = ReadInt();
                map[input[0] - 1].Add(input[1] - 1);
                map[input[1] - 1].Add(input[0] - 1);
            }

            //DFS
            firstAccess = new int[N].Select(x => -1).ToArray();
            lastAccess = new int[N];
            DFS(map, 0);

            // 各頂点に関する考察
            long sum = 0;
            for (int i = 0; i < N; i++)
            {
                List<int> counts = new List<int>();

                // 各頂点の行き先
                foreach (var to in map[i])
                {
                    //行き先にある頂点数の算出
                    int count = 0;
                    if (firstAccess[i] < firstAccess[to])
                    {
                        //頂点iより後にアクセスした場合
                        count = (lastAccess[to] - firstAccess[to] + 1) / 2;
                    }
                    else
                    {
                        //頂点iより前の場所の場合
                        count = N - (lastAccess[i] - firstAccess[i] + 1) / 2;
                    }
                    counts.Add(count);
                }

                if (counts.Count > 1)
                {
                    //加算
                    long temp = 0;
                    foreach (var c in counts)
                    {
                        temp += ModPow(2, c, mod);
                        temp %= mod;
                    }
                    sum += (ModPow(2, N - 1, mod) - temp + counts.Count - 1 + mod) % mod;
                    sum %= mod;
                }
            }

            long upper = sum % mod;
            long lower = ModPow(2, N, mod);

            long ans = (upper * ModPow(lower, mod - 2, mod)) % mod;

            Console.WriteLine(ans);
            Console.ReadKey();
        }

        struct Edge
        {
            public int from;
            public int to;
        }

        static int[] firstAccess;
        static int[] lastAccess;
        static int count = 0;
        static void DFS(List<int>[] edges, int edgeNum)
        {
            firstAccess[edgeNum] = count++;

            foreach (var next in edges[edgeNum])
            {
                if (firstAccess[next] != -1) continue;

                DFS(edges, next);
            }

            lastAccess[edgeNum] = count++;
        }



        static int[] ReadInt()
        {
            int[] ret = Console.ReadLine().Split().Select(int.Parse).ToArray();
            return ret;
        }
        static long[] ReadLong()
        {
            long[] ret = Console.ReadLine().Split().Select(long.Parse).ToArray();
            return ret;
        }


        /// <summary>
        /// a^n (mod p)
        /// nが非常に大きい時に有効
        /// </summary>
        /// <param name="a"></param>
        /// <param name="n"></param>
        /// <param name="mod"></param>
        /// <returns></returns>
        public static long ModPow(long a, long n, long p)
        {
            if (n == 0) return 1;
            if (n == 1) return a % p;
            if (n % 2 == 1) return (a * ModPow(a, n - 1, p)) % p;

            long t = ModPow(a, n / 2, p);
            return (t * t) % p;
        }
    }
}


Measured memory_bytes: 58404