#include<bits/stdc++.h>
using namespace std ;
typedef long long ll ;
typedef unsigned long long ull ;
typedef pair < int , int > pii ; 
typedef vector<int> vi;
typedef vector < long long > vl ;
typedef unsigned int uint ;
#define fi first
#define se second
mt19937 rng(chrono::high_resolution_clock::now().time_since_epoch().count());

#define rep(i, a, b) for(int i = a; i < (b); ++i)
#define all(x) begin(x), end(x)
#define sz(x) (int)(x).size()

const int MAXN = 1e5 + 7 ;
const ll inf = 1e18 ;
int n , q ;
pair < ll , ll > a[ MAXN ] ;
int cl[ MAXN ] ;

struct node {
    ll ans ;
    pair < ll , int > mx[ 2 ][ 2 ][ 2 ] ; // cx , cy , wh
    node ( ) {
        ans = 0 ;
        for ( int i = 0 ; i < 2 ; ++ i ) {
            for ( int j = 0 ; j < 2 ; ++ j ) {
                for ( int t = 0 ; t < 2 ; ++ t ) {
                    mx[ i ][ j ][ t ] = { -inf , 0 } ;
                }
            }
        }
    }
};

node unite ( node p1 , node p2 ) {
    node ret = node ( ) ;
    ret.ans = max ( p1.ans , p2.ans ) ;
    for ( int i = 0 ; i < 2 ; ++ i ) {
        for ( int j = 0 ; j < 2 ; ++ j ) {
            for ( int t = 0 ; t < 2 ; ++ t ) {
                for ( int z = 0 ; z < 2 ; z ++ ) {
                    if ( p1.mx[ i ][ j ][ t ].se == p2.mx[ z ][ j ^ 1 ][ t ^ 1 ].se ) { continue ; }
                    ret.ans = max ( ret.ans , p1.mx[ i ][ j ][ t ].fi + p2.mx[ z ][ j ^ 1 ][ t ^ 1 ].fi ) ;
                }
            }
        }
    }
    for ( int j = 0 ; j < 2 ; ++ j ) {
        for ( int t = 0 ; t < 2 ; ++ t ) {
            ret.mx[ 0 ][ j ][ t ] = max ( p1.mx[ 0 ][ j ][ t ] , p2.mx[ 0 ][ j ][ t ] ) ;
            int sr = ret.mx[ 0 ][ j ][ t ].se ;
            if ( p1.mx[ 0 ][ j ][ t ].se != sr ) {
                ret.mx[ 1 ][ j ][ t ] = max ( ret.mx[ 1 ][ j ][ t ] , p1.mx[ 0 ][ j ][ t ] ) ;
            }
            if ( p1.mx[ 1 ][ j ][ t ].se != sr ) {
                ret.mx[ 1 ][ j ][ t ] = max ( ret.mx[ 1 ][ j ][ t ] , p1.mx[ 1 ][ j ][ t ] ) ;
            }
            if ( p2.mx[ 0 ][ j ][ t ].se != sr ) {
                ret.mx[ 1 ][ j ][ t ] = max ( ret.mx[ 1 ][ j ][ t ] , p2.mx[ 0 ][ j ][ t ] ) ;
            }
            if ( p2.mx[ 1 ][ j ][ t ].se != sr ) {
                ret.mx[ 1 ][ j ][ t ] = max ( ret.mx[ 1 ][ j ][ t ] , p2.mx[ 1 ][ j ][ t ] ) ;
            }
        }
    }
    return ret ;
};

class Tree {
public :
    node tr[ 4 * MAXN ] ;
    void set_pos ( int w , int l ) {
        tr[ w ].ans = 0 ;
        for ( int i = 0 ; i < 2 ; ++ i ) {
            for ( int j = 0 ; j < 2 ; ++ j ) {
                ll sm = 0 ;
                if ( i == 0 ) { sm -= a[ l ].fi ; }
                else { sm += a[ l ].fi ; }
                if ( j == 0 ) { sm -= a[ l ].se ; }
                else { sm += a[ l ].se ; }
                tr[ w ].mx[ 0 ][ i ][ j ] = { sm , cl[ l ] } ;
                tr[ w ].mx[ 1 ][ i ][ j ] = { -inf , 0 } ;
            }
        }
    }
    void init ( int w , int l , int r ) {
        if ( l == r ) {
            set_pos ( w , l ) ;
            return ;
        }
        int mid = ( l + r ) / 2 ;
        init ( 2 * w , l , mid ) ;
        init ( 2 * w + 1 , mid + 1 , r ) ;
        tr[ w ] = unite ( tr[ 2 * w ] , tr[ 2 * w + 1 ] ) ;
    }
    void update ( int w , int l , int r , int pos ) {
        if ( l == r ) {
            set_pos ( w , l ) ;
            return ;
        }
        int mid = ( l + r ) / 2 ;
        if ( pos <= mid ) { update ( 2 * w , l , mid , pos ) ; } 
        else { update ( 2 * w + 1 , mid + 1 , r , pos ) ; }
        tr[ w ] = unite ( tr[ 2 * w ] , tr[ 2 * w + 1 ] ) ;
    }
    node query ( int w , int l , int r , int st , int en ) {
        if ( l > r || st > en ) { return node ( ) ; }
        if ( r < st || en < l ) { return node ( ) ; }
        if ( st <= l && r <= en ) { return tr[ w ] ; }
        int mid = ( l + r ) / 2 ;
        return unite ( query ( 2 * w , l , mid , st , en ) , query ( 2 * w + 1 , mid + 1 , r , st , en ) ) ;
    }
};
Tree w ;

int test_id ;

void solve ( ) {
    ++ test_id ;
    cout << "Case #" << test_id << ":\n" ;
    cin >> n >> q ;
    for ( int i = 1 ; i <= n ; ++ i ) {
        cin >> a[ i ].fi >> a[ i ].se >> cl[ i ] ;
    }
    w.init ( 1 , 1 , n ) ;
    while ( q -- ) {
        int type ; cin >> type ;
        if ( type == 1 ) {
            int k , x , y ;
            cin >> k >> x >> y ;
            a[ k ].fi += x , a[ k ].se += y ;
            w.update ( 1 , 1 , n , k ) ;
        }
        else if ( type == 2 ) {
            int k , nw ;
            cin >> k >> nw ;
            cl[ k ] = nw ;
            w.update ( 1 , 1 , n , k ) ;
        }
        else {
            int l , r ;
            cin >> l >> r ;
            node ret = w.query ( 1 , 1 , n , l , r ) ;
            cout << ret.ans << "\n" ;
        }
    }
}


int main ( ) {
    ios_base :: sync_with_stdio ( false ) ;
    cin.tie ( NULL ) ;
    int t = 1 ; cin >> t ; 
    while ( t -- ) { solve ( ) ; }
    return 0 ;
}