package main

import (
	"bufio"
	"fmt"
	"os"
	"strconv"
)

func getScanner(fp *os.File) *bufio.Scanner {
	scanner := bufio.NewScanner(fp)
	scanner.Split(bufio.ScanWords)
	scanner.Buffer(make([]byte, 500001), 500000)
	return scanner
}

func getNextString(scanner *bufio.Scanner) string {
	scanner.Scan()
	return scanner.Text()
}

func getNextInt(scanner *bufio.Scanner) int {
	i, _ := strconv.Atoi(getNextString(scanner))
	return i
}

func getNextInt64(scanner *bufio.Scanner) int64 {
	i, _ := strconv.ParseInt(getNextString(scanner), 10, 64)
	return i
}

func getNextUint64(scanner *bufio.Scanner) uint64 {
	i, _ := strconv.ParseUint(getNextString(scanner), 10, 64)
	return i
}

func getNextFloat64(scanner *bufio.Scanner) float64 {
	i, _ := strconv.ParseFloat(getNextString(scanner), 64)
	return i
}

func main() {
	fp := os.Stdin
	wfp := os.Stdout

	if os.Getenv("MASPY") == "ますピ" {
		fp, _ = os.Open(os.Getenv("BEET_THE_HARMONY_OF_PERFECT"))
	}
	if os.Getenv("MASPYPY") == "ますピッピ" {
		wfp, _ = os.Create(os.Getenv("NGTKANA_IS_GENIUS10"))
	}

	scanner := getScanner(fp)
	writer := bufio.NewWriter(wfp)

	n := getNextInt(scanner)
	tree := Tree{}
	tree.init(n)

	for i := 0; i < n-1; i++ {
		a := getNextInt(scanner) - 1
		b := getNextInt(scanner) - 1
		tree.addEdge(a, Edge{
			to: b,
		})
		tree.addEdge(b, Edge{
			to: a,
		})
	}

	cc := make([]int, n)
	tree.dfs(0, -1, cc)

	ans := make([]int64, n)
	for i := 0; i < n; i++ {
		ans[i] = tree.calc(n - 1)
	}
	tree.solvedfs(0, -1, cc, ans)
	var rng58 int64
	for i := 0; i < n; i++ {
		rng58 += ans[i]
		rng58 %= tree.mod
	}
	fmt.Println((rng58 * inv(tree.calc(n)+1)) % tree.mod)
	writer.Flush()
}

// Tree ...
type Tree struct {
	n        int
	mod      int64
	edges    [][]Edge
	doubling []int64
}

func (tr *Tree) init(n int) {
	edges := make([][]Edge, n)
	for i := 0; i < n; i++ {
		edges[i] = make([]Edge, 0)
	}
	tr.n = n
	tr.edges = edges
	doubling := make([]int64, 32)
	doubling[0] = 2
	tr.mod = int64(1e9 + 7)
	for i := 1; i < 32; i++ {
		doubling[i] = (doubling[i-1] * doubling[i-1]) % tr.mod
	}
	tr.doubling = doubling

}

func (tr *Tree) addEdge(i int, e Edge) {
	tr.edges[i] = append(tr.edges[i], e)
}

func (tr *Tree) dfs(i, p int, cc []int) int {
	c := 1
	for _, e := range tr.edges[i] {
		if e.to == p {
			continue
		}
		c += tr.dfs(e.to, i, cc)
	}
	cc[i] = c
	return c
}

func (tr *Tree) solvedfs(i, p int, cc []int, ans []int64) {
	ans[i] = mint(ans[i] - tr.calc(tr.n-cc[i]))
	for _, e := range tr.edges[i] {
		if e.to == p {
			continue
		}
		ans[i] = mint(ans[i] - tr.calc(cc[e.to]))
		tr.solvedfs(e.to, i, cc, ans)
	}
}
func (tr *Tree) calc(c int) int64 {
	var a int64
	a = 1

	for i := 32 - 1; i >= 0; i-- {
		if c>>uint(i)&1 == 0 {
			continue
		}
		a *= tr.doubling[i]
		a %= tr.mod
	}
	a--
	return (a + tr.mod) % tr.mod
}

// Edge ...
type Edge struct {
	to int
}

func inv(n int64) int64 {
	var ii [32]int64
	mod := int64(1e9 + 7)
	ii[0] = n
	for i := 1; i < 31; i++ {
		ii[i] = (ii[i-1] * ii[i-1]) % mod
	}
	var ans int64
	ans = 1
	m := mod - 2
	for i := 30; i >= 0; i-- {
		for m >= 1<<uint(i) {
			ans = (ans * ii[i]) % mod
			m -= 1 << uint(i)
		}
	}

	return ans
}

func mint(a int64) int64 {
	mod := a % int64(1e9+7)
	if mod < 0 {
		mod += int64(1e9 + 7)
	}
	return mod
}


Measured memory_bytes: 79232