#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;

inline ll rd() {
    ll x = 0;
    bool f = 0;
    char c = getchar();
    for (; !isdigit(c); c = getchar()) f |= (c == '-');
    for (; isdigit(c); c = getchar()) x = x * 10 + (c ^ 48);
    return f ? -x : x;
}

#define eb emplace_back
#define all(s) (s).begin(), (s).end()
#define rep(i, a, b) for (int i = (a); i <= (b); ++i)
#define per(i, a, b) for (int i = (a); i >= (b); --i)

constexpr int N = 100007;
constexpr ll inf = 9000000000000000000ll;

int testcase, bel[N];

struct segtree {
#define ls (rt << 1)
#define rs (rt << 1 | 1)
#define mid ((l + r) >> 1)
    ll pos[N];
    struct node {
        pair<ll, int> mx, smx, mn, smn;
        node() : mx({-inf ,0}), smx({-inf, 0}), mn({inf, 0}), smn({inf, 0}) {}
        node operator + (const node &obj) {
            node ret;
            if (mx > obj.mx) {
                ret.mx = mx;
                if (smx > obj.mx) ret.smx = smx;
                else {
                    if (obj.mx.second != ret.mx.second) ret.smx = obj.mx;
                    else ret.smx = (smx > obj.smx ? smx : obj.smx);
                }
            } else {
                ret.mx = obj.mx;
                if (obj.smx > mx) ret.smx = obj.smx;
                else {
                    if (mx.second != ret.mx.second) ret.smx = mx;
                    else ret.smx = (smx > obj.smx ? smx : obj.smx);
                }
            }
            if (mn < obj.mn) {
                ret.mn = mn;
                if (smn < obj.mn) ret.smn = smn;
                else {
                    if (obj.mn.second != ret.mn.second) ret.smn = obj.mn;
                    else ret.smn = (smn < obj.smn ? smn : obj.smn);
                }
            } else {
                ret.mn = obj.mn;
                if (obj.smn < mn) ret.smn = obj.smn;
                else {
                    if (mn.second != ret.mn.second) ret.smn = mn;
                    else ret.smn = (smn < obj.smn ? smn : obj.smn);
                }
            }
            return ret;
        }
        ll calc() {
            if (mx.second == 0) return 0;
            if (mx.second != mn.second) return mx.first - mn.first;
            ll ans = 0;
            if (smx.second != 0) ans = max(ans, smx.first - mn.first);
            if (smn.second != 0) ans = max(ans, mx.first - smn.first);
            return ans;
        }
    } c[N << 2];
    void build(int rt, int l, int r) {
        c[rt] = node();
        if (l == r) {
            c[rt].mx = {pos[l], bel[l]};
            c[rt].mn = {pos[l], bel[l]};
            return;
        }
        build(ls, l, mid);
        build(rs, mid + 1, r);
        c[rt] = c[ls] + c[rs];
    }
    void upd(int rt, int l, int r, int p) {
        if (l == r) {
            c[rt] = node();
            c[rt].mx = {pos[l], bel[l]};
            c[rt].mn = {pos[l], bel[l]};
            return;
        }
        p <= mid ? upd(ls, l, mid, p) : upd(rs, mid + 1, r, p);
        c[rt] = c[ls] + c[rs];
    }
    node query(int rt, int l, int r, int L, int R) {
        if (L <= l && r <= R) return c[rt];
        if (L > mid) return query(rs, mid + 1, r, L, R);
        if (R <= mid) return query(ls, l, mid, L, R);
        return query(ls, l, mid, L, R) + query(rs, mid + 1, r, L, R);
    }
} X, Y;

inline void work() {
    printf("Case #%d:\n", ++testcase);
    int n = rd(), m = rd();
    rep(i, 1, n) {
        ll xx = rd(), yy = rd();
        bel[i] = rd();
        X.pos[i] = xx + yy;
        Y.pos[i] = xx - yy;
    }
    X.build(1, 1, n);
    Y.build(1, 1, n);
    rep(i, 1, m) {
        int op = rd();
        if (op == 1) {
            int k = rd();
            ll dx = rd(), dy = rd();
            X.pos[k] += dx + dy;
            Y.pos[k] += dx - dy;
            X.upd(1, 1, n, k);
            Y.upd(1, 1, n, k);
        } else if (op == 2) {
            int k = rd();
            bel[k] = rd();
            X.upd(1, 1, n, k);
            Y.upd(1, 1, n, k);
        } else {
            int l = rd(), r = rd();
            printf("%lld\n", max(X.query(1, 1, n, l, r).calc(), Y.query(1, 1, n, l, r).calc()));
        }
    }
;}

int main() {
    per(t, rd(), 1) work();
    return 0;
}