#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 5;
const int maxk = 80;
const int mod = 1e9 + 7;
int node1[maxn * maxk], node2[maxn * maxk], ls[maxn * maxk], rs[maxn * maxk],
    t[maxn][2], tot;
int bit[maxn], n, m, a[maxn], b[maxn], c[maxn][2], sz[maxn * maxk];
struct cube {
  int a, b, c;
  cube(int a, int b, int c) : a(a), b(b), c(c) {}
};
void inc(int &a, int b) {
  a += b;
  if (a >= mod)
    a -= mod;
  else if (a < 0)
    a += mod;
}
void ins(int &rt, int l, int r, int p) {
  if (rt == 0) {
    rt = ++tot;
    node1[rt] = node2[rt] = ls[rt] = rs[rt] = 0;
    sz[rt] = 0;
  }
  if (l == r) return;
  int m = (l + r) >> 1;
  if (p <= m)
    ins(ls[rt], l, m, p);
  else
    ins(rs[rt], m + 1, r, p);
}
void modify(int rt, int c, int d) {
  if (!rt) return;
  node1[rt] = c;
  sz[rt] += d;
}
void pushup(int rt, int k) {
  node1[rt] = (node1[ls[rt]] + node1[rs[rt]]) % mod;
  if (k == 0)
    node2[rt] = (node2[ls[rt]] + (long long)node1[ls[rt]] * sz[rs[rt]] +
                 node2[rs[rt]]) %
                mod;
  else
    node2[rt] = (node2[ls[rt]] + node2[rs[rt]] +
                 (long long)node1[rs[rt]] * sz[ls[rt]]) %
                mod;
  sz[rt] = sz[ls[rt]] + sz[rs[rt]];
}
void update(int rt, int l, int r, int p, int c, int d, int k) {
  if (!rt) return;
  if (l == r) {
    modify(rt, c, d);
    return;
  }
  int m = (l + r) >> 1;
  if (p <= m)
    update(ls[rt], l, m, p, c, d, k);
  else
    update(rs[rt], m + 1, r, p, c, d, k);
  pushup(rt, k);
}
int query1(int rt, int l, int r, int x, int y) {
  if (!rt || x > y) return 0;
  if (x <= l && r <= y) return node1[rt];
  int m = (l + r) >> 1, ret = 0;
  if (x <= m) inc(ret, query1(ls[rt], l, m, x, y));
  if (m < y) inc(ret, query1(rs[rt], m + 1, r, x, y));
  return ret;
}
cube query2(int rt, int l, int r, int x, int y, int k) {
  if (!rt || x > y) return cube(0, 0, 0);
  if (x <= l && r <= y) return cube(node2[rt], node1[rt], sz[rt]);
  int m = (l + r) >> 1;
  cube p1(0, 0, 0), p2(0, 0, 0);
  if (x <= m) p1 = query2(ls[rt], l, m, x, y, k);
  if (m < y) p2 = query2(rs[rt], m + 1, r, x, y, k);
  if (k == 0)
    return cube((p1.a + (long long)p1.b * p2.c + p2.a) % mod, p1.b + p2.b,
                p1.c + p2.c);
  return cube((p1.a + p2.a + (long long)p2.b * p1.c) % mod, p1.b + p2.b,
              p1.c + p2.c);
}
void add(int i, int v) {
  while (i <= m) {
    bit[i] += v;
    i += i & -i;
  }
}
int sum(int i) {
  int ret = 0;
  while (i) {
    ret += bit[i];
    i -= i & -i;
  }
  return ret;
}
int main() {
  tot = 0;
  scanf("%d", &n);
  for (int i = 1; i <= n; ++i) {
    scanf("%d", &a[i]);
    b[i] = a[i];
  }
  sort(b + 1, b + n + 1);
  m = unique(b + 1, b + n + 1) - b - 1;
  int ans = 0;
  for (int i = 1; i <= n; ++i) a[i] = lower_bound(b + 1, b + m + 1, a[i]) - b;
  for (int i = 1; i <= n; ++i) {
    int v = a[i];
    c[i][0] = sum(v);
    ins(t[v][0], 1, n, i);
    update(t[v][0], 1, n, i, c[i][0], 1, 0);
    add(v, 1);
  }
  memset(bit, 0, sizeof(bit));
  for (int i = n; i > 0; --i) {
    int v = a[i];
    c[i][1] = sum(v);
    ins(t[v][1], 1, n, i);
    update(t[v][1], 1, n, i, c[i][1], 1, 1);
    add(v, 1);
    inc(ans, (long long)query1(t[v][0], 1, n, 1, i - 1) *
                 query1(t[v][1], 1, n, i + 1, n) % mod);
  }
  int q;
  scanf("%d", &q);
  while (q--) {
    int type, p;
    scanf("%d%d", &type, &p);
    int v = a[p];
    if (type == 1) {
      inc(ans, -(long long)query1(t[v][0], 1, n, 1, p - 1) *
                   query1(t[v][1], 1, n, p + 1, n) % mod);
      inc(ans,
          -(long long)c[p][0] * query2(t[v][1], 1, n, p + 1, n, 1).a % mod);
      inc(ans,
          -(long long)c[p][1] * query2(t[v][0], 1, n, 1, p - 1, 0).a % mod);
      update(t[v][0], 1, n, p, 0, -1, 0);
      update(t[v][1], 1, n, p, 0, -1, 1);
    } else {
      update(t[v][0], 1, n, p, c[p][0], 1, 0);
      update(t[v][1], 1, n, p, c[p][1], 1, 1);
      inc(ans, (long long)query1(t[v][0], 1, n, 1, p - 1) *
                   query1(t[v][1], 1, n, p + 1, n) % mod);
      inc(ans, (long long)c[p][0] * query2(t[v][1], 1, n, p + 1, n, 1).a % mod);
      inc(ans, (long long)c[p][1] * query2(t[v][0], 1, n, 1, p - 1, 0).a % mod);
    }
    printf("%d\n", ans);
  }
  return 0;
}
