Problem:
Score : 1000 points

Problem Statement

Inspired by the tv series Stranger Things, bear Limak is going for a walk between two mirror worlds.

There are two perfect binary trees of height H,
each with the standard numeration of vertices from 1 to 2^H-1.
The root is 1 and the children of x are 2 \cdot x and 2 \cdot x + 1.

Let L denote the number of leaves in a single tree, L = 2^{H-1}.

You are given a permutation P_1, P_2, \ldots, P_L of numbers 1 through L.
It describes L special edges that connect leaves of the two trees.
There is a special edge between vertex L+i-1 in the first tree and vertex L+P_i-1 in the second tree.

drawing for the first sample test, permutation P = (2, 3, 1, 4), special edges in green

Let's define product of a cycle as the product of numbers in its vertices.
Compute the sum of products of all simple cycles that have exactly two special edges, modulo (10^9+7).

A simple cycle is a cycle of length at least 3, without repeated vertices or edges.

Constraints

2 \leq H \leq 18

1 \leq P_i \leq L where L = 2^{H-1}

P_i \neq P_j (so this is a permutation)

Input

Input is given from Standard Input in the following format (where L = 2^{H-1}).

H
P_1 P_2 \cdots P_L

Output

Compute the sum of products of simple cycles that have exactly two special edges.
Print the answer modulo (10^9+7).

Sample Input 1

3
2 3 1 4

Sample Output 1

121788

The following drawings show two valid cycles (but there are more!) with products
2 \cdot 5 \cdot 6 \cdot 3 \cdot 1 \cdot 2 \cdot 5 \cdot 4 = 7200
and 1 \cdot 3 \cdot 7 \cdot 7 \cdot 3 \cdot 1 \cdot 2 \cdot 5 \cdot 4 \cdot 2 = 35280.
The third cycle is invalid because it doesn't have exactly two special edges.

Sample Input 2

2
1 2

Sample Output 2

36

The only simple cycle in the graph indeed has two special edges, and the product of vertices is
1 \cdot 3 \cdot 3 \cdot 1 \cdot 2 \cdot 2 = 36.

Sample Input 3

5
6 14 15 7 12 16 5 4 11 9 3 10 8 2 13 1

Sample Output 3

10199246

Solution in Rust (1.42.0) (judge verdict: Time Limit Exceeded)

use proconio::input;

const MOD:i64 = 1_000_000_007;

enum Tree {
    Node {
        left:Box<Tree>,
        right:Box<Tree>,
        val:i64
    },
    Leaf
}

use Tree::{Node,Leaf};

impl Tree {

    fn add_impl(&mut self,v:usize,l:usize,r:usize,vtar:usize,x:i64) -> i64{
        match self {
            Leaf => {
                *self = Node {
                    left: Box::new(Leaf),
                    right: Box::new(Leaf),
                    val:0
                };
            }
            _ => {}
        };
        if r-l==1 {
            if let Node{left:_,right:_,val} = self {
                *val = (*val + x*v as i64)%MOD;
            }
            (x*v as i64)%MOD
        }
        else {
            let tmp = {
                if let Node{left,right,val:_} = self {
                    let mid = (l+r)/2;
                    if vtar<mid {
                        left.add_impl(v*2,l,mid,vtar,x)
                    }
                    else {
                        right.add_impl(v*2+1,mid,r,vtar,x)
                    }
                }
                else {
                    panic!()
                }
            };
            if let Node{left:_,right:_,val} = self {                
                *val = (*val + tmp*v as i64)%MOD;
            };
            (tmp*v as i64)%MOD
        }
    }

    fn add(&mut self,h:usize,vtar:usize,x:i64) {
        self.add_impl(1,0,1<<(h-1),vtar,x);
    }

    fn dfs_impl(&self,i:usize,dep:usize,l:usize,r:usize,xs:&Vec<i64>) -> i64{
        match self{
            Node{left,right,val} => {
                if i<l {
                    val*xs[dep]%MOD
                }
                else if r<=i+1 {
                    0
                }
                else {
                    let mid = (l+r)/2;
                    let ansl = if mid>i+1 {left.dfs_impl(i,dep+1,l,mid,xs)} else {0};
                    let ansr = right.dfs_impl(i,dep+1,mid,r,xs);
                    (ansl+ansr)%MOD
                }
            }
            Leaf => 0
        }
    }
    fn dfs(&self,i:usize,h:usize,xs:&Vec<i64>) -> i64 {
        self.dfs_impl(i,0,0,1<<(h-1),xs)
    }

    
}

fn main() {
    input! {
        h:usize,
        p:[usize;1<<(h-1)]
    };


    let mut tr = Vec::new();
    for _ in 0..(1<<h) {
        tr.push(Leaf)
    }


    let l = 1<<(h-1);

    for i in 0..l {
        let y = l+p[i]-1;
        let mut z = y;
        let mut r = 1;
        while z>1 {
            r=(r*z as i64)%MOD;
            tr[z].add(h,i,r);
            z/=2;
        }
    }

    let mut ans = 0;
    for i in 0..l {
        let x = l+i;
        let y = l+p[i]-1;

        let xs = {
            let mut xs = vec![0;h+1];
            xs[h] = x as i64;
            let mut x= x;
            for i in (1..h).rev() {
                x/=2;
                xs[i] = xs[i+1]*x as i64%MOD;
            }
            xs
        };

        let mut z = y;
        let mut r = y as i64;
         while z>1 {
            let par = z/2;
            r=(r*par as i64)%MOD;
            let sc = r*tr[z^1].dfs(i,h,&xs);
            ans = (ans+sc)%MOD;
            z = par;
        }
    }

    println!("{}",ans);

}