#include <bits/stdc++.h>
using namespace std;
struct node {
  int size;
  long long v1, v2, s1, s2;
};
vector<node> f[100001];
vector<long long> s[100001];
vector<int> e[100001];
int n, a[100001], w[100001], t[100001];
long long o[100001], p[100001];
struct nodes {
  int pos, value;
  bool operator<(const nodes& A) const {
    if (value != A.value) return value < A.value;
    return pos < A.pos;
  }
} c[100001];
const int P = 1000000007;
inline void insert(int idx, int now, int n, int x) {
  for (; now <= n; now += now & (-now)) s[idx][now] += x;
}
long long calc(int idx, int now, int n) {
  long long value = 0;
  for (; now; now -= now & (-now)) value += s[idx][now], value %= P;
  return value;
}
inline void update(int idx, int k) {
  f[idx][k].s1 = (f[idx][k + k].s1 + f[idx][k + k + 1].s1) % P;
  f[idx][k].s2 = (f[idx][k + k].s2 + f[idx][k + k + 1].s2) % P;
  f[idx][k].size = f[idx][k + k].size + f[idx][k + k + 1].size;
  f[idx][k].v1 = (f[idx][k + k].v1 + f[idx][k + k + 1].v1 +
                  f[idx][k + k].s1 * f[idx][k + k + 1].size) %
                 P;
  f[idx][k].v2 = (f[idx][k + k].v2 + f[idx][k + k + 1].v2 +
                  f[idx][k + k + 1].s2 * f[idx][k + k].size) %
                 P;
}
inline void buildtree(int idx, int k, int Left, int Right) {
  if (Left == Right) {
    f[idx][k].v1 = f[idx][k].s1 = o[e[idx][Left - 1]];
    f[idx][k].v2 = f[idx][k].s2 = p[e[idx][Left - 1]];
    f[idx][k].size = 1;
    return;
  }
  int i = (Left + Right) >> 1;
  buildtree(idx, k + k, Left, i);
  buildtree(idx, k + k + 1, i + 1, Right);
  update(idx, k);
}
node updates(node k1, node k2) {
  node will;
  will.s1 = (k1.s1 + k2.s1) % P;
  will.s2 = (k1.s2 + k2.s2) % P;
  will.size = k1.size + k2.size;
  will.v1 = (k2.v1 + k1.s1 * k2.size + k1.v1) % P;
  will.v2 = (k1.v2 + k2.s2 * k1.size + k2.v2) % P;
  return will;
}
node calcss(int idx, int k, int Left, int Right, int s, int t) {
  if (s > t) {
    node A;
    A.size = A.v1 = A.v2 = A.s1 = A.s2 = 0;
    return A;
  }
  if (Left == s && Right == t) return f[idx][k];
  int i = (Left + Right) >> 1;
  if (t <= i)
    return calcss(idx, k + k, Left, i, s, t);
  else if (s > i)
    return calcss(idx, k + k + 1, i + 1, Right, s, t);
  else
    return updates(calcss(idx, k + k, Left, i, s, i),
                   calcss(idx, k + k + 1, i + 1, Right, i + 1, t));
}
void oprs(int idx, int k, int Left, int Right, int x, int type) {
  if (Left == Right) {
    if (type == 1) {
      f[idx][k].v1 = f[idx][k].s1 = 0;
      f[idx][k].v2 = f[idx][k].s2 = 0;
      f[idx][k].size = 0;
    } else {
      f[idx][k].v1 = f[idx][k].s1 = o[e[idx][Left - 1]];
      f[idx][k].v2 = f[idx][k].s2 = p[e[idx][Left - 1]];
      f[idx][k].size = 1;
    }
    return;
  }
  int i = (Left + Right) >> 1;
  if (x <= i)
    oprs(idx, k + k, Left, i, x, type);
  else
    oprs(idx, k + k + 1, i + 1, Right, x, type);
  update(idx, k);
}
int main() {
  scanf("%d", &n);
  for (int i = 1; i <= n; i++)
    scanf("%d", &a[i]), c[i].pos = i, c[i].value = a[i];
  sort(c + 1, c + n + 1);
  int cnt = 0;
  for (int i = 1; i <= n; i++) {
    if (i == 1 || c[i].value != c[i - 1].value) e[++cnt].clear();
    e[cnt].push_back(c[i].pos);
    w[c[i].pos] = cnt;
    t[c[i].pos] = e[cnt].size();
  }
  e[0].clear();
  s[0].clear();
  s[0].push_back(0);
  for (int i = 1; i <= n; i++) s[0].push_back(0);
  for (int i = 1; i <= n; i++) {
    o[i] = calc(0, w[i], n);
    insert(0, w[i], n, 1);
  }
  for (int i = 1; i <= n; i++) insert(0, w[i], n, -1);
  for (int i = n; i; i--) {
    p[i] = calc(0, w[i], n);
    insert(0, w[i], n, 1);
  }
  node A;
  A.size = A.v1 = A.v2 = A.s1 = A.s2 = 0;
  long long ans = 0;
  for (int i = 1; i <= cnt; i++) {
    s[i].clear();
    for (int j = 0; j <= 4 * e[i].size(); j++) f[i].push_back(A);
    buildtree(i, 1, 1, e[i].size());
    for (int j = 1; j <= e[i].size(); j++)
      ans += calcss(i, 1, 1, e[i].size(), 1, j - 1).s1 *
             calcss(i, 1, 1, e[i].size(), j + 1, e[i].size()).s2 % P,
          ans %= P;
  }
  int m;
  scanf("%d", &m);
  for (; m--;) {
    int x, y;
    scanf("%d%d", &x, &y);
    if (x == 1) {
      int idx = w[y], shy = t[y];
      oprs(idx, 1, 1, e[idx].size(), shy, x);
      ans -= calcss(idx, 1, 1, e[idx].size(), 1, shy - 1).s1 *
             calcss(idx, 1, 1, e[idx].size(), shy + 1, e[idx].size()).s2 % P;
      if (ans < 0) ans += P;
      ans -= o[y] *
             (calcss(idx, 1, 1, e[idx].size(), shy + 1, e[idx].size()).v2 -
              calcss(idx, 1, 1, e[idx].size(), shy + 1, e[idx].size()).s2 + P) %
             P;
      if (ans < 0) ans += P;
      ans -= p[y] *
             (calcss(idx, 1, 1, e[idx].size(), 1, shy - 1).v1 -
              calcss(idx, 1, 1, e[idx].size(), 1, shy - 1).s1 + P) %
             P;
      if (ans < 0) ans += P;
    } else {
      int idx = w[y], shy = t[y];
      oprs(idx, 1, 1, e[idx].size(), shy, x);
      ans += calcss(idx, 1, 1, e[idx].size(), 1, shy - 1).s1 *
             calcss(idx, 1, 1, e[idx].size(), shy + 1, e[idx].size()).s2 % P;
      ans %= P;
      ans += o[y] *
             (calcss(idx, 1, 1, e[idx].size(), shy + 1, e[idx].size()).v2 -
              calcss(idx, 1, 1, e[idx].size(), shy + 1, e[idx].size()).s2 + P) %
             P;
      ans %= P;
      ans += p[y] *
             (calcss(idx, 1, 1, e[idx].size(), 1, shy - 1).v1 -
              calcss(idx, 1, 1, e[idx].size(), 1, shy - 1).s1 + P) %
             P;
      ans %= P;
    }
    printf("%I64d\n", ans);
  }
}
