stablegradients/pie-gem5-pairs huggingface dataset:
// Slower C++ solution:


#include<bits/stdc++.h>

using namespace std;



#define MAX 100000



int dp[MAX+5][4];

int val[MAX+5][4];

int n;



void initialize()

{

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

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

            dp[i][j] = -1;

}



int vacation(int i, int j)

{

    if(i<=0) return 0;



  /*  if(i==1)

    {

        return val[i][j];

    }

*/

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



    int mx = INT_MIN;



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

    {

        if(j==k) continue;



        mx = max(mx, vacation(i-1, k)+ val[i][j]);

    }





    dp[i][j] = mx;



    return mx;

}



int main()

{

    initialize();



    cin>>n;

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

    {

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

            cin>>val[i][j];

    }



    int retVal1 = vacation(n, 1);



    initialize();



    int retVal2 = vacation(n, 2);



    initialize();



    int retVal3 = vacation(n, 3);



    cout<<max({retVal1, retVal2, retVal3})<<endl;



    return 0;

}


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

#include<iostream>

#include<algorithm>

#include<queue>

#define inf 0x3f3f3f3f

using namespace std;

typedef long long LL;

const int maxn = 1e5+5;



int a[maxn],b[maxn],c[maxn],dp[maxn][3];



int main(){

	int n;

	scanf("%d",&n);

	int m;

	for(int i = 1; i <= n; i++) scanf("%d %d %d", &a[i],&b[i],&c[i]);

	dp[1][0] = a[1]; dp[1][1] = b[1]; dp[1][2] = c[1];

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

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

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

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

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

		}

	}

	m = max(dp[n][0], dp[n][1]);

	m = max(m, dp[n][2]);

	printf("%d",m);

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

using namespace std;

int arr[100010][5];

int dp[100010][5];



int vac(int a, int b){

	if(a == 0) return 0;

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

	

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

		if(i != b){

			dp[a][b] = max(dp[a][b], vac(a - 1,i) + arr[a][i]);

		}

	}

	

	return dp[a][b];

}



int main (){

	memset(dp,-1,sizeof dp);

	int n;

	cin >> n;

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

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

	}

	

	

	int ans = 0;

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

		ans = max(ans , vac(n - 1, i) + arr[n][i]);

	}

	

	cout << ans << endl;

	

}

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

#include<iostream>

#include<algorithm>

#include<queue>

#define inf 0x3f3f3f3f

using namespace std;

typedef long long LL;

const int maxn = 1e5+5;



int a[maxn],b[maxn],c[maxn],dp[maxn][3];



int main(){

	int n;

	scanf("%d",&n);

	int m;

	for(int i = 1; i <= n; i++) scanf("%d %d %d", &a[i],&b[i],&c[i]);

	dp[1][0] = a[1]; dp[1][1] = b[1]; dp[1][2] = c[1];

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

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

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

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

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

		}

	}

	m = max(dp[n][0], dp[n][1]);

	m = max(m, dp[n][2]);

	printf("%d",m);

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

using namespace std;



int ar[100010][5],n;

int dp[100010][5];



int call(int i,int f)

{



    if(i==n)

        return 0;



    if(dp[i][f]!=-1)

        return dp[i][f];



    int ans=0;



    if(f==0)

        ans+=max(ar[i][1]+call(i+1,1),ar[i][2]+call(i+1,2));



    else if(f==1)

        ans+=max(ar[i][0]+call(i+1,0),ar[i][2]+call(i+1,2));

    else

        ans+=max(ar[i][1]+call(i+1,1),ar[i][0]+call(i+1,0));



        dp[i][f]=ans;

        return ans;



}



int main()

{



    cin>>n;



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

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



    memset(dp,-1,sizeof dp);



    int ans=max(max(call(0,0),call(0,1)),call(0,2));



    cout<<ans<<endl;



}


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



using namespace std;



int main() {

    vector<vector<int>> anpan;

    int n, k = -1;

    cin >> n;

    vector<int> zerad = {0};

        anpan.push_back(zerad);

        anpan.push_back(zerad);

        anpan.push_back(zerad);



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

        int a, b, c;

        cin >> a >> b >> c;

        anpan[0].push_back(max(anpan[1][i], anpan[2][i]) + a);

        anpan[1].push_back(max(anpan[0][i], anpan[2][i]) + b);

        anpan[2].push_back(max(anpan[0][i], anpan[1][i]) + c);

    }

    cout << max(anpan[0][n], max(anpan[1][n], anpan[2][n])) << endl;

}
// Slower C++ solution:


#include<bits/stdc++.h>

using namespace std;



#define MAX 100000



int dp[MAX+5][4];

int val[MAX+5][4];

int n;



void initialize()

{

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

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

            dp[i][j] = -1;

}



int vacation(int i, int j)

{

    if(i<=0) return 0;



  /*  if(i==1)

    {

        return val[i][j];

    }

*/

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



    int mx = INT_MIN;



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

    {

        if(j==k) continue;



        mx = max(mx, vacation(i-1, k)+ val[i][j]);

    }





    dp[i][j] = mx;



    return mx;

}



int main()

{

    initialize();



    cin>>n;

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

    {

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

            cin>>val[i][j];

    }



    int retVal1 = vacation(n, 1);



    initialize();



    int retVal2 = vacation(n, 2);



    initialize();



    int retVal3 = vacation(n, 3);



    cout<<max({retVal1, retVal2, retVal3})<<endl;



    return 0;

}


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



using namespace std;



int main() {

    vector<vector<int>> anpan;

    int n, k = -1;

    cin >> n;

    vector<int> zerad = {0};

        anpan.push_back(zerad);

        anpan.push_back(zerad);

        anpan.push_back(zerad);



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

        int a, b, c;

        cin >> a >> b >> c;

        anpan[0].push_back(max(anpan[1][i], anpan[2][i]) + a);

        anpan[1].push_back(max(anpan[0][i], anpan[2][i]) + b);

        anpan[2].push_back(max(anpan[0][i], anpan[1][i]) + c);

    }

    cout << max(anpan[0][n], max(anpan[1][n], anpan[2][n])) << endl;

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

using namespace std;

int arr[100010][5];

int dp[100010][5];



int vac(int a, int b){

	if(a == 0) return 0;

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

	

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

		if(i != b){

			dp[a][b] = max(dp[a][b], vac(a - 1,i) + arr[a][i]);

		}

	}

	

	return dp[a][b];

}



int main (){

	memset(dp,-1,sizeof dp);

	int n;

	cin >> n;

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

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

	}

	

	

	int ans = 0;

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

		ans = max(ans , vac(n - 1, i) + arr[n][i]);

	}

	

	cout << ans << endl;

	

}

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



using namespace std;



int main() {

    vector<vector<int>> anpan;

    int n, k = -1;

    cin >> n;

    vector<int> zerad = {0};

        anpan.push_back(zerad);

        anpan.push_back(zerad);

        anpan.push_back(zerad);



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

        int a, b, c;

        cin >> a >> b >> c;

        anpan[0].push_back(max(anpan[1][i], anpan[2][i]) + a);

        anpan[1].push_back(max(anpan[0][i], anpan[2][i]) + b);

        anpan[2].push_back(max(anpan[0][i], anpan[1][i]) + c);

    }

    cout << max(anpan[0][n], max(anpan[1][n], anpan[2][n])) << endl;

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

#include<algorithm>



using namespace std;



int a[110000],b[110000],c[110000];

int f[110000][3];

int main()

{

    int n;



    cin>>n;



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

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

    f[1][0] = max(b[1],c[1]);

    f[1][1] = max(a[1],c[1]);

    f[1][2] = max(a[1],b[1]);

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

    {

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

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

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

    }

    int ans=max(f[n][0],f[n][1]);

    ans=max(ans,f[n][2]);

    cout<<ans;

}   

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

#include<algorithm>



using namespace std;



const int maxn = 1e5 + 5;

int dp[maxn][5],a[maxn][4];

int main()

{

	int n,i,j;

	scanf("%d",&n);

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

	{

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

		{

			scanf("%d",&a[i][j]);

		}

	}

	for(i=1;i<=3;i++)

		dp[1][i]=a[1][i];

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

	{

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

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

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

	}

	int ans=0;

	for(i=1;i<=3;i++)

		ans=max(dp[n][i],ans);

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

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



using namespace std;





int main()

{

	int n;

	cin >> n;



	vector<vector<int>> h(n, vector<int>(3)), dp(n, vector<int>(3));



	for(auto &cur : h)

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



	dp[0] = h[0];



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

	{

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

		{

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

			{

				if(k == j)

					continue;



				dp[i][j] = max(dp[i][j], dp[i - 1][k] + h[i][j]);

			}

		}

	}



	cout << *max_element(dp[n - 1].begin(), dp[n - 1].end()) << endl;

}

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

#include<algorithm>



using namespace std;



const int maxn = 1e5 + 5;

int dp[maxn][5],a[maxn][4];

int main()

{

	int n,i,j;

	scanf("%d",&n);

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

	{

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

		{

			scanf("%d",&a[i][j]);

		}

	}

	for(i=1;i<=3;i++)

		dp[1][i]=a[1][i];

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

	{

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

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

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

	}

	int ans=0;

	for(i=1;i<=3;i++)

		ans=max(dp[n][i],ans);

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

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

using namespace std;

int dp[100005][5],a[100005][5];

int main()

{

    int i,j,n;

    cin>>n;

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

    {

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

        {

            cin>>a[i][j];

        }

    }

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

    {

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

        {

            if(i==0)

            {

                dp[i][j]=a[i][j];

            }

            else if(j==0)

            {

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

            }

            else if(j==1)

            {

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

            }

            else if(j==2)

            {

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

            }

        }

    }

    n--;

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

    return 0;

}




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

#include<algorithm>



using namespace std;



const int maxn = 1e5 + 5;

int dp[maxn][5],a[maxn][4];

int main()

{

	int n,i,j;

	scanf("%d",&n);

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

	{

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

		{

			scanf("%d",&a[i][j]);

		}

	}

	for(i=1;i<=3;i++)

		dp[1][i]=a[1][i];

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

	{

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

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

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

	}

	int ans=0;

	for(i=1;i<=3;i++)

		ans=max(dp[n][i],ans);

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

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

#define ll long long

#define ull unsigned long long

using namespace std;

ll n,a[100009],b[100009],c[100009],dp[100009][5];

int main (){

	ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);

	cin >> n;

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

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

	}

	for (int i=n; i>=1; i--){

		dp[i][1]=a[i]+max(dp[i+1][2],dp[i+1][3]);

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

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

	}

	ll jwb=0;

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

		jwb=max(jwb,dp[1][i]);

	}

	cout << jwb << endl;

}

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

#include<algorithm>



using namespace std;



const int maxn = 1e5 + 5;

int dp[maxn][5],a[maxn][4];

int main()

{

	int n,i,j;

	scanf("%d",&n);

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

	{

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

		{

			scanf("%d",&a[i][j]);

		}

	}

	for(i=1;i<=3;i++)

		dp[1][i]=a[1][i];

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

	{

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

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

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

	}

	int ans=0;

	for(i=1;i<=3;i++)

		ans=max(dp[n][i],ans);

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

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

using namespace std;



int ar[100010][5],n;

int dp[100010][5];



int call(int i,int f)

{



    if(i==n)

        return 0;



    if(dp[i][f]!=-1)

        return dp[i][f];



    int ans=0;



    if(f==0)

        ans+=max(ar[i][1]+call(i+1,1),ar[i][2]+call(i+1,2));



    else if(f==1)

        ans+=max(ar[i][0]+call(i+1,0),ar[i][2]+call(i+1,2));

    else

        ans+=max(ar[i][1]+call(i+1,1),ar[i][0]+call(i+1,0));



        dp[i][f]=ans;

        return ans;



}



int main()

{



    cin>>n;



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

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



    memset(dp,-1,sizeof dp);



    int ans=max(max(call(0,0),call(0,1)),call(0,2));



    cout<<ans<<endl;



}


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

#include<algorithm>



using namespace std;



const int maxn = 1e5 + 5;

int dp[maxn][5],a[maxn][4];

int main()

{

	int n,i,j;

	scanf("%d",&n);

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

	{

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

		{

			scanf("%d",&a[i][j]);

		}

	}

	for(i=1;i<=3;i++)

		dp[1][i]=a[1][i];

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

	{

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

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

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

	}

	int ans=0;

	for(i=1;i<=3;i++)

		ans=max(dp[n][i],ans);

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

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

using namespace std;



int h[3][100005], a[100005], b[100005], c[100005];



int main(){



    int n; cin >> n;

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

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

    }



    h[0][1] = a[1];

    h[1][1] = b[1];

    h[2][1] = c[1];



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

        h[0][i] = max({h[0][i - 2] + a[i], h[1][i-1] + a[i], h[2][i-1] + a[i]});

        h[1][i] = max({h[1][i - 2] + b[i], h[0][i-1] + b[i], h[2][i-1] + b[i]});

        h[2][i] = max({h[2][i - 2] + c[i], h[0][i-1] + c[i], h[1][i-1] + c[i]});

    }



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

    return 0;

}




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

#include<algorithm>



using namespace std;



const int maxn = 1e5 + 5;

int dp[maxn][5],a[maxn][4];

int main()

{

	int n,i,j;

	scanf("%d",&n);

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

	{

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

		{

			scanf("%d",&a[i][j]);

		}

	}

	for(i=1;i<=3;i++)

		dp[1][i]=a[1][i];

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

	{

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

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

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

	}

	int ans=0;

	for(i=1;i<=3;i++)

		ans=max(dp[n][i],ans);

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

}
// Slower C++ solution:


#include<bits/stdc++.h>

using namespace std;



#define MAX 100000



int dp[MAX+5][4];

int val[MAX+5][4];

int n;



void initialize()

{

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

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

            dp[i][j] = -1;

}



int vacation(int i, int j)

{

    if(i<=0) return 0;



  /*  if(i==1)

    {

        return val[i][j];

    }

*/

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



    int mx = INT_MIN;



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

    {

        if(j==k) continue;



        mx = max(mx, vacation(i-1, k)+ val[i][j]);

    }





    dp[i][j] = mx;



    return mx;

}



int main()

{

    initialize();



    cin>>n;

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

    {

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

            cin>>val[i][j];

    }



    int retVal1 = vacation(n, 1);



    initialize();



    int retVal2 = vacation(n, 2);



    initialize();



    int retVal3 = vacation(n, 3);



    cout<<max({retVal1, retVal2, retVal3})<<endl;



    return 0;

}


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

#include<algorithm>



using namespace std;



const int maxn = 1e5 + 5;

int dp[maxn][5],a[maxn][4];

int main()

{

	int n,i,j;

	scanf("%d",&n);

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

	{

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

		{

			scanf("%d",&a[i][j]);

		}

	}

	for(i=1;i<=3;i++)

		dp[1][i]=a[1][i];

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

	{

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

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

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

	}

	int ans=0;

	for(i=1;i<=3;i++)

		ans=max(dp[n][i],ans);

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

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

using namespace std;



#define fr(i,n) _back

#define pb	push_back

#define eb	emplace_back

#define mk	make_pair

#define fi	first

#define se	second

#define endl	'\n'



typedef long long ll;

typedef pair<int,int> ii;

typedef vector<ii> vii;

const int INF = 0x3f3f3f3f;

const double PI = acos(-1.0);

int dp[2][3];



int main() {

    ios_base::sync_with_stdio(false);

    int n; cin >> n;

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

        for(int j = 0; j  < 3; j++) cin >> dp[1][j];

        dp[1][0] += max(dp[0][1],dp[0][2]);

        dp[1][1] += max(dp[0][0],dp[0][2]);

        dp[1][2] += max(dp[0][1],dp[0][0]);

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

    }

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

    return 0;

}


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

#include<algorithm>



using namespace std;



const int maxn = 1e5 + 5;

int dp[maxn][5],a[maxn][4];

int main()

{

	int n,i,j;

	scanf("%d",&n);

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

	{

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

		{

			scanf("%d",&a[i][j]);

		}

	}

	for(i=1;i<=3;i++)

		dp[1][i]=a[1][i];

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

	{

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

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

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

	}

	int ans=0;

	for(i=1;i<=3;i++)

		ans=max(dp[n][i],ans);

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

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

using namespace std;

int arr[100010][5];

int dp[100010][5];



int vac(int a, int b){

	if(a == 0) return 0;

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

	

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

		if(i != b){

			dp[a][b] = max(dp[a][b], vac(a - 1,i) + arr[a][i]);

		}

	}

	

	return dp[a][b];

}



int main (){

	memset(dp,-1,sizeof dp);

	int n;

	cin >> n;

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

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

	}

	

	

	int ans = 0;

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

		ans = max(ans , vac(n - 1, i) + arr[n][i]);

	}

	

	cout << ans << endl;

	

}

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

#include<algorithm>



using namespace std;



const int maxn = 1e5 + 5;

int dp[maxn][5],a[maxn][4];

int main()

{

	int n,i,j;

	scanf("%d",&n);

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

	{

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

		{

			scanf("%d",&a[i][j]);

		}

	}

	for(i=1;i<=3;i++)

		dp[1][i]=a[1][i];

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

	{

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

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

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

	}

	int ans=0;

	for(i=1;i<=3;i++)

		ans=max(dp[n][i],ans);

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

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

using namespace std;

int n,a[100010][5],dp[100010][5];



int main()

{

	scanf("%d",&n);

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

	{

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

	}

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

	{

		dp[1][i] = a[1][i];

	}

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

	{

	//	printf("%d. ",i);

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

		{

			dp[i][j] = -1;

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

			{

			//	printf("%d %d : %d %d\n",i,j,dp[i-1][j]+a[i][k],a[i][k]);

				if(j!=k)

				{

					dp[i][j] = max(dp[i][j],dp[i-1][k]+a[i][j]);

				}

			}

			//printf("%d ",dp[i][j]);

		}

		//printf("\n");

	}

	printf("%d\n",max(dp[n][0],max(dp[n][1],dp[n][2])));

	return 0;

}

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

#include<algorithm>



using namespace std;



const int maxn = 1e5 + 5;

int dp[maxn][5],a[maxn][4];

int main()

{

	int n,i,j;

	scanf("%d",&n);

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

	{

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

		{

			scanf("%d",&a[i][j]);

		}

	}

	for(i=1;i<=3;i++)

		dp[1][i]=a[1][i];

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

	{

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

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

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

	}

	int ans=0;

	for(i=1;i<=3;i++)

		ans=max(dp[n][i],ans);

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

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

#include<iostream>

#include<algorithm>

#include<queue>

#define inf 0x3f3f3f3f

using namespace std;

typedef long long LL;

const int maxn = 1e5+5;



int a[maxn],b[maxn],c[maxn],dp[maxn][3];



int main(){

	int n;

	scanf("%d",&n);

	int m;

	for(int i = 1; i <= n; i++) scanf("%d %d %d", &a[i],&b[i],&c[i]);

	dp[1][0] = a[1]; dp[1][1] = b[1]; dp[1][2] = c[1];

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

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

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

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

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

		}

	}

	m = max(dp[n][0], dp[n][1]);

	m = max(m, dp[n][2]);

	printf("%d",m);

}

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

#include<algorithm>



using namespace std;



const int maxn = 1e5 + 5;

int dp[maxn][5],a[maxn][4];

int main()

{

	int n,i,j;

	scanf("%d",&n);

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

	{

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

		{

			scanf("%d",&a[i][j]);

		}

	}

	for(i=1;i<=3;i++)

		dp[1][i]=a[1][i];

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

	{

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

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

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

	}

	int ans=0;

	for(i=1;i<=3;i++)

		ans=max(dp[n][i],ans);

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

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



using namespace std;



int main() {

    vector<vector<int>> anpan;

    int n, k = -1;

    cin >> n;

    vector<int> zerad = {0};

        anpan.push_back(zerad);

        anpan.push_back(zerad);

        anpan.push_back(zerad);



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

        int a, b, c;

        cin >> a >> b >> c;

        anpan[0].push_back(max(anpan[1][i], anpan[2][i]) + a);

        anpan[1].push_back(max(anpan[0][i], anpan[2][i]) + b);

        anpan[2].push_back(max(anpan[0][i], anpan[1][i]) + c);

    }

    cout << max(anpan[0][n], max(anpan[1][n], anpan[2][n])) << endl;

}

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

#include<algorithm>



using namespace std;



const int maxn = 1e5 + 5;

int dp[maxn][5],a[maxn][4];

int main()

{

	int n,i,j;

	scanf("%d",&n);

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

	{

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

		{

			scanf("%d",&a[i][j]);

		}

	}

	for(i=1;i<=3;i++)

		dp[1][i]=a[1][i];

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

	{

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

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

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

	}

	int ans=0;

	for(i=1;i<=3;i++)

		ans=max(dp[n][i],ans);

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

}