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 Rust (1.15.1) (judge verdict: Accepted)

// This code is generated by [cargo-atcoder](https://github.com/tanakh/cargo-atcoder)
// Original source code:
/*
use proconio::marker::Usize1;
use proconio::{fastout, input};

type Graph = Vec<Vec<usize>>;

const MO: u64 = 1_000_000_007;
const INV2: u64 = MO - MO / 2;

fn powmod(x: u64, e: u64) -> u64 {
    let mut x = x;
    let mut v = 1;
    let mut e = e;
    while e > 0 {
        if e % 2 == 1 {
            v = (v * x) % MO;
        }
        x = (x * x) % MO;
        e /= 2;
    }
    v % MO
}

fn dfs(g: &Graph, u: usize, sz: &mut Vec<usize>, p: usize) -> usize {
    sz[u] = 1 + g[u]
        .iter()
        .filter(|&v| *v != p)
        .map(|v| dfs(g, *v, sz, u))
        .sum::<usize>();
    sz[u]
}

fn dfs_calc(g: &Graph, u: usize, sz: &[usize], p: usize) -> u64 {
    g[u].iter()
        .filter(|&v| *v != p)
        .map(|v| {
            let us = (MO + 1 - powmod(INV2, sz[*v] as u64))
                * (MO + 1 - powmod(INV2, (g.len() - sz[*v]) as u64))
                % MO;
            let vs = dfs_calc(g, *v, sz, u);
            us + vs
        })
        .sum::<u64>()
        % MO
}

#[fastout]
fn main() {
    input! {
        n: usize,
        es: [(Usize1, Usize1); n - 1],
    }

    let mut g: Graph = vec![vec![]; n];
    for (u, v) in es {
        g[u].push(v);
        g[v].push(u);
    }
    let mut sz = vec![0; n];
    dfs(&g, 0, &mut sz, 0);
    let ss = dfs_calc(&g, 0, &sz, 0);
    println!(
        "{}",
        (ss + MO + 1 - (n as u64) * INV2 % MO + MO - powmod(INV2, n as u64)) % MO
    )
}

*/

fn main() {
    let exe = "./binXXXXXX";
    std::io::Write::write_all(&mut std::fs::File::create(exe).unwrap(), &decode(BIN)).unwrap();
    std::fs::set_permissions(exe, std::os::unix::fs::PermissionsExt::from_mode(0o755)).unwrap();
    std::process::exit(std::process::Command::new(exe).status().unwrap().code().unwrap())
}

fn decode(v: &str) -> Vec<u8> {
    let mut ret = vec![];
    let mut buf = 0;
    let mut tbl = vec![64; 256];
    for i in 0..64 { tbl[TBL[i] as usize] = i as u8; }
    for (i, c) in v.bytes().filter_map(|c| { let c = tbl[c as usize]; if c < 64 { Some(c) } else { None } }).enumerate() {
        match i % 4 {
            0 => buf = c << 2,
            1 => { ret.push(buf | c >> 4); buf = c << 4; }
            2 => { ret.push(buf | c >> 2); buf = c << 6; }
            3 => ret.push(buf | c),
            _ => unreachable!(),
        }
    }
    ret
}

const TBL: &'static [u8] = b"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
const BIN: &'static str = "<base64-encoded ELF executable removed>";