#include <bits/stdc++.h>

template<unsigned P>
class modint {
  static_assert(1 <= P, "P must be a positive integer");

  using mint = modint<P>;

protected:
  unsigned v;

public:
  constexpr modint() : v() {}

  template<typename T,
           typename std::enable_if<std::is_integral<T>::value &&
                                       std::is_signed<T>::value,
                                   bool>::type = true>
  constexpr modint(T t_v) : v() {
    long long tmp = t_v % static_cast<long long>(P);
    if (tmp < 0) {
      tmp += P;
    }
    v = tmp;
  }

  template<typename T,
           typename std::enable_if<std::is_integral<T>::value &&
                                       std::is_unsigned<T>::value,
                                   bool>::type = true>
  constexpr modint(T t_v) : v() {
    v = t_v % P;
  }

  constexpr unsigned val() const {
    return v;
  }

  static constexpr unsigned mod() {
    return P;
  }

  static constexpr mint raw(unsigned v) {
    mint res;
    res.v = v;
    return res;
  }

  constexpr mint &operator+=(const mint &rhs) {
    v < P - rhs.v ? v += rhs.v : v -= P - rhs.v;
    return *this;
  }

  constexpr mint &operator++() {
    v + 1 < P ? ++v : v = 0;
    return *this;
  }

  constexpr mint operator++(int) {
    mint tmp = *this;
    v + 1 < P ? ++v : v = 0;
    return tmp;
  }

  constexpr mint &operator-=(const mint &rhs) {
    v < rhs.v ? v += P - rhs.v : v -= rhs.v;
    return *this;
  }

  constexpr mint &operator--() {
    v ? --v : v = P - 1;
    return *this;
  }
  
  constexpr mint operator--(int) {
    mint tmp = *this;
    v ? --v : v = P - 1;
    return tmp;
  }

  constexpr mint operator-() const {
    mint res;
    res.v = v ? P - v : 0;
    return res;
  }

  constexpr mint &operator*=(const mint &rhs) {
    v = static_cast<unsigned long long>(v) * rhs.v % P;
    return *this;
  }

  constexpr mint pow(unsigned long long b) const {
    mint a(*this), s(1);
    for (; b; b >>= 1) {
      if (b & 1) {
        s *= a;
      }
      a *= a;
    }
    return s;
  }

  constexpr mint inv() const {
    return pow(P - 2);
  }

  constexpr friend mint operator+(const mint &lhs, const mint &rhs) {
    return mint(lhs) += rhs;
  }                                                                              
                                                                                 
  constexpr friend mint operator-(const mint &lhs, const mint &rhs) {            
    return mint(lhs) -= rhs;                                                     
  }

  constexpr friend mint operator*(const mint &lhs, const mint &rhs) {
    return mint(lhs) *= rhs;
  }

  constexpr friend bool operator==(const mint &lhs, const mint &rhs) {
    return lhs.v == rhs.v;
  }

  constexpr friend bool operator!=(const mint &lhs, const mint &rhs) {
    return lhs.v != rhs.v;
  }

  friend std::istream &operator>>(std::istream &in, mint &x) {
    return in >> x.v;
  }

  friend std::ostream &operator<<(std::ostream &out, const mint &x) {
    return out << x.v;
  }
};

using mint = modint<1000000007>;

template<class Tp>
class Fenwick {
private:
  int n;
  std::vector<Tp> tree;

public:
  Fenwick(int n) : n(n), tree(n + 1) {}

  void add(int x, Tp y) {
    ++x;
    for (; x <= n; x += x & -x) {
      tree[x] += y;
    }
  }

  Tp query(int x) {
    ++x;
    Tp res{};
    for (; x; x -= x & -x) {
      res += tree[x];
    }
    return res;
  }

  Tp query(int x, int y) {
    return query(y) - query(x - 1);
  }
};

signed main() {
  std::ios::sync_with_stdio(false);
  std::cin.tie(nullptr);

  int h, n;
  std::cin >> h;
  n = 1 << h;

  std::vector<int> a(n);

  for (int i = 1; i < n; ++i) {
    std::cin >> a[i];
  }

  int q;
  std::cin >> q;

  std::vector<std::tuple<int, int, int>> opt(q);
  std::vector<std::vector<int>> opts(n);
  std::vector<int> size(q);
  int sum = 0;

  for (int i = 0; i < q; ++i) {
    auto &[op, x, y] = opt[i];
    std::cin >> op >> x >> y;

    if (op <= 2 && y == 2) {
      sum += op == 1 ? 1 : -1;
    } 

    size[i] = sum;
    opts[x].emplace_back(i);
  }

  Fenwick<int> ds(1000001);
  std::vector<int> b(n), f(n);
  std::vector<std::pair<int, mint>> ans;

  for (int root = 1; root < n; ++root) {
    std::vector<int> S;
    
    auto dfs = [&](auto &self, int p) {
      if (p >= n) {
        return;
      }

      for (auto id : opts[p]) {
        S.emplace_back(id);
      }

      b[p] = a[p];
      self(self, 2 * p);
      self(self, 2 * p + 1);
    };

    dfs(dfs, root);
    std::sort(S.begin(), S.end());

    auto update = [&](int mode) {
      int x = root;

      if (!b[x]) {
        return 0;
      }

      if (mode == 1) {
        b[x] = 0;
      }

      while (2 * x + 1 < n) {
        if (!b[2 * x] && !b[2 * x + 1]) {
          break;
        }

        if (b[2 * x] < b[2 * x + 1]) {
          if (mode == 1) {
            std::swap(b[x], b[2 * x + 1]);
          }

          x = 2 * x + 1;
        } else {
          if (mode == 1) {
            std::swap(b[x], b[2 * x]);
          }

          x = 2 * x;
        }
      }

      return x;
    };

    int x = update(0);

    while (x) {
      f[x] = b[root];
      update(1);
      x = update(0);
    }

    std::multiset<int> max;

    for (auto id : S) {
      auto [op, x, y] = opt[id];

      if (op == 1) {
        if (y == 1) {
          max.insert(f[x]);
        } else {
          ds.add(f[x], 1);
        }
      }

      if (op == 2) {
        if (y == 1) {
          max.erase(max.find(f[x]));
        } else {
          ds.add(f[x], -1);
        }
      }

      if (op == 3) {
        if (x != root) {
          continue;
        }

        int nmax = max.empty() ? 0 : *max.rbegin();
        mint res = 1;

        if (nmax > y) {
          res = 0;
        } else {
          if (nmax == y) {
            res = mint(2).pow(ds.query(y));
          } else {
            res = mint(2).pow(ds.query(y - 1)) * (mint(2).pow(ds.query(y, y)) - 1); 
          }
        }

        ans.emplace_back(id, res * mint(2).pow(size[id] - ds.query(1000000)));
      }
    }

    for (auto id : S) {
      auto [op, x, y] = opt[id];

      if (op == 1 && y == 2) {
        ds.add(f[x], -1);
      }

      if (op == 2 && y == 2) {
        ds.add(f[x], 1);
      }
    }
  }

  std::sort(ans.begin(), ans.end(), [&](const auto &x, const auto &y) {
    return x.first < y.first;
  });

  for (auto [_, x] : ans) {
    std::cout << x << '\n';
  }
}