#include<bits/stdc++.h>

 using namespace std;

 typedef long long ll;

 const ll N=1e5+,inf=0x3f3f3f3f3f3f3f3fll;

 ll n,m,X[N],Y[N],C[N],ka;

 struct D {ll mx,smx,mi,smi,umx,umi;} tr[N<<][];

 D operator+(const D& a,const D& b) {

     if(a.mx==~inf)return b;

     if(b.mx==~inf)return a;

     D c;

     c.mx=max(a.mx,b.mx);

     c.mi=min(a.mi,b.mi);

     c.umx=c.mx==a.mx?a.umx:b.umx;

     c.smx=max(a.smx,b.smx);

     if(a.umx!=b.umx)c.smx=max(c.smx,min(a.mx,b.mx));

     c.umi=c.mi==a.mi?a.umi:b.umi;

     c.smi=min(a.smi,b.smi);

     if(a.umi!=b.umi)c.smi=min(c.smi,max(a.mi,b.mi));

     return c;

 }

 #define ls (u<<1)

 #define rs (u<<1|1)

 #define mid ((l+r)>>1)

 void pu(ll u) {tr[u][]=tr[ls][]+tr[rs][],tr[u][]=tr[ls][]+tr[rs][];}

 void build(ll u=,ll l=,ll r=n) {

     if(l==r) {

         tr[u][]= {X[l]+Y[l],~inf,X[l]+Y[l],inf,C[l],C[l]};

         tr[u][]= {X[l]-Y[l],~inf,X[l]-Y[l],inf,C[l],C[l]};

         return;

     }

     build(ls,l,mid),build(rs,mid+,r),pu(u);

 }

 void upd(ll p,ll x,ll y,ll c,ll u=,ll l=,ll r=n) {

     if(l==r) {

         tr[u][]= {x+y,~inf,x+y,inf,c,c};

         tr[u][]= {x-y,~inf,x-y,inf,c,c};

         return;

     }

     p<=mid?upd(p,x,y,c,ls,l,mid):upd(p,x,y,c,rs,mid+,r);

     pu(u);

 }

 D qry(ll L,ll R,ll f,ll u=,ll l=,ll r=n) {

     if(l>=L&&r<=R)return tr[u][f];

     if(l>R||r<L)return {~inf};

     return qry(L,R,f,ls,l,mid)+qry(L,R,f,rs,mid+,r);

 }

 int main() {

     ll T;

     for(scanf("%lld",&T); T--;) {

         printf("Case #%lld:\n",++ka);

         scanf("%lld%lld",&n,&m);

         for(ll i=; i<=n; ++i)scanf("%lld%lld%lld",&X[i],&Y[i],&C[i]);

         build();

         while(m--) {

             ll f,l,r,k,c,x,y;

             scanf("%lld",&f);

             if(f==)scanf("%lld%lld%lld",&k,&x,&y),upd(k,X[k]+=x,Y[k]+=y,C[k]);

             else if(f==)scanf("%lld%lld",&k,&c),upd(k,X[k],Y[k],C[k]=c);

             else if(f==) {

                 scanf("%lld%lld",&l,&r);

                 D a=qry(l,r,),b=qry(l,r,);

                 ll x=a.umx==a.umi?max(a.mx-a.smi,a.smx-a.mi):a.mx-a.mi;

                 ll y=b.umx==b.umi?max(b.mx-b.smi,b.smx-b.mi):b.mx-b.mi;

                 printf("%lld\n",a.smx==~inf?:max(x,y));

             }

         }

     }

     return ;

 }