#include <bits/stdc++.h>
using namespace std;

struct PairXY {
    long long x, y;
    bool operator<(const PairXY &other) const {
        if (x != other.x) return x < other.x;
        return y < other.y;
    }
    bool operator==(const PairXY &other) const {
        return x == other.x && y == other.y;
    }
};

struct Node {
    long long u, v;
    int idxU, idxV;
};

struct Query {
    int type; // 1 - магазин, 2 - клиент
    int id;   // id точки (по (x,y))
};

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

    int T;
    if (!(cin >> T)) return 0;

    while (T--) {
        int n, m;
        cin >> n >> m;

        // читаем исходные точки
        vector<PairXY> initAxy(n), initBxy(m);
        for (int i = 0; i < n; ++i)
            cin >> initAxy[i].x >> initAxy[i].y;
        for (int i = 0; i < m; ++i)
            cin >> initBxy[i].x >> initBxy[i].y;

        int q;
        cin >> q;
        vector<Query> qs(q);
        vector<PairXY> qxy(q);
        for (int i = 0; i < q; ++i) {
            cin >> qs[i].type >> qxy[i].x >> qxy[i].y;
        }

        // собираем ВСЕ точки, которые когда-либо встречаются
        vector<PairXY> all;
        all.reserve(n + m + q);
        for (int i = 0; i < n; ++i) all.push_back(initAxy[i]);
        for (int i = 0; i < m; ++i) all.push_back(initBxy[i]);
        for (int i = 0; i < q; ++i) all.push_back(qxy[i]);

        sort(all.begin(), all.end());
        all.erase(unique(all.begin(), all.end()), all.end());

        int P = (int)all.size();

        // строим узлы (по уникальным (x,y))
        vector<Node> nodes(P);
        for (int i = 0; i < P; ++i) {
            long long x = all[i].x;
            long long y = all[i].y;
            nodes[i].u = x + y;
            nodes[i].v = x - y;
            nodes[i].idxU = nodes[i].idxV = -1;
        }

        // координатное сжатие по u и v
        vector<long long> allU(P), allV(P);
        for (int i = 0; i < P; ++i) {
            allU[i] = nodes[i].u;
            allV[i] = nodes[i].v;
        }
        sort(allU.begin(), allU.end());
        allU.erase(unique(allU.begin(), allU.end()), allU.end());
        sort(allV.begin(), allV.end());
        allV.erase(unique(allV.begin(), allV.end()), allV.end());

        int Ku = (int)allU.size();
        int Kv = (int)allV.size();

        for (int i = 0; i < P; ++i) {
            nodes[i].idxU = int(lower_bound(allU.begin(), allU.end(), nodes[i].u) - allU.begin());
            nodes[i].idxV = int(lower_bound(allV.begin(), allV.end(), nodes[i].v) - allV.begin());
        }

        // теперь сопоставляем каждой входной точке её id (индекс в all/nodes)
        auto get_id = [&](const PairXY &p) -> int {
            int id = int(lower_bound(all.begin(), all.end(), p) - all.begin());
            return id; // гарантированно существует
        };

        vector<int> initA(n), initB(m);
        for (int i = 0; i < n; ++i) initA[i] = get_id(initAxy[i]);
        for (int i = 0; i < m; ++i) initB[i] = get_id(initBxy[i]);
        for (int i = 0; i < q; ++i) qs[i].id = get_id(qxy[i]);

        // счётчики по u/v для A и B
        vector<int> cntAu(Ku, 0), cntAv(Kv, 0);
        vector<int> cntBu(Ku, 0), cntBv(Kv, 0);

        int minAu = -1, maxAu = -1;
        int minAv = -1, maxAv = -1;
        int minBu = -1, maxBu = -1;
        int minBv = -1, maxBv = -1;

        vector<char> inA(P, 0), inB(P, 0);
        int cntA = 0, cntB = 0;

        auto addA = [&](int id) {
            if (inA[id]) return;
            inA[id] = 1;
            ++cntA;
            Node &nd = nodes[id];
            int iu = nd.idxU, iv = nd.idxV;

            if (++cntAu[iu] == 1) {
                if (minAu == -1 || iu < minAu) minAu = iu;
                if (maxAu == -1 || iu > maxAu) maxAu = iu;
            }
            if (++cntAv[iv] == 1) {
                if (minAv == -1 || iv < minAv) minAv = iv;
                if (maxAv == -1 || iv > maxAv) maxAv = iv;
            }
        };

        auto remA = [&](int id) {
            if (!inA[id]) return;
            inA[id] = 0;
            --cntA;
            Node &nd = nodes[id];
            int iu = nd.idxU, iv = nd.idxV;

            if (--cntAu[iu] == 0) {
                if (cntA == 0) {
                    minAu = maxAu = -1;
                } else if (iu == minAu) {
                    while (minAu <= maxAu && cntAu[minAu] == 0) ++minAu;
                } else if (iu == maxAu) {
                    while (maxAu >= minAu && cntAu[maxAu] == 0) --maxAu;
                }
            }
            if (--cntAv[iv] == 0) {
                if (cntA == 0) {
                    minAv = maxAv = -1;
                } else if (iv == minAv) {
                    while (minAv <= maxAv && cntAv[minAv] == 0) ++minAv;
                } else if (iv == maxAv) {
                    while (maxAv >= minAv && cntAv[maxAv] == 0) --maxAv;
                }
            }
        };

        auto addB = [&](int id) {
            if (inB[id]) return;
            inB[id] = 1;
            ++cntB;
            Node &nd = nodes[id];
            int iu = nd.idxU, iv = nd.idxV;

            if (++cntBu[iu] == 1) {
                if (minBu == -1 || iu < minBu) minBu = iu;
                if (maxBu == -1 || iu > maxBu) maxBu = iu;
            }
            if (++cntBv[iv] == 1) {
                if (minBv == -1 || iv < minBv) minBv = iv;
                if (maxBv == -1 || iv > maxBv) maxBv = iv;
            }
        };

        auto remB = [&](int id) {
            if (!inB[id]) return;
            inB[id] = 0;
            --cntB;
            Node &nd = nodes[id];
            int iu = nd.idxU, iv = nd.idxV;

            if (--cntBu[iu] == 0) {
                if (cntB == 0) {
                    minBu = maxBu = -1;
                } else if (iu == minBu) {
                    while (minBu <= maxBu && cntBu[minBu] == 0) ++minBu;
                } else if (iu == maxBu) {
                    while (maxBu >= minBu && cntBu[maxBu] == 0) --maxBu;
                }
            }
            if (--cntBv[iv] == 0) {
                if (cntB == 0) {
                    minBv = maxBv = -1;
                } else if (iv == minBv) {
                    while (minBv <= maxBv && cntBv[minBv] == 0) ++minBv;
                } else if (iv == maxBv) {
                    while (maxBv >= minBv && cntBv[maxBv] == 0) --maxBv;
                }
            }
        };

        // начальное состояние
        for (int id : initA) addA(id);
        for (int id : initB) addB(id);

        for (int i = 0; i < q; ++i) {
            int tp = qs[i].type;
            int id = qs[i].id;


            if (tp == 1) {
                if (inA[id]) remA(id);
                else addA(id);
            } else {
                if (inB[id]) remB(id);
                else addB(id);
            }

            if (cntA == 0 || cntB == 0) {
                cout << "KAPUT\n";
            } else {
                long long cand1 = allU[maxAu] - allU[minBu];
                long long cand2 = allU[maxBu] - allU[minAu];
                long long cand3 = allV[maxAv] - allV[minBv];
                long long cand4 = allV[maxBv] - allV[minAv];
                long long ans = max(max(cand1, cand2), max(cand3, cand4));
                cout << ans << '\n';
            }
        }
    }

    return 0;
}
