#include <bits/stdc++.h>
using namespace std;
namespace baseFastio {
template <typename Int>
inline Int read() {
  Int flag = 1;
  char c = getchar();
  while ((!isdigit(c)) && c != '-' && c != EOF) c = getchar();
  if (c == '-') flag = -1, c = getchar();
  Int init = c & 15;
  while (isdigit(c = getchar())) init = (init << 3) + (init << 1) + (c & 15);
  return init * flag;
}
template <typename Int>
inline Int read(char& c) {
  Int flag = 1;
  c = getchar();
  while ((!isdigit(c)) && c != '-' && c != EOF) c = getchar();
  if (c == '-') flag = -1, c = getchar();
  Int init = c & 15;
  while (isdigit(c = getchar())) init = (init << 3) + (init << 1) + (c & 15);
  return init * flag;
}
template <typename Int>
inline void write(Int x) {
  if (x < 0) putchar('-'), x = ~x + 1;
  if (x > 9) write(x / 10);
  putchar((x % 10) | 48);
}
template <typename Int>
inline void write(Int x, char nextch) {
  write(x);
  putchar(nextch);
}
}  // namespace baseFastio
namespace Fastio {
enum io_flags { ignore_int = 1 << 0 };
struct Reader {
  char endch;
  Reader() { endch = '\0'; }
  template <typename Int>
  Int operator()() {
    return baseFastio::read<Int>(endch);
    ;
  }
  Reader& operator>>(io_flags f) {
    if (f == ignore_int) baseFastio::read<int>();
    return *this;
  }
  template <typename Int>
  Reader& operator>>(Int& i) {
    i = baseFastio::read<Int>(endch);
    return *this;
  }
  template <typename Int>
  inline Int get_int() {
    return baseFastio::read<Int>();
  }
  inline char get_nxt() { return endch; }
} read;
struct Writer {
  Writer& operator<<(const char* ch) {
    while (*ch) putchar(*(ch++));
    return *this;
  }
  Writer& operator<<(const char ch) {
    putchar(ch);
    return *this;
  }
  template <typename Int>
  Writer& operator<<(const Int i) {
    baseFastio::write(i);
    return *this;
  }
} write;
}  // namespace Fastio
using namespace Fastio;
const long long N = 3e5 + 7, P = 1e9 + 7;
long long n, q;
long long a[N];
long long fpow(long long a, long long b) {
  long long ret = 1;
  while (b) {
    if (b & 1) ret = ret * a % P;
    a = a * a % P;
    b >>= 1;
  }
  return ret;
}
namespace MathVal {
long long pow2[N << 1], ipow2[N << 1];
void init(long long n) {
  pow2[0] = ipow2[0] = 1;
  for (long long i = 1; i <= n; i++) pow2[i] = (pow2[i - 1] << 1) % P;
  ipow2[n] = fpow(pow2[n], P - 2);
  for (long long i = n - 1; i >= 1; i--) ipow2[i] = (ipow2[i + 1] << 1) % P;
}
}  // namespace MathVal
namespace SegmentTree {
using MathVal::ipow2;
using MathVal::pow2;
struct treeNode {
  long long l, r;
  long long tot;
  long long val, val1, val2;
} t[N << 3];
void build(long long u, long long l, long long r) {
  t[u].l = l;
  t[u].r = r;
  t[u].tot = t[u].val = t[u].val1 = t[u].val2 = 0;
  if (l == r) return;
  long long mid = (l + r) >> 1;
  build(u << 1, l, mid);
  build(u << 1 | 1, mid + 1, r);
}
void pushup(long long u) {
  t[u].tot = t[u << 1].tot + t[u << 1 | 1].tot;
  t[u].val1 = (t[u << 1].val1 + t[u << 1 | 1].val1 * pow2[t[u << 1].tot]) % P;
  t[u].val2 = (t[u << 1].val2 + t[u << 1 | 1].val2 * ipow2[t[u << 1].tot]) % P;
  t[u].val = (t[u << 1].val + t[u << 1 | 1].val +
              t[u << 1].val1 * t[u << 1 | 1].val2 % P * ipow2[t[u << 1].tot]) %
             P;
}
void update(long long u, long long pos, long long ActualValue) {
  if (t[u].l == t[u].r) {
    if (ActualValue > 0) {
      t[u].tot = 1;
      t[u].val1 = ActualValue;
      t[u].val2 = (long long)ActualValue * ipow2[1] % P;
      t[u].val = 0;
    } else {
      t[u].tot = t[u].val1 = t[u].val2 = t[u].val = 0;
    }
    return;
  }
  long long mid = (t[u].l + t[u].r) >> 1;
  if (pos <= mid)
    update(u << 1, pos, ActualValue);
  else
    update(u << 1 | 1, pos, ActualValue);
  pushup(u);
}
}  // namespace SegmentTree
namespace against_cpp11 {
long long wh[N], val[N];
struct LiSanHua_node {
  long long Value, *pos;
  bool operator<(const LiSanHua_node& b) const { return Value < b.Value; }
} LiSanHua[N << 1];
signed main() {
  read >> n;
  for (long long i = 1; i <= n; i++) {
    read >> a[i];
    LiSanHua[i] = (LiSanHua_node){a[i], a + i};
  }
  read >> q;
  for (long long i = 1; i <= q; i++) {
    read >> wh[i] >> val[i];
    LiSanHua[i + n] = (LiSanHua_node){val[i], val + i};
  }
  sort(LiSanHua + 1, LiSanHua + n + q + 1);
  for (long long i = 1; i <= n + q; i++) *LiSanHua[i].pos = i;
  MathVal::init(n + q);
  SegmentTree::build(1, 1, n + q);
  for (long long i = 1; i <= n; i++)
    SegmentTree::update(1, a[i], LiSanHua[a[i]].Value);
  write << SegmentTree::t[1].val << '\n';
  for (long long i = 1; i <= q; i++) {
    SegmentTree::update(1, a[wh[i]], -LiSanHua[a[wh[i]]].Value);
    a[wh[i]] = val[i];
    SegmentTree::update(1, a[wh[i]], LiSanHua[a[wh[i]]].Value);
    write << SegmentTree::t[1].val << '\n';
  }
  return 0;
}
}  // namespace against_cpp11
signed main() { return against_cpp11::main(); }
