stablegradients/pie-gem5-pairs huggingface dataset:
// Slower C++ solution:
#include <bits/stdc++.h>

using namespace std;



#define ll long long int



int N;

int dias[100005][3];

ll memo[100005][3];



ll solve(int dia, int act){

	if(!dia) return dias[dia][act];

	if(memo[dia][act]) return memo[dia][act];

	return memo[dia][act] = 

		dias[dia][act]+max(solve(dia-1, (act+1)%3), solve(dia-1, (act+2)%3));

}



ll solve(){

	for(int i = 0; i < 3; i++)

		memo[0][i] = dias[0][i];

	for(int i = 1; i<N; i++)

		for(int j = 0; j<3; j++)

			memo[i][j] = dias[i][j]+

							max(memo[i-1][(j+1)%3], 

								memo[i-1][(j+2)%3]);

	ll maxi = 0;

	for(int i = 0; i < 3; i++)

		maxi = max(maxi, memo[N-1][i]);

	return maxi;

}



int main() {

	cin>>N;

	for(int i = 0; i< N; i++)

		cin>>dias[i][0]>>dias[i][1]>>dias[i][2];

	cout<<solve()<<"\n";

	return 0;

}

// Faster C++ solution for the same problem (measured speedup: 4.496933028060251x):
#include<cstdio>

#include<algorithm>

int main(){

  int j=1,x,da[3][100001],fun[3][2];

  scanf("%d",&x);

  fun[0][0] = fun[1][0] = fun[2][0] = 0;

  for(int i=1;i<=x;i++){

    scanf("%d%d%d",&da[0][i],&da[1][i],&da[2][i]);

    fun[0][j] = std::max(fun[1][j^1],fun[2][j^1]) + da[0][i];

    fun[1][j] = std::max(fun[0][j^1],fun[2][j^1]) + da[1][i];

    fun[2][j] = std::max(fun[1][j^1],fun[0][j^1]) + da[2][i];

    j^=1;

  }

  j^=1;

  printf("%d\n",std::max(std::max(fun[0][j],fun[1][j]),fun[2][j]));

  

  return 0;

}
// Slower C++ solution:
#include <bits/stdc++.h>

using namespace std;



#define ll long long int



int N;

int dias[3];

ll memo[2][3];



ll solve(){

	cin>>memo[0][0]>>memo[0][1]>>memo[0][2];

	for(int i = 1; i<N; i++){

		cin>>dias[0]>>dias[1]>>dias[2];

		for(int j = 0; j<3;j++)

			memo[i&1][j]=dias[j]+max(memo[(i+1)&1][(j+1)%3],memo[(i+1)&1][(j+2)%3]);

	}

	ll maxi = 0;

	for(int j = 0; j<3;j++)

		maxi = max(memo[(N-1)&1][j], maxi);

	return maxi;

}



int main() {

	cin>>N;

	cout<<solve()<<"\n";

	return 0;

}

// Faster C++ solution for the same problem (measured speedup: 4.5081975462363975x):
#include<cstdio>

#include<algorithm>

int main(){

  int j=1,x,da[3][100001],fun[3][2];

  scanf("%d",&x);

  fun[0][0] = fun[1][0] = fun[2][0] = 0;

  for(int i=1;i<=x;i++){

    scanf("%d%d%d",&da[0][i],&da[1][i],&da[2][i]);

    fun[0][j] = std::max(fun[1][j^1],fun[2][j^1]) + da[0][i];

    fun[1][j] = std::max(fun[0][j^1],fun[2][j^1]) + da[1][i];

    fun[2][j] = std::max(fun[1][j^1],fun[0][j^1]) + da[2][i];

    j^=1;

  }

  j^=1;

  printf("%d\n",std::max(std::max(fun[0][j],fun[1][j]),fun[2][j]));

  

  return 0;

}
// Slower C++ solution:
#include <bits/stdc++.h>

using namespace std;



#define ll long long int



int felicidad[100005][3];

ll memo[100005][3];

int N;



ll maxFeliz(int dia, int act){

	if(!dia) return felicidad[0][act];

	if(memo[dia][act]) return memo[dia][act];

	return memo[dia][act] = felicidad[dia][act]+

					max(maxFeliz(dia-1, (act+1)%3),

						maxFeliz(dia-1, (act+2)%3));

}



int main() {

	cin>>N;

	for(int i = 0; i<N; i++)

		cin>>felicidad[i][0]>>felicidad[i][1]>>felicidad[i][2];

	cout<<max(maxFeliz(N-1,0), max(maxFeliz(N-1,1), maxFeliz(N-1,2)))<<"\n";

	return 0;

}

// Faster C++ solution for the same problem (measured speedup: 4.498911686025186x):
#include<cstdio>

#include<algorithm>

int main(){

  int j=1,x,da[3][100001],fun[3][2];

  scanf("%d",&x);

  fun[0][0] = fun[1][0] = fun[2][0] = 0;

  for(int i=1;i<=x;i++){

    scanf("%d%d%d",&da[0][i],&da[1][i],&da[2][i]);

    fun[0][j] = std::max(fun[1][j^1],fun[2][j^1]) + da[0][i];

    fun[1][j] = std::max(fun[0][j^1],fun[2][j^1]) + da[1][i];

    fun[2][j] = std::max(fun[1][j^1],fun[0][j^1]) + da[2][i];

    j^=1;

  }

  j^=1;

  printf("%d\n",std::max(std::max(fun[0][j],fun[1][j]),fun[2][j]));

  

  return 0;

}
// Slower C++ solution:
#include <iostream>

#include <cstring>

#include <stdio.h>

using namespace std;

const int N=1e+5;

int n,a[N],b[N],c[N];

int memo[N][4];

int dp(int i,int t)

{

    if(i==n)

        return 0;

    int &ret=memo[i][t];

    if(~ret)

        return ret;

    ret=0;

    if(t!=0)

        ret=max(ret,dp(i+1,0)+a[i]);

    if(t!=1)

        ret=max(ret,dp(i+1,1)+b[i]);

    if(t!=2)

        ret=max(ret,dp(i+1,2)+c[i]);

    return ret;





}

int main()

{

    memset(memo,-1,sizeof memo);

    scanf("%d",&n);

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

    {

         scanf("%d %d %d",a+i,b+i,c+i);

    }

    printf("%d\n",dp(0,3));

    return 0;

}


// Faster C++ solution for the same problem (measured speedup: 11.651975998064977x):
#include<cstdio>

#include<algorithm>

int main(){

  int j=1,x,da[3][100001],fun[3][2];

  scanf("%d",&x);

  fun[0][0] = fun[1][0] = fun[2][0] = 0;

  for(int i=1;i<=x;i++){

    scanf("%d%d%d",&da[0][i],&da[1][i],&da[2][i]);

    fun[0][j] = std::max(fun[1][j^1],fun[2][j^1]) + da[0][i];

    fun[1][j] = std::max(fun[0][j^1],fun[2][j^1]) + da[1][i];

    fun[2][j] = std::max(fun[1][j^1],fun[0][j^1]) + da[2][i];

    j^=1;

  }

  j^=1;

  printf("%d\n",std::max(std::max(fun[0][j],fun[1][j]),fun[2][j]));

  

  return 0;

}
// Slower C++ solution:
#include <bits/stdc++.h>

using namespace std;



int n;

int dp[100100][4];

vector<int> arr[100100];



int main() {

    cin >> n;

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

        int k;

        for (int j = 0; j < 3; ++j) {

            cin >> k;

            arr[i].push_back(k);

        }

    }



    for (int i = 0; i < 3; ++i) dp[1][i] = arr[1][i];



    for (int pos = 2; pos <= n; ++pos) {

        for (int j = 0; j < 3; ++j) {



            if ( j == 0 ) 

                dp[pos][j] = arr[pos][j] + max(dp[pos - 1][1], dp[pos - 1][2]);

            

            else if ( j == 1 )

                dp[pos][j] = arr[pos][j] + max(dp[pos - 1][0], dp[pos - 1][2]);



            else

                dp[pos][j] = arr[pos][j] + max(dp[pos - 1][0], dp[pos - 1][1]);

        }

    }



    cout << max({dp[n][0], dp[n][1], dp[n][2]}) << endl;

    return 0;

}


// Faster C++ solution for the same problem (measured speedup: 1.3578935900808733x):
#include <bits/stdc++.h>

using namespace std;



#define clr(arr,val) memset(arr,val ,sizeof arr)

//#define first f

//#define second s



typedef  long long ull;

typedef long long ll;

ll const oo=1e18 ;



int const SZ= (int)1e5+5;

//const ll mod=(ll)1e9+7;

    

//int dp[SZ][SZ];

int arr[SZ][4];

int dp[SZ][4];

int n;

int solve(int r ,int prev ){



    if(r>=n){

        return 0;

    }

    int &ret=dp[r][prev];

    if(prev!=-1 && ret !=-1){

        return ret;

    }

    int mx=0;

    for(int i=0 ;i<3;i++){

        if(i==prev) continue;

        mx=max(mx,arr[r][i]+solve(r+1,i));

    }

    return ret=mx;

}



int main() {

//#ifdef CLION

//    freopen("in.txt", "r", stdin);

//    freopen("out.txt", "w", stdin);

//#endif

    

    cin>>n;

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

       cin>>arr[i][0]>>arr[i][1]>>arr[i][2];

    }

    memset(dp,-1,sizeof(dp));

    cout<<solve(0,-1)<<endl;

    return 0;

}
// Slower C++ solution:
#include<bits/stdc++.h>

using namespace std;

typedef long long ll;



ll arr[100009][3];

int dp[100009][2][2][2];



long long VAC1(int n,int a, int b, int c)

{



    if(!n && a) return arr[n][0];

    else if(!n && b) return arr[n][1];

    else if(!n && c) return arr[n][2];

    else if(dp[n][a][b][c]!=-1)return dp[n][a][b][c];



    else

    {



        ll x,y,z;

        if(a)

        {

            x = VAC1(n-1,0,1,0)+arr[n][0];

            y = VAC1(n-1,0,0,1)+arr[n][0];



        }



        else if(b)

        {

            x = VAC1(n-1,1,0,0)+arr[n][1];

            y = VAC1(n-1,0,0,1)+arr[n][1];

        }



        else if(c)

        {

            x = VAC1(n-1,1,0,0)+arr[n][2];

            y = VAC1(n-1,0,1,0)+arr[n][2];

        }



        dp[n][a][b][c] = max(x,y);;

        return dp[n][a][b][c];





    }

}



int main()

{

   // freopen("in.txt","r",stdin);

    int n;

    memset(dp,-1,sizeof(dp));

    cin >> n;

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

    {

        for(int j=0; j<3; j++)

        {

            cin >> arr[i][j];

        }

    }

    ll res = VAC1(n-1,1,0,0);

    res= max(res, VAC1(n-1,0,1,0));

    res = max(res,VAC1(n-1,0,0,1));



    cout << res << endl;

}


// Faster C++ solution for the same problem (measured speedup: 1.6203025350660283x):
#include <bits/stdc++.h>

using namespace std;



#define clr(arr,val) memset(arr,val ,sizeof arr)

//#define first f

//#define second s



typedef  long long ull;

typedef long long ll;

ll const oo=1e18 ;



int const SZ= (int)1e5+5;

//const ll mod=(ll)1e9+7;

    

//int dp[SZ][SZ];

int arr[SZ][4];

int dp[SZ][4];

int n;

int solve(int r ,int prev ){



    if(r>=n){

        return 0;

    }

    int &ret=dp[r][prev];

    if(prev!=-1 && ret !=-1){

        return ret;

    }

    int mx=0;

    for(int i=0 ;i<3;i++){

        if(i==prev) continue;

        mx=max(mx,arr[r][i]+solve(r+1,i));

    }

    return ret=mx;

}



int main() {

//#ifdef CLION

//    freopen("in.txt", "r", stdin);

//    freopen("out.txt", "w", stdin);

//#endif

    

    cin>>n;

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

       cin>>arr[i][0]>>arr[i][1]>>arr[i][2];

    }

    memset(dp,-1,sizeof(dp));

    cout<<solve(0,-1)<<endl;

    return 0;

}
// Slower C++ solution:
#define _CRT_SECURE_NO_WARNINGS

#include<bits/stdc++.h>

#include<unordered_map>

#include<unordered_set>	

using namespace std;

typedef long long ll;

#define bay_bay return 0;

#define fori(n) for(int i=0;i<n;++i)

#define for1(n) for(int i=1;i<=n;i+=3)

#define all(v) ((v).begin()), ((v).end())	

#define sz(v) v.size()

#define endl "\n"

constexpr auto EPS = 1e-9;

#define ff fflush(stdout);

const int mod = 1000000007LL;

clock_t T;

#define ctime cerr << "Time : " << double(clock() - T) / CLOCKS_PER_SEC << endl

void GOAT()

{

	std::ios_base::sync_with_stdio(0);

	cin.tie(NULL);

	cout.tie(NULL);

#ifndef ONLINE_JUDGE

	freopen("in.txt", "r", stdin);

	//freopen("output.txt", "w	", stdout);

#else

#endif

}

struct day

{

	ll a, b, c;



};

day days[100009];

ll mem[100009][4];

int n;

ll solve(int idx, int ch)

{

	if (idx == n)

	{

		return 0;

	}

	ll &ret = mem[idx][ch];

	if (~ret)

		return ret;

	ret = LLONG_MIN;

	if (ch != 1)

		ret=max(ret, days[idx].a + solve(idx + 1, 1));

	if (ch != 2)

		ret=max(ret, days[idx].b + solve(idx + 1, 2));

	if (ch != 3)

		ret=max(ret, days[idx].c + solve(idx + 1, 3));

	return ret;



}

int main()

{

	//GOAT();

	cin >> n;

	memset(mem, -1,sizeof mem);

	fori(n)

	{

		cin >> days[i].a >> days[i].b >> days[i].c;

	}

	cout << solve(0, 0) << endl;

	

}

// Faster C++ solution for the same problem (measured speedup: 1.6208840229518504x):
#include <bits/stdc++.h>

using namespace std;



#define clr(arr,val) memset(arr,val ,sizeof arr)

//#define first f

//#define second s



typedef  long long ull;

typedef long long ll;

ll const oo=1e18 ;



int const SZ= (int)1e5+5;

//const ll mod=(ll)1e9+7;

    

//int dp[SZ][SZ];

int arr[SZ][4];

int dp[SZ][4];

int n;

int solve(int r ,int prev ){



    if(r>=n){

        return 0;

    }

    int &ret=dp[r][prev];

    if(prev!=-1 && ret !=-1){

        return ret;

    }

    int mx=0;

    for(int i=0 ;i<3;i++){

        if(i==prev) continue;

        mx=max(mx,arr[r][i]+solve(r+1,i));

    }

    return ret=mx;

}



int main() {

//#ifdef CLION

//    freopen("in.txt", "r", stdin);

//    freopen("out.txt", "w", stdin);

//#endif

    

    cin>>n;

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

       cin>>arr[i][0]>>arr[i][1]>>arr[i][2];

    }

    memset(dp,-1,sizeof(dp));

    cout<<solve(0,-1)<<endl;

    return 0;

}
// Slower C++ solution:
/**

     **author : _KMS_

     **created : 01-04-2020

**/

#include<bits/stdc++.h>

using namespace std;

const long long M =3e5+10,MOD=1e9+7;

typedef long long ll;

vector<int>v[M];

bool vis[M];

int dp[M][7];

int arr[10];

int main()

{

    ios::sync_with_stdio(false);

    cin.tie(0);

    int t,n;

    cin>>n;

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

    {

      for(int j=1;j<=3;j++)

      {

        cin>>arr[j];

       for(int k=1;k<=3;k++)if(j!=k)dp[i][j]=max(dp[i][j],dp[i-1][k]+arr[j]);

      }

    }



  cout<<max(dp[n][1],max(dp[n][2],dp[n][3]))<<"\n";

    return 0;

}

// Faster C++ solution for the same problem (measured speedup: 3.6168887865152994x):
#include <bits/stdc++.h>

using namespace std;



#define clr(arr,val) memset(arr,val ,sizeof arr)

//#define first f

//#define second s



typedef  long long ull;

typedef long long ll;

ll const oo=1e18 ;



int const SZ= (int)1e5+5;

//const ll mod=(ll)1e9+7;

    

//int dp[SZ][SZ];

int arr[SZ][4];

int dp[SZ][4];

int n;

int solve(int r ,int prev ){



    if(r>=n){

        return 0;

    }

    int &ret=dp[r][prev];

    if(prev!=-1 && ret !=-1){

        return ret;

    }

    int mx=0;

    for(int i=0 ;i<3;i++){

        if(i==prev) continue;

        mx=max(mx,arr[r][i]+solve(r+1,i));

    }

    return ret=mx;

}



int main() {

//#ifdef CLION

//    freopen("in.txt", "r", stdin);

//    freopen("out.txt", "w", stdin);

//#endif

    

    cin>>n;

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

       cin>>arr[i][0]>>arr[i][1]>>arr[i][2];

    }

    memset(dp,-1,sizeof(dp));

    cout<<solve(0,-1)<<endl;

    return 0;

}
// Slower C++ solution:
#define __USE_MINGW_ANSI_STDIO

#define _CRT_SECURE_NO_WARNINGS

#include <bits/stdc++.h>

#include <unordered_set>

#include <unordered_map>



using namespace std;



typedef long long ll;

typedef long long ull;

typedef pair<ll, ll> ii;



#define all(v)		((v).begin()), ((v).end())

#define sz(v)		((int)((v).size()))

#define endl		"\n"

#define fx(n)		fixed<<setprecision(n)

#define mk			make_pair	



void File()

{

#ifndef ONLINE_JUDGE

	freopen("output.txt", "w", stdout);

	freopen("input.txt", "r", stdin);

#endif

#ifdef ONLINE_JUDGE

	/*freopen("output.txt", "w", stdout);

	freopen("pyramid.in", "r", stdin);*/

#endif

}

void fast()

{

	ios::sync_with_stdio(NULL);

	cout.tie(NULL);

	cin.tie(NULL);

	//File();

}

const double pi = 2 * acos(0.0);

const ll oo = 0x3f3f3f3f;

const int MOD = 1e9 + 7;

const int nn = 1e5 + 15;

int dx[8] = { 1, -1, 0, 0, 1, -1, 1, -1 };

int dy[8] = { 0, 0, 1, -1, 1, -1, -1, 1 };



int n, k;

vector<pair<int, pair<int, int>>>v;

ll dp[nn][4];

ll solve(int idx, int last)

{

	if (idx >= n)

		return 0;

	ll &ret = dp[idx][last];

	if (~ret)

		return ret;

	ret = 0;

	if (last != 1)

		ret = max(ret, solve(idx + 1, 1) + v[idx].first);



	if (last != 2)

		ret = max(ret, solve(idx + 1, 2) + v[idx].second.first);



	if (last != 3)

		ret = max(ret, solve(idx + 1, 3) + v[idx].second.second);



	return ret;

}

int main()

{

	fast();

	cin >> n;

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

	{

		int x, y, z;

		cin >> x >> y >> z;

		v.push_back(mk(x, mk(y, z)));

	}

	memset(dp, -1, sizeof(dp));

	cout << solve(0, 0) << endl;

	return 0;

}

// Faster C++ solution for the same problem (measured speedup: 1.6288772817155912x):
#include <bits/stdc++.h>

using namespace std;



#define clr(arr,val) memset(arr,val ,sizeof arr)

//#define first f

//#define second s



typedef  long long ull;

typedef long long ll;

ll const oo=1e18 ;



int const SZ= (int)1e5+5;

//const ll mod=(ll)1e9+7;

    

//int dp[SZ][SZ];

int arr[SZ][4];

int dp[SZ][4];

int n;

int solve(int r ,int prev ){



    if(r>=n){

        return 0;

    }

    int &ret=dp[r][prev];

    if(prev!=-1 && ret !=-1){

        return ret;

    }

    int mx=0;

    for(int i=0 ;i<3;i++){

        if(i==prev) continue;

        mx=max(mx,arr[r][i]+solve(r+1,i));

    }

    return ret=mx;

}



int main() {

//#ifdef CLION

//    freopen("in.txt", "r", stdin);

//    freopen("out.txt", "w", stdin);

//#endif

    

    cin>>n;

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

       cin>>arr[i][0]>>arr[i][1]>>arr[i][2];

    }

    memset(dp,-1,sizeof(dp));

    cout<<solve(0,-1)<<endl;

    return 0;

}
// Slower C++ solution:
#include<bits/stdc++.h>

#define ull unsigned long long

#define ll long long

#define pb push_back

#define endl '\n'

#define line cout<<"----------------------"<<endl

#define mp make_pair

#define mod 1000000007

#define fast ios_base::sync_with_stdio(false); cin.tie(NULL)

#define filein freopen("input.txt","r",stdin)

#define fileout freopen("output.txt","w",stdout)

using namespace std;

const ll  mx=300009;

struct edge

{

    ll  a,b,c;

};

vector<edge> v;

ll  dp[100009][4];

ll  call(ll  ind, ll  pre)

{

    if(ind==v.size()) return 0;

    ll  &ret=dp[ind][pre];

    if(ret!=-1) return ret;

    ret=0;

    ll  a=0,b=0,c=0;

    auto x=v[ind];

        if(pre==1)

        {

            a=x.b+call(ind+1,2);

            b=x.c+call(ind+1,3);

        }

        else if(pre==2)

        {

            a=x.a+call(ind+1,1);

            b=x.c+call(ind+1,3);

        }

        else if(pre==3)

        {

            a=x.a+call(ind+1,1);

            b=x.b+call(ind+1,2);

        }

        else

        {

            a=x.a+call(ind+1,1);

            b=x.b+call(ind+1,2);

            c=x.c+call(ind+1,3);

        }

    return ret=max(a,max(b,c));

}

int  main()

{

    ll  n ;

    cin>>n;

    for(ll  i=0;i<n;i++)

    {

        ll  a,b,c; cin>>a>>b>>c;

        v.pb({a,b,c});

    }

    memset(dp,-1,sizeof dp);

    cout<<call(0,0)<<endl;







}


// Faster C++ solution for the same problem (measured speedup: 1.6196080829190709x):
#include <bits/stdc++.h>

using namespace std;



#define clr(arr,val) memset(arr,val ,sizeof arr)

//#define first f

//#define second s



typedef  long long ull;

typedef long long ll;

ll const oo=1e18 ;



int const SZ= (int)1e5+5;

//const ll mod=(ll)1e9+7;

    

//int dp[SZ][SZ];

int arr[SZ][4];

int dp[SZ][4];

int n;

int solve(int r ,int prev ){



    if(r>=n){

        return 0;

    }

    int &ret=dp[r][prev];

    if(prev!=-1 && ret !=-1){

        return ret;

    }

    int mx=0;

    for(int i=0 ;i<3;i++){

        if(i==prev) continue;

        mx=max(mx,arr[r][i]+solve(r+1,i));

    }

    return ret=mx;

}



int main() {

//#ifdef CLION

//    freopen("in.txt", "r", stdin);

//    freopen("out.txt", "w", stdin);

//#endif

    

    cin>>n;

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

       cin>>arr[i][0]>>arr[i][1]>>arr[i][2];

    }

    memset(dp,-1,sizeof(dp));

    cout<<solve(0,-1)<<endl;

    return 0;

}
// Slower C++ solution:
#include <bits/stdc++.h>

#define ll long long

using namespace std;



ll n;

std::vector<ll> ara[100010];

ll dp[100010][4];



ll fnc(ll idx,ll last){

  if(idx == n) return 0;

  if(dp[idx][last] != -1) return dp[idx][last];



  ll res1 = - (1<<25);

  ll res2 = - (1<<25);

  ll res3 = - (1<<25);



  if(last == 0){

    res1 = max(res1,ara[idx][0] + fnc(idx+1,1));

    res2 = max(res2,ara[idx][1] + fnc(idx+1,2));

    res3 = max(res3,ara[idx][2] + fnc(idx+1,3));

  }else if(last == 1){

    res2 = max(res2,ara[idx][1] + fnc(idx+1,2));

    res3 = max(res3,ara[idx][2] + fnc(idx+1,3));

  }else if(last == 2){

    res1 = max(res1,ara[idx][0] + fnc(idx+1,1));

    res3 = max(res3,ara[idx][2] + fnc(idx+1,3));

  }else if(last == 3){

    res1 = max(res1,ara[idx][0] + fnc(idx+1,1));

    res2 = max(res2,ara[idx][1] + fnc(idx+1,2));

  }

  dp[idx][last] = max(res1, max(res2,res3));

  return dp[idx][last];

}



int main(int argc, char const *argv[]) {

  memset(dp,-1,sizeof(dp));

  cin >> n;

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

    int a,b,c;

    cin >> a >> b >> c;

    ara[i].push_back(a);

    ara[i].push_back(b);

    ara[i].push_back(c);

  }



  cout << fnc(0,0) << endl;

  return 0;

}


// Faster C++ solution for the same problem (measured speedup: 2.7504746299513814x):
#include <bits/stdc++.h>

using namespace std;



#define clr(arr,val) memset(arr,val ,sizeof arr)

//#define first f

//#define second s



typedef  long long ull;

typedef long long ll;

ll const oo=1e18 ;



int const SZ= (int)1e5+5;

//const ll mod=(ll)1e9+7;

    

//int dp[SZ][SZ];

int arr[SZ][4];

int dp[SZ][4];

int n;

int solve(int r ,int prev ){



    if(r>=n){

        return 0;

    }

    int &ret=dp[r][prev];

    if(prev!=-1 && ret !=-1){

        return ret;

    }

    int mx=0;

    for(int i=0 ;i<3;i++){

        if(i==prev) continue;

        mx=max(mx,arr[r][i]+solve(r+1,i));

    }

    return ret=mx;

}



int main() {

//#ifdef CLION

//    freopen("in.txt", "r", stdin);

//    freopen("out.txt", "w", stdin);

//#endif

    

    cin>>n;

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

       cin>>arr[i][0]>>arr[i][1]>>arr[i][2];

    }

    memset(dp,-1,sizeof(dp));

    cout<<solve(0,-1)<<endl;

    return 0;

}
// Slower C++ solution:
#include <bits/stdc++.h>



using namespace std;

typedef long long int lli;



lli n, a[100005], b[100005], c[100005];



lli dp[100005][4];



lli solve(lli i, lli last){

    if(i == n) return dp[i][last] = 0;

    if(dp[i][last] != -1) return dp[i][last];

    lli ans1, ans2, ans3;

    ans1 = ans2 = ans3 = LONG_LONG_MIN;

    if(last != 1) ans1 = a[i] + solve(i+1, 1);

    if(last != 2) ans2 = b[i] + solve(i+1, 2);

    if(last != 3) ans3 = c[i] + solve(i+1, 3);



    return dp[i][last] = max(ans1, max(ans2, ans3));

}





int main(){

    //freopen("input.txt", "r", stdin);

    int T=1, cs=1;

    //scanf("%d", &T);

    while(T--){

        memset(dp, -1, sizeof(dp));

        scanf("%lld", &n);

        for(lli i=0; i<n; i++){

            scanf("%lld %lld %lld", &a[i], &b[i], &c[i]);

        }

        printf("%lld\n", solve(0, 0));



    }



    return 0;

}

// Faster C++ solution for the same problem (measured speedup: 1.612907379884409x):
#include <bits/stdc++.h>

using namespace std;



#define clr(arr,val) memset(arr,val ,sizeof arr)

//#define first f

//#define second s



typedef  long long ull;

typedef long long ll;

ll const oo=1e18 ;



int const SZ= (int)1e5+5;

//const ll mod=(ll)1e9+7;

    

//int dp[SZ][SZ];

int arr[SZ][4];

int dp[SZ][4];

int n;

int solve(int r ,int prev ){



    if(r>=n){

        return 0;

    }

    int &ret=dp[r][prev];

    if(prev!=-1 && ret !=-1){

        return ret;

    }

    int mx=0;

    for(int i=0 ;i<3;i++){

        if(i==prev) continue;

        mx=max(mx,arr[r][i]+solve(r+1,i));

    }

    return ret=mx;

}



int main() {

//#ifdef CLION

//    freopen("in.txt", "r", stdin);

//    freopen("out.txt", "w", stdin);

//#endif

    

    cin>>n;

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

       cin>>arr[i][0]>>arr[i][1]>>arr[i][2];

    }

    memset(dp,-1,sizeof(dp));

    cout<<solve(0,-1)<<endl;

    return 0;

}
// Slower C++ solution:
#include<bits/stdc++.h>

using namespace std;

typedef long long ll;



ll arr[100009][3];

int dp[100009][2][2][2];



long long VAC1(int n,int a, int b, int c)

{



    if(!n && a) return arr[n][0];

    else if(!n && b) return arr[n][1];

    else if(!n && c) return arr[n][2];

    else if(dp[n][a][b][c]!=-1)return dp[n][a][b][c];



    else

    {



        ll x,y,z;

        if(a)

        {

            x = VAC1(n-1,0,1,0)+arr[n][0];

            y = VAC1(n-1,0,0,1)+arr[n][0];



        }



        else if(b)

        {

            x = VAC1(n-1,1,0,0)+arr[n][1];

            y = VAC1(n-1,0,0,1)+arr[n][1];

        }



        else if(c)

        {

            x = VAC1(n-1,1,0,0)+arr[n][2];

            y = VAC1(n-1,0,1,0)+arr[n][2];

        }



        dp[n][a][b][c] = max(x,y);;

        return dp[n][a][b][c];





    }

}



int main()

{

   // freopen("in.txt","r",stdin);

    int n;

    memset(dp,-1,sizeof(dp));

    cin >> n;

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

    {

        for(int j=0; j<3; j++)

        {

            cin >> arr[i][j];

        }

    }

    ll res = VAC1(n-1,1,0,0);

    res= max(res, VAC1(n-1,0,1,0));

    res = max(res,VAC1(n-1,0,0,1));



    cout << res << endl;

}


// Faster C++ solution for the same problem (measured speedup: 1.2298909171098278x):
#include <bits/stdc++.h>

using namespace std;

int main(){

    int n;

    cin>>n;

    long long dp[100005][3];

    memset(dp,-1,sizeof(dp));

    dp[0][0]=0;

    dp[0][1]=0;

    dp[0][2]=0;

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

        long long a,b,c;

        cin>>a>>b>>c;

        dp[i][0]=max(dp[i-1][1]+b, dp[i-1][2]+c);

        dp[i][1]=max(dp[i-1][0]+a, dp[i-1][2]+c);

        dp[i][2]=max(dp[i-1][1]+b, dp[i-1][0]+a);

    }

    long long ans=max(dp[n][0], max(dp[n][1], dp[n][2]));

    cout<<ans<<'\n';

}