output_description: Compute the sum of products of simple cycles that have exactly two special
  edges. Print the answer modulo (10^9+7).
  
  * * *
input_description: Input is given from Standard Input in the following format (where L =
  2^{H-1}).
  
      
      
      H
      P_1 P_2 \cdots P_L
attempt: import os
  import sys
  
  import numpy as np
  
  
  def solve(inp):
      def mod_pow(x, a, MOD):
          ret = 1
          cur = x
          while a:
              if a & 1:
                  ret = ret * cur % MOD
              cur = cur * cur % MOD
              a >>= 1
          return ret
  
      h = inp[0]
      ppp = inp[1:]
      n = 1 << (h - 1)
      ppp += n - 1
      MOD = 10**9 + 7
  
      cumprods = np.ones(2 * n, dtype=np.int64)
      cumprods_rev = np.ones(n, dtype=np.int64)
      cumprods_through = np.zeros(n, dtype=np.int64)
      for i in range(2, 2 * n):
          cumprods[i] = cumprods[i >> 1] * i % MOD
      for i in range(n):
          cumprods_rev[i] = mod_pow(cumprods[i], MOD - 2, MOD)
          cumprods_through[i] = cumprods[i + n] * cumprods[ppp[i]] % MOD
  
      cumprods_from_tree1 = np.zeros(2 * n, dtype=np.int64)
      ans = 0
  
      for lca in range(1, n):
          d = lca
          digit = h
          while d:
              d >>= 1
              digit -= 1
  
          leftmost_leaf_in_left_subtree = lca << digit
          leftmost_leaf_in_right_subtree = ((lca << 1) + 1) << (digit - 1)
          rightmost_leaf_in_right_subtree = (lca + 1) << digit
  
          rev = cumprods_rev[lca >> 1]
          for leaf in range(
              leftmost_leaf_in_left_subtree, leftmost_leaf_in_right_subtree
          ):
              v = ppp[leaf - n]
              cp = cumprods_through[leaf - n] * rev % MOD
              while v > 1:
                  cumprods_from_tree1[v] += cp * cumprods_rev[v >> 1] % MOD
                  v >>= 1
  
          rev = cumprods_rev[lca]
          for leaf in range(
              leftmost_leaf_in_right_subtree, rightmost_leaf_in_right_subtree
          ):
              v = ppp[leaf - n]
              cp = cumprods_through[leaf - n] * rev % MOD
              while v > 1:
                  ans += (
                      cumprods_from_tree1[v ^ 1]
                      % MOD
                      * cp
                      % MOD
                      * cumprods_rev[v >> 2]
                      % MOD
                  )
                  v >>= 1
              ans %= MOD
  
          for leaf in range(
              leftmost_leaf_in_left_subtree, leftmost_leaf_in_right_subtree
          ):
              v = ppp[leaf - n]
              while cumprods_from_tree1[v] != 0:
                  cumprods_from_tree1[v] = 0
                  v >>= 1
  
      return ans
  
  
  if sys.argv[-1] == "ONLINE_JUDGE":
      from numba.pycc import CC
  
      cc = CC("my_module")
      cc.export("solve", "(i8[:],)")(solve)
      cc.compile()
      exit()
  
  if os.name == "posix":
      # noinspection PyUnresolvedReferences
      from my_module import solve
  else:
      from numba import njit
  
      solve = njit("(i8[:],)", cache=True)(solve)
      print("compiled", file=sys.stderr)
  
  inp = np.fromstring(sys.stdin.read(), dtype=np.int64, sep=" ")
  ans = solve(inp)
  print(ans)
  
problem_description: 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.
  
  ![graph for sample1](https://img.atcoder.jp/agc047/nice_wide_example.png)
  
  _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.
samples: [{"input": "3\n    2 3 1 4", "output": "121788\n    \n\nThe following drawings show two valid cycles (but there are more!) with\nproducts 2 \\cdot 5 \\cdot 6 \\cdot 3 \\cdot 1 \\cdot 2 \\cdot 5 \\cdot 4 = 7200 and\n1 \\cdot 3 \\cdot 7 \\cdot 7 \\cdot 3 \\cdot 1 \\cdot 2 \\cdot 5 \\cdot 4 \\cdot 2 =\n35280. The third cycle is invalid because it doesn't have exactly two special\nedges.\n\n![three cycles](https://img.atcoder.jp/agc047/3_trees_font.png)\n\n* * *"}, {"input": "2\n    1 2", "output": "36\n    \n\nThe only simple cycle in the graph indeed has two special edges, and the\nproduct of vertices is 1 \\cdot 3 \\cdot 3 \\cdot 1 \\cdot 2 \\cdot 2 = 36.\n\n* * *"}, {"input": "5\n    6 14 15 7 12 16 5 4 11 9 3 10 8 2 13 1", "output": "10199246"}]