#include <bits/stdc++.h>
#define int long long

using namespace std;

const int N=1e3+10;


void solve(){
    int n;
    cin>>n;
    vector<int> a1(n+1),a2(n+1),a3(n+1);
    vector<vector<vector<vector<int>>>> dp(2, vector<vector<vector<int>>>(210, vector<vector<int>>(210, vector<int>(210))));

    for(int i=0;i<n;i++){
        cin>>a1[i]>>a2[i]>>a3[i];
    }
    for(int i=0;i<n;i++){ //第i天
        for(int j=0;j<=202;j++){ //有连续j天无
            for(int k=0;k<=202;k++){ //有连续k天无
                int j1=j+(j!=0);
                int k1=k+(k!=0);
                int nxt=i&1^1;
                dp[nxt][1][j1][k1]=max(dp[nxt][1][j1][k1],dp[i&1][0][j][k]+a1[i]-j-k);
                //dp[nxt][0][1][k1]=max(dp[nxt][0][1][k1],dp[i&1][0][j][k]+a2[i]-k);
                //dp[nxt][0][j1][1]=max(dp[nxt][0][j1][1],dp[i&1][0][j][k]+a3[i]-j);
                //dp[nxt][1][0][k1]=max(dp[nxt][1][0][k1],dp[i&1][j][0][k]+a1[i]-k);
                dp[nxt][j1][1][k1]=max(dp[nxt][j1][1][k1],dp[i&1][j][0][k]+a2[i]-j-k);
                //dp[nxt][j1][0][1]=max(dp[nxt][j1][0][1],dp[i&1][j][0][k]+a3[i]-j);
                //dp[nxt][1][j1][0]=max(dp[nxt][1][j1][0],dp[i&1][j][k][0]+a1[i]-j);
                //dp[nxt][j1][1][0]=max(dp[nxt][j1][1][0],dp[i&1][j][k][0]+a2[i]-j);
                dp[nxt][j1][k1][1]=max(dp[nxt][j1][k1][1],dp[i&1][j][k][0]+a3[i]-j-k);

                dp[nxt][1][j1][k1]=max(dp[nxt][1][j1][k1],dp[i&1][1][j][k]+a1[i]-j-k);
                dp[nxt][2][1][k1]=max(dp[nxt][2][1][k1],dp[i&1][1][j][k]+a2[i]-1-k);
                dp[nxt][2][j1][1]=max(dp[nxt][2][j1][1],dp[i&1][1][j][k]+a3[i]-j-1);

                dp[nxt][1][2][k1]=max(dp[nxt][1][2][k1],dp[i&1][j][1][k]+a1[i]-1-k);
                dp[nxt][j1][1][k1]=max(dp[nxt][j1][1][k1],dp[i&1][j][1][k]+a2[i]-j-k);
                dp[nxt][j1][2][1]=max(dp[nxt][j1][2][1],dp[i&1][j][1][k]+a3[i]-j-1);
                
                dp[nxt][1][j1][2]=max(dp[nxt][1][j1][2],dp[i&1][j][k][1]+a1[i]-j-1);
                dp[nxt][j1][1][2]=max(dp[nxt][j1][1][2],dp[i&1][j][k][1]+a2[i]-j-1);
                dp[nxt][j1][k1][1]=max(dp[nxt][j1][k1][1],dp[i&1][j][k][1]+a3[i]-j-k);
            }
        }
        //cout<<dp[i&1^1][1][0][0]<<'\n';
    }
    //cout<<"waht:";
    //cout<<dp[2][0][1][2]<<'\n';
    int ans=0;
    for(int j=0;j<=202;j++){
        for(int k=0;k<=202;k++){
            ans=max(ans,dp[n&1][1][j][k]);
            ans=max(ans,dp[n&1][j][1][k]);
            ans=max(ans,dp[n&1][j][k][1]);
        }
    }
    cout<<ans<<'\n';
}
/*
1
3
1 1 10
1 10 1
10 1 1
*/


signed main(){
    ios::sync_with_stdio(0);
    cin.tie(0),cout.tie(0);
    int t;
    cin>>t;
    while(t--) solve();
    return 0;
}