#include <cstdio>

 #include <cstring>

 #include <queue>

 #include <cmath>

 #include <algorithm>

 #include <set>

 #include <iostream>

 #include <map>

 #include <stack>

 #include <string>

 #include <vector>

 #define  pi acos(-1.0)

 #define  eps 1e-9

 #define  fi first

 #define  se second

 #define  rtl   rt<<1

 #define  rtr   rt<<1|1

 #define  bug         printf("******\n")

 #define  mem(a,b)    memset(a,b,sizeof(a))

 #define  name2str(x) #x

 #define  fuck(x)     cout<<#x" = "<<x<<endl

 #define  f(a)        a*a

 #define  sf(n)       scanf("%d", &n)

 #define  sff(a,b)    scanf("%d %d", &a, &b)

 #define  sfff(a,b,c) scanf("%d %d %d", &a, &b, &c)

 #define  sffff(a,b,c,d) scanf("%d %d %d %d", &a, &b, &c, &d)

 #define  pf          printf

 #define  FRE(i,a,b)  for(i = a; i <= b; i++)

 #define  FREE(i,a,b) for(i = a; i >= b; i--)

 #define  FRL(i,a,b)  for(i = a; i < b; i++)+

 #define  FRLL(i,a,b) for(i = a; i > b; i--)

 #define  FIN         freopen("data.txt","r",stdin)

 #define  gcd(a,b)    __gcd(a,b)

 #define  lowbit(x)   x&-x

 #define rep(i,a,b) for(int i=a;i<b;++i)

 #define per(i,a,b) for(int i=a-1;i>=b;--i)

 using namespace std;

 typedef long long  LL;

 typedef unsigned long long ULL;

 const int maxn =  + ;

 const int maxm = 8e6 + ;

 const int mod = 1e9 + ;

 const int INF = 0x3f3f3f3f;

 int T, n;

 LL s[maxn], x[maxn], y[maxn], a[maxn], b[maxn], w[maxn], mp[maxn][maxn];

 struct Segtree {

     LL maxx, vl, vr, sum, fg;

 } Tree[maxn << ];

 void updata ( int rt ) {

     Tree[rt].maxx = max ( Tree[rtl].maxx, max ( Tree[rtr].maxx, Tree[rtl].vr + Tree[rtr].vl ) );

     Tree[rt].sum = Tree[rtl].sum + Tree[rtr].sum;

     Tree[rt].vl = max ( Tree[rtl].vl, Tree[rtl].sum + Tree[rtr].vl );

     Tree[rt].vr = max ( Tree[rtr].vr, Tree[rtr].sum + Tree[rtl].vr );

 }

 void build ( int l, int r, int rt ) {

     Tree[rt].fg = true;

     if ( l == r ) {

         Tree[rt].sum = s[l];

         Tree[rt].maxx = s[l];

         Tree[rt].vl = s[l];

         Tree[rt].vr = s[l];

         return ;

     }

     int mid = ( l + r ) >> ;

     build ( l, mid, rtl );

     build ( mid + , r, rtr );

     updata ( rt );

 }

 void add ( int l, int r, int rt, int pos, int to ) {

     if ( l > pos || r < pos ) return ;

     if ( l == r ) {

         Tree[rt].sum += to;

         Tree[rt].maxx += to;

         Tree[rt].vl += to;

         Tree[rt].vr += to;

         return ;

     }

     int mid = ( l + r ) >> ;

     add ( l, mid, rtl, pos, to );

     add ( mid + , r, rtr, pos, to );

     updata ( rt );

 }

 Segtree query ( int l, int r, int rt, int sa, int se ) {

     if ( sa <= l && r <= se ) return Tree[rt];

     int mid = ( l + r ) >> ;

     if ( sa > mid ) return query ( mid + , r, rtr, sa, se );

     if ( se <= mid ) return query ( l, mid, rtl, sa, se );

     Segtree t, lson, rson;

     lson = query ( l, mid, rtl, sa, se );

     rson = query ( mid + , r, rtr, sa, se );

     t.vl = max ( lson.vl, lson.sum + rson.vl );

     t.vr = max ( rson.vr, lson.vr + rson.sum );

     t.maxx = max ( lson.vr + rson.vl, max ( lson.maxx, rson.maxx ) );

     return t;

 }

 vector<LL>v[maxn];

 int main() {

 //    FIN;

     sf ( T );

     while ( T-- ) {

         sf ( n );

         for ( int i =  ; i <= n ; i++ ) {

             scanf ( "%lld%lld%lld", &x[i], &y[i], &w[i] );

             a[i] = x[i], b[i] = y[i];

             v[i].clear();

         }

         sort ( a + , a +  + n ), sort ( b + , b +  + n );

         int len1 = unique ( a + , a +  + n ) - a - ;

         int len2 = unique ( b + , b +  + n ) - b - ;

         for ( int i =  ; i <= n ; i++ ) for ( int j =  ; j <= n ; j++ ) mp[i][j] = ;

         for ( int i =  ; i <= n ; i++ ) {

             x[i] = lower_bound ( a + , a +  + len1, x[i] ) - a;

             y[i] = lower_bound ( b + , b +  + len2, y[i] ) - b;

             mp[y[i]][x[i]] += w[i];

         }

         for ( int i =  ; i <= n ; i++ )

             for ( int j =  ; j <= n ; j++ )

                 if ( mp[i][j] )  v[i].push_back ( j );

         LL ans = ;

         for ( int i =  ; i <= n ; i++ ) {

             for ( int j =  ; j <= n ; j++ ) s[j] = mp[i][j];

             build ( , n,  );

             ans = max ( ans, query ( , n, , , n ).maxx );

             for ( int j = i +  ; j <= n ; j++ ) {

                 for ( int k =  ; k < v[j].size() ; k++ ) {

                     add ( , n, , v[j][k], mp[j][v[j][k]] );

                 }

                 ans = max ( ans, query ( , n, , , n ).maxx );

             }

         }

         printf ( "%lld\n", ans );

     }

     return ;

 }