#include <bits/stdc++.h>
#define endl '\n'
using namespace std;
using i64 = long long;
using a3 = array<i64, 3>;

const i64 INF = 1ll << 30;

struct SegTree
{
#define ls (p << 1)
#define rs ((p << 1) | 1)
#define mid ((l + r) >> 1)

    int n;
    vector<i64> tr, val, L, R;

    SegTree(int N = 0) : n(N)
    {
        tr.resize(n << 2 | 1);
        val.resize(n << 2 | 1);
        L.resize(n << 2 | 1);
        R.resize(n << 2 | 1);
    }

    void update(int p, int l, int r)
    {
        tr[p] = tr[ls];
        val[p] = val[ls];
        L[p] = L[ls];
        R[p] = R[ls];

        if (tr[ls] == mid - l + 1 && tr[rs])
        {
            auto [len, mex, lmt] = query(R[ls], rs, mid + 1, r);
            tr[p] += len;
            val[p] += mex;
            R[p] = lmt;
        }
    }

    void add(int x, int k, int p, int l, int r)
    {
        if (l == r)
        {
            val[p] += k;
            if (val[p] == 0)
            {
                tr[p] = 0;
                L[p] = R[p] = 0;
            }
            else
            {
                tr[p] = 1;
                L[p] = R[p] = val[p];
            }
            // cout << p << ' ' << l << ' ' << r << ' ' << tr[p] << ' ' << val[p] << ' ' << L[p] << ' ' << R[p] << endl;
            return;
        }

        if (x <= mid)
            add(x, k, ls, l, mid);
        if (mid + 1 <= x)
            add(x, k, rs, mid + 1, r);
        update(p, l, r);
        // cout << p << ' ' << l << ' ' << r << ' ' << tr[p] << ' ' << val[p] << ' ' << L[p] << ' ' << R[p] << endl;
    }

    a3 query(i64 limit, int p, int l, int r)
    {
        if (L[p] <= limit)
        {
            return {tr[p], val[p], R[p]};
        }
        else if (l == r)
        {
            if (tr[p])
            {
                return {1ll, limit, limit};
            }
            else
            {
                return {0ll, 0ll, 0ll};
            }
        }

        if (R[ls] <= limit)
        {
            auto [len, mex, lmt] = query(limit, ls, l, mid);
            if (len == mid - l + 1)
                return {len + tr[rs], mex + val[rs], R[rs]};
            return {len, mex, R[ls]};
        }
        else
        {
            auto [len, mex, lmt] = query(limit, rs, mid + 1, r);
            if (tr[ls] == mid - l + 1)
                return {tr[ls] + len, limit * (mid - l + 1) + mex, lmt};
            return {tr[ls], limit * (mid - l + 1), limit};
        }

        // int find_less_than(int s, int t, int x, int p, int l, int r)
        // {
        //     if (minn[p] >= x)
        //         return t + 1;
        //     if (t < l || s > r)
        //         return t + 1;

        //     int res = INF;
        //     if (s <= mid && minn[ls] < x)
        //         res = min(res, find_less_than(s, t, x, ls, l, mid));
        //     if (mid + 1 <= t && minn[rs] < x)
        //         res = min(res, find_less_than(s, t, x, rs, mid + 1, r));
        //     return res;
        // }
    }
};

void solve()
{
    int n;
    cin >> n;

    SegTree tr(n);

    for (int i = 1; i <= n; i++)
    {
        int x;
        cin >> x;
        tr.add(i, x, 1, 1, n);
        // cout << endl;
    }
    cout << tr.val[1] << endl;

    int q;
    cin >> q;
    while (q--)
    {
        int op, x;
        cin >> op >> x;
        x++;
        if (x <= n)
        {
            if (op == 1)
                tr.add(x, 1, 1, 1, n);
            else
                tr.add(x, -1, 1, 1, n);
        }

        // cout << endl;
        cout << tr.val[1] << endl;
    }

    // while (q--)
    // {
    //     int l, r, x;
    //     cin >> l >> r >> x;
    //     cout << tr.find_less_than(x, l, r, 1, 1, n) << endl;
    // }

    // cout << "Yes\n";
}

int main()
{
    ios::sync_with_stdio(NULL);
    cin.tie(nullptr);

    int t = 1;
    // cin >> t;
    while (t--)
        solve();
    return 0;
}