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

struct FastHash {
    static uint64_t splitmix64(uint64_t x) {
        x += 0x9e3779b97f4a7c15ULL;
        x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9ULL;
        x = (x ^ (x >> 27)) * 0x94d049bb133111ebULL;
        x = x ^ (x >> 31);
        return x;
    }
    size_t operator()(uint64_t x) const {
        static const uint64_t FIXED_RANDOM =
            chrono::steady_clock::now().time_since_epoch().count();
        return splitmix64(x + FIXED_RANDOM);
    }
};

// простое сегдерево по количеству точек
struct SegTree {
    int n;
    vector<int> cnt; // число точек в вершине (на отрезке)

    SegTree(int n_ = 0) { init(n_); }

    void init(int n_) {
        if (n_ <= 0) {
            n = 0;
            cnt.clear();
            return;
        }
        n = 1;
        while (n < n_) n <<= 1;
        cnt.assign(2 * n, 0);
    }

    inline void add(int pos, int delta) {
        int i = pos + n;
        cnt[i] += delta;
        for (i >>= 1; i; i >>= 1)
            cnt[i] = cnt[i << 1] + cnt[i << 1 | 1];
    }

    inline bool empty() const { return n == 0 || cnt.empty() || cnt[1] == 0; }

    int first() const {       // минимальный индекс с cnt > 0
        if (empty()) return -1;
        int i = 1;
        while (i < n) {
            if (cnt[i << 1] > 0) i = i << 1;
            else i = i << 1 | 1;
        }
        return i - n;
    }

    int last() const {        // максимальный индекс с cnt > 0
        if (empty()) return -1;
        int i = 1;
        while (i < n) {
            if (cnt[i << 1 | 1] > 0) i = i << 1 | 1;
            else i = i << 1;
        }
        return i - n;
    }
};

struct NodeInfo {
    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;

        int total_est = n + m + 5; // потом ещё q добавим

        // маппинг (x,y) -> id
        unordered_map<uint64_t, int, FastHash> id_by_xy;
        id_by_xy.reserve(total_est * 2);
        id_by_xy.max_load_factor(0.7f);

        vector<NodeInfo> nodes;     // все уникальные точки
        nodes.reserve(total_est * 2);

        auto get_id = [&](long long x, long long y) -> int {
            // кодируем (x,y) в 64 бита без коллизий для int32
            int32_t sx = (int32_t)x;
            int32_t sy = (int32_t)y;
            uint64_t ux = (uint32_t)sx;
            uint64_t uy = (uint32_t)sy;
            uint64_t key = (ux << 32) | uy;

            auto it = id_by_xy.find(key);
            if (it != id_by_xy.end()) return it->second;

            int id = (int)nodes.size();
            NodeInfo ni;
            ni.u = x + y;
            ni.v = x - y;
            ni.idxU = ni.idxV = -1;
            nodes.push_back(ni);
            id_by_xy.emplace(key, id);
            return id;
        };

        vector<int> initA(n), initB(m);
        vector<long long> allU, allV;
        allU.reserve(total_est * 2);
        allV.reserve(total_est * 2);

        // читаем магазины
        for (int i = 0; i < n; ++i) {
            long long x, y;
            cin >> x >> y;
            int id = get_id(x, y);
            initA[i] = id;
        }
        // читаем клиентов
        for (int i = 0; i < m; ++i) {
            long long x, y;
            cin >> x >> y;
            int id = get_id(x, y);
            initB[i] = id;
        }

        int q;
        cin >> q;
        vector<Query> qs(q);
        qs.reserve(q);

        // заранее увеличим оценку для векторов
        allU.reserve((int)nodes.size() + q * 2);
        allV.reserve((int)nodes.size() + q * 2);

        for (int i = 0; i < q; ++i) {
            int tp;
            long long x, y;
            cin >> tp >> x >> y;
            int id = get_id(x, y);
            qs[i] = {tp, id};
        }

        // собираем все u,v для координатного сжатия
        for (auto &nd : nodes) {
            allU.push_back(nd.u);
            allV.push_back(nd.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());

        // заполняем индексы u/v у каждой точки
        for (auto &nd : nodes) {
            nd.idxU = int(lower_bound(allU.begin(), allU.end(), nd.u) - allU.begin());
            nd.idxV = int(lower_bound(allV.begin(), allV.end(), nd.v) - allV.begin());
        }

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

        SegTree Au(Ku), Av(Kv), Bu(Ku), Bv(Kv);

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

        auto addA = [&](int id) {
            if (inA[id]) return;
            inA[id] = 1;
            ++cntA;
            Au.add(nodes[id].idxU, +1);
            Av.add(nodes[id].idxV, +1);
        };
        auto remA = [&](int id) {
            if (!inA[id]) return;
            inA[id] = 0;
            --cntA;
            Au.add(nodes[id].idxU, -1);
            Av.add(nodes[id].idxV, -1);
        };
        auto addB = [&](int id) {
            if (inB[id]) return;
            inB[id] = 1;
            ++cntB;
            Bu.add(nodes[id].idxU, +1);
            Bv.add(nodes[id].idxV, +1);
        };
        auto remB = [&](int id) {
            if (!inB[id]) return;
            inB[id] = 0;
            --cntB;
            Bu.add(nodes[id].idxU, -1);
            Bv.add(nodes[id].idxV, -1);
        };

        // начальное состояние
        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 {
                int aMinU = Au.first();
                int aMaxU = Au.last();
                int bMinU = Bu.first();
                int bMaxU = Bu.last();

                int aMinV = Av.first();
                int aMaxV = Av.last();
                int bMinV = Bv.first();
                int bMaxV = Bv.last();

                long long cand1 = allU[aMaxU] - allU[bMinU];
                long long cand2 = allU[bMaxU] - allU[aMinU];
                long long cand3 = allV[aMaxV] - allV[bMinV];
                long long cand4 = allV[bMaxV] - allV[aMinV];

                long long ans = max(max(cand1, cand2), max(cand3, cand4));
                cout << ans << '\n';
            }
        }
    }

    return 0;
}
