#include <bits/stdc++.h>
using namespace std;
template <typename T, typename U>
ostream &operator<<(ostream &os, const pair<T, U> &_p) {
  return os << "(" << _p.first << "," << _p.second << ")";
}
template <typename T>
ostream &operator<<(ostream &os, const vector<T> &_V) {
  bool f = true;
  os << "[";
  for (auto v : _V) {
    os << (f ? "" : ",") << v;
    f = false;
  }
  return os << "]";
}
template <typename T>
ostream &operator<<(ostream &os, const set<T> &_S) {
  bool f = true;
  os << "(";
  for (auto s : _S) {
    os << (f ? "" : ",") << s;
    f = false;
  }
  return os << ")";
}
template <typename T, typename U>
ostream &operator<<(ostream &os, const map<T, U> &_M) {
  return os << set<pair<T, U>>(_M.begin(), _M.end());
}
const signed long long INF = 1000000100;
const long double EPS = 1e-9;
template <class TH>
void _dbg(const char *sdbg, TH h) {
  cerr << sdbg << "=" << h << "\n";
}
template <class TH, class... TA>
void _dbg(const char *sdbg, TH h, TA... a) {
  while (*sdbg != ',') cerr << *sdbg++;
  cerr << "=" << h << ",";
  _dbg(sdbg + 1, a...);
}
void renum(vector<int> &a) {
  set<int> vals(a.begin(), a.end());
  int cur = 1;
  map<int, int> ord;
  for (int x : vals) {
    ord[x] = cur;
    cur++;
  }
  for (int &x : a) {
    x = ord[x];
  }
}
template <typename T>
struct tree {
  T *A;
  int M;
  function<T(const T &, const T &)> f;
  T one;
  tree(){};
  tree(int _n, T _one, function<T(const T &, const T &)> _f) {
    M = 1 << (32 - __builtin_clz(_n));
    A = new T[2 * M];
    f = _f;
    one = _one;
    for (int(i) = (0); (i) < (2 * M); (i)++) A[i] = _one;
  }
  T query(int a, int b, int l = 0, int r = -1, int w = 1) {
    if (r == -1) r = M - 1;
    if (r < a || b < l) return one;
    if (a <= l && r <= b) return A[w];
    int mid = (l + r) / 2;
    T lhs = query(a, b, l, mid, 2 * w);
    T rhs = query(a, b, mid + 1, r, 2 * w + 1);
    return f(lhs, rhs);
  }
  void insert(int a, T v) {
    a += M;
    A[a] = v;
    a /= 2;
    while (a != 0) {
      A[a] = f(A[2 * a], A[2 * a + 1]);
      a /= 2;
    }
  }
};
vector<int> not_greater_to_left(const vector<int> &a) {
  int n = int(a.size());
  auto sum = [](const int &x, const int &y) { return x + y; };
  tree<int> T(n + 5, 0, sum);
  vector<int> res(n);
  for (int(i) = (0); (i) < (n); (i)++) {
    for (int(j) = (0); (j) < (T.M); (j)++) (j, T.A[j]);
    res[i] = T.query(0, a[i]);
    (res[i], T.query(a[i], a[i]));
    T.insert(a[i], T.query(a[i], a[i]) + 1);
  }
  return res;
}
const signed long long mod = 1000000007;
const int C = 4;
struct Node {
  signed long long dp[C][C];
  Node(signed long long diag = 0) {
    for (int(i) = (0); (i) < (C); (i)++) {
      for (int(j) = (0); (j) < (C); (j)++) {
        dp[i][j] = 0;
      }
      dp[i][i] = diag;
    }
  }
  Node(signed long long to_left, signed long long to_right) {
    for (int(i) = (0); (i) < (C); (i)++) {
      for (int(j) = (0); (j) < (C); (j)++) {
        dp[i][j] = 0;
      }
      dp[i][i] = 1;
    }
    dp[0][1] = to_left;
    dp[1][2] = 1;
    dp[2][3] = to_right;
  }
  void print() {
    for (int(i) = (0); (i) < (C); (i)++) {
      for (int(j) = (0); (j) < (C); (j)++) {
        if (dp[i][j] == INF)
          if (0)
            cout << "$"
                 << " ";
          else if (0)
            cout << dp[i][j] << " ";
      }
      if (0) cout << endl;
    }
  }
};
Node merge_nodes(const Node &L, const Node &R) {
  Node V;
  for (int(i) = (0); (i) < (C); (i)++) {
    for (int(j) = (0); (j) < (C); (j)++) {
      for (int(k) = (0); (k) < (C); (k)++) {
        V.dp[i][j] += L.dp[i][k] * R.dp[k][j];
      }
      V.dp[i][j] %= mod;
    }
  }
  return V;
}
void solve() {
  int n;
  cin >> n;
  vector<int> a(n);
  for (int(i) = (0); (i) < (n); (i)++) cin >> a[i];
  int m;
  cin >> m;
  renum(a);
  auto ls = not_greater_to_left(a);
  reverse(a.begin(), a.end());
  auto rs = not_greater_to_left(a);
  reverse(rs.begin(), rs.end());
  reverse(a.begin(), a.end());
  (ls);
  (rs);
  vector<vector<int>> layers(n + 1);
  map<int, int> pos;
  for (int(i) = (0); (i) < (n); (i)++) {
    int p = int(layers[a[i]].size());
    layers[a[i]].push_back(i);
    pos[i] = p;
  }
  vector<tree<Node>> T(n + 1);
  signed long long ans = 0;
  for (int(i) = (1); (i) <= (n); (i)++) {
    int k = int(layers[i].size());
    if (!k) continue;
    T[i] = tree<Node>(k, Node(1), merge_nodes);
    for (int(j) = (0); (j) < (k); (j)++) {
      int cur = layers[i][j];
      T[i].insert(j, Node(ls[cur], rs[cur]));
    }
    for (int(j) = (1); (j) < (2 * T[i].M); (j)++) {
      if (0) cout << "Node " << j << ":\n";
      T[i].A[j].print();
      if (0) cout << endl;
    }
    auto v = T[i].query(0, k - 1);
    v.print();
    ans += v.dp[0][3];
    ans %= mod;
  }
  (ans);
  for (int(its) = (0); (its) < (m); (its)++) {
    int t, x;
    cin >> t >> x;
    x--;
    int i = a[x], j = pos[x];
    signed long long old = T[i].A[1].dp[0][3];
    if (t == 1)
      T[i].insert(j, Node(1));
    else
      T[i].insert(j, Node(ls[x], rs[x]));
    signed long long cur = T[i].A[1].dp[0][3];
    ans += cur - old;
    ans = (ans + mod) % mod;
    cout << ans << "\n";
  }
}
int main() {
  ios_base::sync_with_stdio(0);
  solve();
}
