#include <iostream>
#include <algorithm>
#include <vector>
#include <algorithm>
#include <cmath>

using namespace std;

typedef long long ll;

void recalc(int n, const vector<int>& a, int& start_size, vector<vector<int>>& blocks) {
    start_size = sqrt(n);
    blocks.clear();
    for (int i = 0; i < n; ++i) {
        if (i / start_size == blocks.size()) {
            blocks.push_back(vector<int>{});
        }
        blocks[i / start_size].push_back(a[i]);
    }
}

ll sqr(int x) {
    ll y = x;
    return y * y;
}

int main() {
    int n, p;
    cin >> n >> p;
    vector<int> a(n);
    ll summ = 0;
    for (int i = 0; i < n; ++i) {
        cin >> a[i];
        summ += sqr(a[i]);
    }
    cout << summ << endl;
    int k;
    cin >> k;
    int start_size;
    vector<vector<int>> blocks;
    recalc(n, a, start_size, blocks);
    for (int i = 0; i < k; ++i) {
        int type, pos;
        cin >> type >> pos;
        pos--;
        int block = 0;
        while (pos >= blocks[block].size()) {
            pos -= blocks[block].size();
            block++;
        } //block, pos
        int lft = blocks[block][pos] / 2, rght = (blocks[block][pos] + 1) / 2;
        summ -= sqr(blocks[block][pos]);
        if (type == 1) {
            blocks[block].erase(blocks[block].begin() + pos);//pos - 1, pos
            int leftblock, leftpos, rightblock, rightpos;
            if (pos == 0) {
                leftblock = block - 1;
                leftpos = (leftblock == -1 ? -1 : blocks[leftblock].size() - 1);
            } else {
                leftblock = block;
                leftpos = pos - 1;
            }
            if (blocks[block].size() == pos) {
                rightblock = block + 1;
                rightpos = 0;
            } else {
                rightblock = block;
                rightpos = pos;
            }
            if (leftblock == -1) {
                summ -= sqr(blocks[rightblock][rightpos]);
                blocks[rightblock][rightpos] += (lft + rght);
                summ += sqr(blocks[rightblock][rightpos]);
            } else if (rightblock == blocks.size()) {
                summ -= sqr(blocks[leftblock][leftpos]);
                blocks[leftblock][leftpos] += (lft + rght);
                summ += sqr(blocks[leftblock][leftpos]);
            } else {
                summ -= sqr(blocks[leftblock][leftpos]);
                blocks[leftblock][leftpos] += lft;
                summ += sqr(blocks[leftblock][leftpos]);
                summ -= sqr(blocks[rightblock][rightpos]);
                blocks[rightblock][rightpos] += rght;
                summ += sqr(blocks[rightblock][rightpos]);
            }
        } else {
            blocks[block].erase(blocks[block].begin() + pos);
            summ += sqr(lft);
            summ += sqr(rght);
            blocks[block].insert(blocks[block].begin() + pos, lft);
            blocks[block].insert(blocks[block].begin() + pos + 1, rght);
            if (blocks[block].size() >= 2 * start_size) {
                a.clear();
                for (auto arr : blocks) {
                    for (auto el : arr) {
                        a.push_back(el);
                    }
                }
                n = a.size();
                recalc(n, a, start_size, blocks);
            }
        }
        cout << summ << endl;
    }
    system("pause");
    return 0;
}