#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
const int NMAX = 111111;
int A[NMAX];
int C[NMAX * 4 + 3];
void add(int x, int nl, int nr, int node) {
  C[node]++;
  if (nl != nr) {
    int mid = (nl + nr) / 2;
    if (x <= mid)
      add(x, nl, mid, node * 2);
    else
      add(x, mid + 1, nr, node * 2 + 1);
  }
}
int sum(int l, int r, int nl, int nr, int node) {
  if (l <= nl && nr <= r) return C[node];
  if (r < nl || nr < l) return 0;
  return sum(l, r, nl, (nl + nr) / 2, node * 2) +
         sum(l, r, (nl + nr) / 2 + 1, nr, node * 2 + 1);
}
void padd(long long& x, long long y) {
  x = x + y;
  if (x >= MOD) x -= MOD;
}
struct Node {
  long long c[4][4];
  void off() {
    memset(c, 0, sizeof(c));
    for (int i = 0; i < 4; i++) c[i][i] = 1;
  }
  void on(long long p, long long s) {
    memset(c, 0, sizeof(c));
    for (int i = 0; i < 4; i++) c[i][i] = 1;
    c[0][1] = p;
    c[1][2] = 1;
    c[2][3] = s;
  }
};
void mmerge(Node& node, const Node& nl, const Node& nr) {
  memset(node.c, 0, sizeof(node.c));
  for (int i = 0; i < 4; i++)
    for (int j = 0; j < 4; j++)
      for (int k = 0; k < 4; k++)
        padd(node.c[i][k], nl.c[i][j] * nr.c[j][k] % MOD);
}
struct Solver {
  vector<long long> P, S;
  vector<Node> c;
  int N;
  Solver() {}
  Solver(int n) : P(n + 1), S(n + 1), c(4 * n + 3), N(n) {}
  void init(int nl, int nr, int node) {
    if (nl == nr)
      c[node].on(P[nl], S[nr]);
    else {
      init(nl, (nl + nr) / 2, node * 2);
      init((nl + nr) / 2 + 1, nr, node * 2 + 1);
      mmerge(c[node], c[node * 2], c[node * 2 + 1]);
    }
  }
  void init() { init(1, N, 1); }
  void toggle(int x, int nl, int nr, int node) {
    if (nl == nr) {
      if (c[node].c[1][2])
        c[node].off();
      else
        c[node].on(P[x], S[x]);
    } else {
      int mid = (nl + nr) / 2;
      if (x <= mid)
        toggle(x, nl, mid, node * 2);
      else
        toggle(x, mid + 1, nr, node * 2 + 1);
      mmerge(c[node], c[node * 2], c[node * 2 + 1]);
    }
  }
  void toggle(int x) { toggle(x, 1, N, 1); }
  long long query() { return c[1].c[0][3]; }
};
long long P[NMAX], S[NMAX];
int pIdx[NMAX];
int pAcc[NMAX];
int main() {
  int N;
  scanf("%d", &N);
  for (int i = 1; i <= N; i++) scanf("%d", A + i);
  map<int, int> mp;
  for (int i = 1; i <= N; i++) mp[A[i]] = -1;
  int X = 0;
  for (auto& kv : mp) kv.second = ++X;
  for (int i = 1; i <= N; i++) A[i] = mp[A[i]];
  for (int i = 1; i <= N; i++) {
    P[i] = sum(1, A[i], 1, X, 1);
    add(A[i], 1, X, 1);
  }
  memset(C, 0, sizeof(C));
  for (int i = N; i >= 1; i--) {
    S[i] = sum(1, A[i], 1, X, 1);
    add(A[i], 1, X, 1);
  }
  vector<Solver> solvers(X + 1);
  vector<vector<int>> cands(X + 1);
  long long ans = 0;
  for (int i = 1; i <= N; i++) cands[A[i]].push_back(i);
  for (int i = 1; i <= X; i++)
    if (cands[i].size() >= 3) solvers[i] = Solver(cands[i].size());
  for (int i = 1; i <= N; i++) pIdx[i] = ++pAcc[A[i]];
  for (int i = 1; i <= X; i++)
    if (cands[i].size() >= 3) {
      auto& solver = solvers[i];
      for (int cand : cands[i]) {
        solver.P[pIdx[cand]] = P[cand];
        solver.S[pIdx[cand]] = S[cand];
      }
      solver.init();
      padd(ans, solver.query());
    }
  int M;
  scanf("%d", &M);
  while (M--) {
    int t, x;
    scanf("%d%d", &t, &x);
    if (cands[A[x]].size() < 3) {
      printf("%lld\n", ans);
      continue;
    }
    auto& solver = solvers[A[x]];
    long long cur = solver.query();
    solver.toggle(pIdx[x]);
    long long res = solver.query();
    ans = (ans - cur + res + MOD) % MOD;
    printf("%lld\n", ans);
  }
}
