#include <bits/stdc++.h>
using namespace std;
int n;
vector<int> a;
bool read() {
  if (scanf("%d", &n) < 1) {
    return 0;
  }
  a.resize(n);
  for (int i = 0; i < int(n); ++i) {
    scanf("%d", &a[i]);
  }
  vector<int> c;
  for (int x : a) {
    c.push_back(x);
  }
  sort(begin(c), end(c));
  c.resize(unique(begin(c), end(c)) - c.begin());
  for (int& x : a) {
    x = lower_bound(begin(c), end(c), x) - c.begin();
  }
  return 1;
}
struct FenwTree {
  vector<int> t;
  FenwTree(int n = 0) { t.assign(n, 0); }
  int get(int r) {
    int s = 0;
    for (int i = r; i >= 0; i &= i + 1, --i) {
      s += t[i];
    }
    return s;
  }
  int get(int l, int r) { return get(r) - get(l - 1); }
  void inc(int pos, int val) {
    for (int i = pos; i < ((int)(t).size()); i |= i + 1) {
      t[i] += val;
    }
  }
};
const int MOD = 1e9 + 7;
void add(int& x, int y) { ((x += y) >= MOD) && (x -= MOD); }
int mul(int x, int y) { return x * 1ll * y % MOD; }
struct Node {
  int dp[4][4];
  Node() {
    clear();
    for (int i = 0; i < int(4); ++i) {
      dp[i][i] = 1;
    }
  }
  Node(int left_________________, int right_______________) {
    clear();
    for (int i = 0; i < int(4); ++i) {
      dp[i][i] = 1;
    }
    dp[0][1] = left_________________;
    dp[1][2] = 1;
    dp[2][3] = right_______________;
  }
  void clear() { memset(dp, 0, sizeof dp); }
  void print() const {
    for (int l = 0; l < int(4); ++l)
      for (int r = l; r < 4; ++r) {
        if (dp[l][r]) {
          printf("[%d, %d) -> %d\n", l, r, dp[l][r]);
        }
      }
    puts("-->");
  }
};
Node merge(const Node& left_________________,
           const Node& right_______________) {
  Node res;
  res.clear();
  for (int l = 0; l < int(4); ++l)
    for (int r = l; r < 4; ++r) {
      for (int m = l; m <= r; ++m) {
        add(res.dp[l][r],
            mul(left_________________.dp[l][m], right_______________.dp[m][r]));
      }
    }
  return res;
}
struct SegmTree {
  vector<Node> t;
  vector<int> left_________________;
  vector<int> right_______________;
  int sz;
  SegmTree() {}
  SegmTree(const vector<int>& left_________________,
           const vector<int>& right_______________)
      : left_________________(left_________________),
        right_______________(right_______________) {
    sz = 1;
    while (sz < ((int)(left_________________).size())) sz *= 2;
    t.resize(sz * 2);
    for (int it = 0; it < int(((int)(left_________________).size())); ++it) {
      change(it, 1);
    }
  }
  void upd(int v) { t[v] = merge(t[v * 2], t[v * 2 + 1]); }
  void change(int v, int tl, int tr, int pos, int new_state) {
    if (tl == tr) {
      if (new_state) {
        t[v] = Node(left_________________[tl], right_______________[tl]);
      } else {
        t[v] = Node();
      }
      return;
    }
    int tm = (tl + tr) >> 1;
    if (pos <= tm) {
      change(v * 2, tl, tm, pos, new_state);
    } else {
      change(v * 2 + 1, tm + 1, tr, pos, new_state);
    }
    upd(v);
  }
  void change(int pos, int new_state) { change(1, 0, sz - 1, pos, new_state); }
  int get() { return t[1].dp[0][3]; }
};
vector<SegmTree> trees;
vector<vector<int> > poses;
void prepare() {
  poses.clear();
  poses.resize(n);
  for (int i = 0; i < int(n); ++i) {
    poses[a[i]].push_back(i);
  }
  vector<int> left_________________(n);
  FenwTree T(n);
  for (int i = 0; i < int(n); ++i) {
    left_________________[i] = T.get(a[i]);
    T.inc(a[i], +1);
  }
  vector<int> right_______________(n);
  T = FenwTree(n);
  for (int i = int(n) - 1; i >= 0; --i) {
    right_______________[i] = T.get(a[i]);
    T.inc(a[i], +1);
  }
  trees.resize(n);
  for (int val = 0; val < int(n); ++val) {
    vector<int> Left;
    vector<int> Right;
    for (int pos : poses[val]) {
      Left.push_back(left_________________[pos]);
      Right.push_back(right_______________[pos]);
    }
    trees[val] = SegmTree(Left, Right);
  }
}
void solve() {
  prepare();
  int ans = 0;
  for (int val = 0; val < int(n); ++val) {
    add(ans, trees[val].get());
  }
  int m;
  scanf("%d", &m);
  for (int it = 0; it < int(m); ++it) {
    int t, x;
    scanf("%d%d", &t, &x);
    --x;
    --t;
    int val = a[x];
    int pos =
        lower_bound(begin(poses[val]), end(poses[val]), x) - poses[val].begin();
    add(ans, -trees[val].get() + MOD);
    trees[val].change(pos, t);
    add(ans, trees[val].get());
    printf("%d\n", ans);
  }
}
int main() {
  while (read()) {
    solve();
  }
  return 0;
}
