stablegradients/pie-gem5-pairs huggingface dataset:
// 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.188137583314871x):
#include<stdio.h>

#include<stdlib.h>



#define get(a, i, j) *((*(a+i))+j)





typedef long long ll;



//long long **mem, **util, N;

ll mem[100001][3], util[100001][3], N;



ll dp(ll d, ll u);



int main()

{

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



    ll i, max, temp_util;



    //util = (ll**) malloc(N * sizeof(ll*));

    //mem = (ll**) malloc(N * sizeof(ll*));



    scanf("%lld", &N);



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

        //*(util+i) = (ll*) malloc(3 * sizeof(ll));

        //*(mem+i) = (ll*) calloc(3, sizeof(ll));



        scanf("%lld%lld%lld", &get(util, i, 0), &get(util, i, 1), &get(util, i, 2));

    }





    //printf("%lld\n", dp(0, 0));

    max = 0;

    temp_util = 0;



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

        //printf("calling dp(const 0, %lld)\n", i);

        temp_util = dp(0, i);

        if (max < temp_util) max = temp_util;

    }



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



    return 0;

}





ll dp(ll d, ll u)

{

    //printf("inside dp with d = %lld, u = %lld\n", d, u);

    if (d == N-1) {

        //printf("returning %lld without setting\n\n", get(util, d, u));

        return get(util, d, u);

    }



    if(get(mem, d, u) > 0) {

        //printf("returning %lld without setting\n\n", get(util, d, u));

        return get(mem, d, u);

    }



    ll i, max, temp_util;



    max = 0;

    temp_util = 0;

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

        if(i!=u) temp_util = dp(d+1, i);

        if(temp_util>max) max = temp_util;

    }



    //printf("setting value in mem[%lld][%lld] = %lld (%lld)\n\n", d, u, get(util, d, u)+max, get(util, d, u));

    return get(mem, d, u) = get(util, d, u) + max;

}
// 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.2576358615895895x):
#include<stdio.h>

#include<stdlib.h>



#define get(a, i, j) *((*(a+i))+j)





typedef long long ll;



//long long **mem, **util, N;

ll mem[100001][3], util[100001][3], N;



ll dp(ll d, ll u);



int main()

{

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



    ll i, max, temp_util;



    //util = (ll**) malloc(N * sizeof(ll*));

    //mem = (ll**) malloc(N * sizeof(ll*));



    scanf("%lld", &N);



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

        //*(util+i) = (ll*) malloc(3 * sizeof(ll));

        //*(mem+i) = (ll*) calloc(3, sizeof(ll));



        scanf("%lld%lld%lld", &get(util, i, 0), &get(util, i, 1), &get(util, i, 2));

    }





    //printf("%lld\n", dp(0, 0));

    max = 0;

    temp_util = 0;



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

        //printf("calling dp(const 0, %lld)\n", i);

        temp_util = dp(0, i);

        if (max < temp_util) max = temp_util;

    }



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



    return 0;

}





ll dp(ll d, ll u)

{

    //printf("inside dp with d = %lld, u = %lld\n", d, u);

    if (d == N-1) {

        //printf("returning %lld without setting\n\n", get(util, d, u));

        return get(util, d, u);

    }



    if(get(mem, d, u) > 0) {

        //printf("returning %lld without setting\n\n", get(util, d, u));

        return get(mem, d, u);

    }



    ll i, max, temp_util;



    max = 0;

    temp_util = 0;

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

        if(i!=u) temp_util = dp(d+1, i);

        if(temp_util>max) max = temp_util;

    }



    //printf("setting value in mem[%lld][%lld] = %lld (%lld)\n\n", d, u, get(util, d, u)+max, get(util, d, u));

    return get(mem, d, u) = get(util, d, u) + max;

}
// 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.198663039885372x):
#include<stdio.h>

#include<stdlib.h>



#define get(a, i, j) *((*(a+i))+j)





typedef long long ll;



//long long **mem, **util, N;

ll mem[100001][3], util[100001][3], N;



ll dp(ll d, ll u);



int main()

{

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



    ll i, max, temp_util;



    //util = (ll**) malloc(N * sizeof(ll*));

    //mem = (ll**) malloc(N * sizeof(ll*));



    scanf("%lld", &N);



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

        //*(util+i) = (ll*) malloc(3 * sizeof(ll));

        //*(mem+i) = (ll*) calloc(3, sizeof(ll));



        scanf("%lld%lld%lld", &get(util, i, 0), &get(util, i, 1), &get(util, i, 2));

    }





    //printf("%lld\n", dp(0, 0));

    max = 0;

    temp_util = 0;



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

        //printf("calling dp(const 0, %lld)\n", i);

        temp_util = dp(0, i);

        if (max < temp_util) max = temp_util;

    }



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



    return 0;

}





ll dp(ll d, ll u)

{

    //printf("inside dp with d = %lld, u = %lld\n", d, u);

    if (d == N-1) {

        //printf("returning %lld without setting\n\n", get(util, d, u));

        return get(util, d, u);

    }



    if(get(mem, d, u) > 0) {

        //printf("returning %lld without setting\n\n", get(util, d, u));

        return get(mem, d, u);

    }



    ll i, max, temp_util;



    max = 0;

    temp_util = 0;

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

        if(i!=u) temp_util = dp(d+1, i);

        if(temp_util>max) max = temp_util;

    }



    //printf("setting value in mem[%lld][%lld] = %lld (%lld)\n\n", d, u, get(util, d, u)+max, get(util, d, u));

    return get(mem, d, u) = get(util, d, u) + max;

}
// 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.253005568416485x):
#include<stdio.h>

#include<stdlib.h>



#define get(a, i, j) *((*(a+i))+j)





typedef long long ll;



//long long **mem, **util, N;

ll mem[100001][3], util[100001][3], N;



ll dp(ll d, ll u);



int main()

{

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



    ll i, max, temp_util;



    //util = (ll**) malloc(N * sizeof(ll*));

    //mem = (ll**) malloc(N * sizeof(ll*));



    scanf("%lld", &N);



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

        //*(util+i) = (ll*) malloc(3 * sizeof(ll));

        //*(mem+i) = (ll*) calloc(3, sizeof(ll));



        scanf("%lld%lld%lld", &get(util, i, 0), &get(util, i, 1), &get(util, i, 2));

    }





    //printf("%lld\n", dp(0, 0));

    max = 0;

    temp_util = 0;



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

        //printf("calling dp(const 0, %lld)\n", i);

        temp_util = dp(0, i);

        if (max < temp_util) max = temp_util;

    }



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



    return 0;

}





ll dp(ll d, ll u)

{

    //printf("inside dp with d = %lld, u = %lld\n", d, u);

    if (d == N-1) {

        //printf("returning %lld without setting\n\n", get(util, d, u));

        return get(util, d, u);

    }



    if(get(mem, d, u) > 0) {

        //printf("returning %lld without setting\n\n", get(util, d, u));

        return get(mem, d, u);

    }



    ll i, max, temp_util;



    max = 0;

    temp_util = 0;

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

        if(i!=u) temp_util = dp(d+1, i);

        if(temp_util>max) max = temp_util;

    }



    //printf("setting value in mem[%lld][%lld] = %lld (%lld)\n\n", d, u, get(util, d, u)+max, get(util, d, u));

    return get(mem, d, u) = get(util, d, u) + max;

}
// 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.595323168364443x):
#include<stdio.h>

#include<stdlib.h>



#define get(a, i, j) *((*(a+i))+j)





typedef long long ll;



//long long **mem, **util, N;

ll mem[100001][3], util[100001][3], N;



ll dp(ll d, ll u);



int main()

{

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



    ll i, max, temp_util;



    //util = (ll**) malloc(N * sizeof(ll*));

    //mem = (ll**) malloc(N * sizeof(ll*));



    scanf("%lld", &N);



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

        //*(util+i) = (ll*) malloc(3 * sizeof(ll));

        //*(mem+i) = (ll*) calloc(3, sizeof(ll));



        scanf("%lld%lld%lld", &get(util, i, 0), &get(util, i, 1), &get(util, i, 2));

    }





    //printf("%lld\n", dp(0, 0));

    max = 0;

    temp_util = 0;



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

        //printf("calling dp(const 0, %lld)\n", i);

        temp_util = dp(0, i);

        if (max < temp_util) max = temp_util;

    }



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



    return 0;

}





ll dp(ll d, ll u)

{

    //printf("inside dp with d = %lld, u = %lld\n", d, u);

    if (d == N-1) {

        //printf("returning %lld without setting\n\n", get(util, d, u));

        return get(util, d, u);

    }



    if(get(mem, d, u) > 0) {

        //printf("returning %lld without setting\n\n", get(util, d, u));

        return get(mem, d, u);

    }



    ll i, max, temp_util;



    max = 0;

    temp_util = 0;

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

        if(i!=u) temp_util = dp(d+1, i);

        if(temp_util>max) max = temp_util;

    }



    //printf("setting value in mem[%lld][%lld] = %lld (%lld)\n\n", d, u, get(util, d, u)+max, get(util, d, u));

    return get(mem, d, u) = get(util, d, u) + max;

}
// 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.197685494206102x):
#include<stdio.h>

#include<stdlib.h>



#define get(a, i, j) *((*(a+i))+j)





typedef long long ll;



//long long **mem, **util, N;

ll mem[100001][3], util[100001][3], N;



ll dp(ll d, ll u);



int main()

{

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



    ll i, max, temp_util;



    //util = (ll**) malloc(N * sizeof(ll*));

    //mem = (ll**) malloc(N * sizeof(ll*));



    scanf("%lld", &N);



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

        //*(util+i) = (ll*) malloc(3 * sizeof(ll));

        //*(mem+i) = (ll*) calloc(3, sizeof(ll));



        scanf("%lld%lld%lld", &get(util, i, 0), &get(util, i, 1), &get(util, i, 2));

    }





    //printf("%lld\n", dp(0, 0));

    max = 0;

    temp_util = 0;



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

        //printf("calling dp(const 0, %lld)\n", i);

        temp_util = dp(0, i);

        if (max < temp_util) max = temp_util;

    }



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



    return 0;

}





ll dp(ll d, ll u)

{

    //printf("inside dp with d = %lld, u = %lld\n", d, u);

    if (d == N-1) {

        //printf("returning %lld without setting\n\n", get(util, d, u));

        return get(util, d, u);

    }



    if(get(mem, d, u) > 0) {

        //printf("returning %lld without setting\n\n", get(util, d, u));

        return get(mem, d, u);

    }



    ll i, max, temp_util;



    max = 0;

    temp_util = 0;

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

        if(i!=u) temp_util = dp(d+1, i);

        if(temp_util>max) max = temp_util;

    }



    //printf("setting value in mem[%lld][%lld] = %lld (%lld)\n\n", d, u, get(util, d, u)+max, get(util, d, u));

    return get(mem, d, u) = get(util, d, u) + max;

}
// 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.853987910722648x):
#include<stdio.h>

#include<stdlib.h>



#define get(a, i, j) *((*(a+i))+j)





typedef long long ll;



//long long **mem, **util, N;

ll mem[100001][3], util[100001][3], N;



ll dp(ll d, ll u);



int main()

{

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



    ll i, max, temp_util;



    //util = (ll**) malloc(N * sizeof(ll*));

    //mem = (ll**) malloc(N * sizeof(ll*));



    scanf("%lld", &N);



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

        //*(util+i) = (ll*) malloc(3 * sizeof(ll));

        //*(mem+i) = (ll*) calloc(3, sizeof(ll));



        scanf("%lld%lld%lld", &get(util, i, 0), &get(util, i, 1), &get(util, i, 2));

    }





    //printf("%lld\n", dp(0, 0));

    max = 0;

    temp_util = 0;



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

        //printf("calling dp(const 0, %lld)\n", i);

        temp_util = dp(0, i);

        if (max < temp_util) max = temp_util;

    }



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



    return 0;

}





ll dp(ll d, ll u)

{

    //printf("inside dp with d = %lld, u = %lld\n", d, u);

    if (d == N-1) {

        //printf("returning %lld without setting\n\n", get(util, d, u));

        return get(util, d, u);

    }



    if(get(mem, d, u) > 0) {

        //printf("returning %lld without setting\n\n", get(util, d, u));

        return get(mem, d, u);

    }



    ll i, max, temp_util;



    max = 0;

    temp_util = 0;

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

        if(i!=u) temp_util = dp(d+1, i);

        if(temp_util>max) max = temp_util;

    }



    //printf("setting value in mem[%lld][%lld] = %lld (%lld)\n\n", d, u, get(util, d, u)+max, get(util, d, u));

    return get(mem, d, u) = get(util, d, u) + max;

}
// 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.252314874213836x):
#include<stdio.h>

#include<stdlib.h>



#define get(a, i, j) *((*(a+i))+j)





typedef long long ll;



//long long **mem, **util, N;

ll mem[100001][3], util[100001][3], N;



ll dp(ll d, ll u);



int main()

{

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



    ll i, max, temp_util;



    //util = (ll**) malloc(N * sizeof(ll*));

    //mem = (ll**) malloc(N * sizeof(ll*));



    scanf("%lld", &N);



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

        //*(util+i) = (ll*) malloc(3 * sizeof(ll));

        //*(mem+i) = (ll*) calloc(3, sizeof(ll));



        scanf("%lld%lld%lld", &get(util, i, 0), &get(util, i, 1), &get(util, i, 2));

    }





    //printf("%lld\n", dp(0, 0));

    max = 0;

    temp_util = 0;



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

        //printf("calling dp(const 0, %lld)\n", i);

        temp_util = dp(0, i);

        if (max < temp_util) max = temp_util;

    }



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



    return 0;

}





ll dp(ll d, ll u)

{

    //printf("inside dp with d = %lld, u = %lld\n", d, u);

    if (d == N-1) {

        //printf("returning %lld without setting\n\n", get(util, d, u));

        return get(util, d, u);

    }



    if(get(mem, d, u) > 0) {

        //printf("returning %lld without setting\n\n", get(util, d, u));

        return get(mem, d, u);

    }



    ll i, max, temp_util;



    max = 0;

    temp_util = 0;

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

        if(i!=u) temp_util = dp(d+1, i);

        if(temp_util>max) max = temp_util;

    }



    //printf("setting value in mem[%lld][%lld] = %lld (%lld)\n\n", d, u, get(util, d, u)+max, get(util, d, u));

    return get(mem, d, u) = get(util, d, u) + max;

}
// 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.609996417008592x):
#include<stdio.h>

#include<stdlib.h>



#define get(a, i, j) *((*(a+i))+j)





typedef long long ll;



//long long **mem, **util, N;

ll mem[100001][3], util[100001][3], N;



ll dp(ll d, ll u);



int main()

{

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



    ll i, max, temp_util;



    //util = (ll**) malloc(N * sizeof(ll*));

    //mem = (ll**) malloc(N * sizeof(ll*));



    scanf("%lld", &N);



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

        //*(util+i) = (ll*) malloc(3 * sizeof(ll));

        //*(mem+i) = (ll*) calloc(3, sizeof(ll));



        scanf("%lld%lld%lld", &get(util, i, 0), &get(util, i, 1), &get(util, i, 2));

    }





    //printf("%lld\n", dp(0, 0));

    max = 0;

    temp_util = 0;



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

        //printf("calling dp(const 0, %lld)\n", i);

        temp_util = dp(0, i);

        if (max < temp_util) max = temp_util;

    }



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



    return 0;

}





ll dp(ll d, ll u)

{

    //printf("inside dp with d = %lld, u = %lld\n", d, u);

    if (d == N-1) {

        //printf("returning %lld without setting\n\n", get(util, d, u));

        return get(util, d, u);

    }



    if(get(mem, d, u) > 0) {

        //printf("returning %lld without setting\n\n", get(util, d, u));

        return get(mem, d, u);

    }



    ll i, max, temp_util;



    max = 0;

    temp_util = 0;

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

        if(i!=u) temp_util = dp(d+1, i);

        if(temp_util>max) max = temp_util;

    }



    //printf("setting value in mem[%lld][%lld] = %lld (%lld)\n\n", d, u, get(util, d, u)+max, get(util, d, u));

    return get(mem, d, u) = get(util, d, u) + max;

}
// 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.124799128705484x):
#include<stdio.h>

#include<stdlib.h>



#define get(a, i, j) *((*(a+i))+j)





typedef long long ll;



//long long **mem, **util, N;

ll mem[100001][3], util[100001][3], N;



ll dp(ll d, ll u);



int main()

{

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



    ll i, max, temp_util;



    //util = (ll**) malloc(N * sizeof(ll*));

    //mem = (ll**) malloc(N * sizeof(ll*));



    scanf("%lld", &N);



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

        //*(util+i) = (ll*) malloc(3 * sizeof(ll));

        //*(mem+i) = (ll*) calloc(3, sizeof(ll));



        scanf("%lld%lld%lld", &get(util, i, 0), &get(util, i, 1), &get(util, i, 2));

    }





    //printf("%lld\n", dp(0, 0));

    max = 0;

    temp_util = 0;



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

        //printf("calling dp(const 0, %lld)\n", i);

        temp_util = dp(0, i);

        if (max < temp_util) max = temp_util;

    }



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



    return 0;

}





ll dp(ll d, ll u)

{

    //printf("inside dp with d = %lld, u = %lld\n", d, u);

    if (d == N-1) {

        //printf("returning %lld without setting\n\n", get(util, d, u));

        return get(util, d, u);

    }



    if(get(mem, d, u) > 0) {

        //printf("returning %lld without setting\n\n", get(util, d, u));

        return get(mem, d, u);

    }



    ll i, max, temp_util;



    max = 0;

    temp_util = 0;

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

        if(i!=u) temp_util = dp(d+1, i);

        if(temp_util>max) max = temp_util;

    }



    //printf("setting value in mem[%lld][%lld] = %lld (%lld)\n\n", d, u, get(util, d, u)+max, get(util, d, u));

    return get(mem, d, u) = get(util, d, u) + max;

}