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

using namespace std;

typedef long long ll;

typedef long long int lli;

typedef long double ld;

const int oo = 1e9;



int n;

const int nx = 1e5+5;

int ac[nx][3];

int dp[3][nx];

int go(int x, int i){

	if(i==n) return 0;

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

	int& ans = dp[x][i];

	if(x==0)

	{

		ans=max(ans, go(1, i+1)+ac[i][0]);

		ans=max(ans, go(2, i+1)+ac[i][0]);

	}

	if(x==1)

	{

		ans=max(ans, go(0, i+1)+ac[i][1]);

		ans=max(ans, go(2, i+1)+ac[i][1]);

	}

	if(x==2)

	{

		ans=max(ans, go(0, i+1)+ac[i][2]);

		ans=max(ans, go(1, i+1)+ac[i][2]);

	}

	

	return ans;

	

}

int main(){

    cin>>n;

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

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

    }

    memset(dp, -1, sizeof dp);

    cout<<max(go(0,0), max(go(1,0),go(2,0)))<<"\n";

    return 0;

}

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



using namespace std;



int choose(const int &day, const int &last_activity, const int activities[][3], const int &n, int memo[][4]){

    int ans;

    if(day == n){

        ans = 0;

    }

    else{

        if(memo[day][last_activity] != -1){

            ans = memo[day][last_activity];

        }

        else if(last_activity == 0){

            ans = memo[day][0] = max(activities[day][0] + choose(day + 1, 1, activities, n, memo), max(activities[day][1] + choose(day + 1, 2, activities, n, memo), activities[day][2] + choose(day + 1, 3, activities, n, memo)));

        }

        else if(last_activity == 1){

            ans = memo[day][1] = max(activities[day][1] + choose(day + 1, 2, activities, n, memo), activities[day][2] + choose(day + 1, 3, activities, n, memo));

        }

        else if(last_activity == 2){

            ans = memo[day][2] = max(activities[day][0] + choose(day + 1, 1, activities, n, memo), activities[day][2] + choose(day + 1, 3, activities, n, memo));

        }

        else{

            ans = memo[day][3] = max(activities[day][0] + choose(day + 1, 1, activities, n, memo), activities[day][1] + choose(day + 1, 2, activities, n, memo));

        }

    }

    return ans;

}



int solve(const int activities[][3], const int &n, int memo[][4]){

    return choose(0, 0, activities, n, memo);

}



int main(){

    int n;

    while(scanf("%d", &n) != EOF){

        int activities[n][3], memo[n][4];

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

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

            memo[i][0] = -1; memo[i][1] = -1; memo[i][2] = -1; memo[i][3] = -1;

        }

        printf("%d\n", solve(activities, n, memo));

    }

    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: 4.235483054542686x):
#include <bits/stdc++.h>



using namespace std;



int choose(const int &day, const int &last_activity, const int activities[][3], const int &n, int memo[][4]){

    int ans;

    if(day == n){

        ans = 0;

    }

    else{

        if(memo[day][last_activity] != -1){

            ans = memo[day][last_activity];

        }

        else if(last_activity == 0){

            ans = memo[day][0] = max(activities[day][0] + choose(day + 1, 1, activities, n, memo), max(activities[day][1] + choose(day + 1, 2, activities, n, memo), activities[day][2] + choose(day + 1, 3, activities, n, memo)));

        }

        else if(last_activity == 1){

            ans = memo[day][1] = max(activities[day][1] + choose(day + 1, 2, activities, n, memo), activities[day][2] + choose(day + 1, 3, activities, n, memo));

        }

        else if(last_activity == 2){

            ans = memo[day][2] = max(activities[day][0] + choose(day + 1, 1, activities, n, memo), activities[day][2] + choose(day + 1, 3, activities, n, memo));

        }

        else{

            ans = memo[day][3] = max(activities[day][0] + choose(day + 1, 1, activities, n, memo), activities[day][1] + choose(day + 1, 2, activities, n, memo));

        }

    }

    return ans;

}



int solve(const int activities[][3], const int &n, int memo[][4]){

    return choose(0, 0, activities, n, memo);

}



int main(){

    int n;

    while(scanf("%d", &n) != EOF){

        int activities[n][3], memo[n][4];

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

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

            memo[i][0] = -1; memo[i][1] = -1; memo[i][2] = -1; memo[i][3] = -1;

        }

        printf("%d\n", solve(activities, n, memo));

    }

    return 0;

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

using namespace std;

#define ll long long

ll a[100009],b[100009],c[100009];

int dp[100009][3];

int main() {

    ios::sync_with_stdio(false);

    int n;cin>>n;

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

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

    memset(dp,0x3f, sizeof(dp));

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

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

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

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

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

    }

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

    return 0;

}


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



using namespace std;



int choose(const int &day, const int &last_activity, const int activities[][3], const int &n, int memo[][4]){

    int ans;

    if(day == n){

        ans = 0;

    }

    else{

        if(memo[day][last_activity] != -1){

            ans = memo[day][last_activity];

        }

        else if(last_activity == 0){

            ans = memo[day][0] = max(activities[day][0] + choose(day + 1, 1, activities, n, memo), max(activities[day][1] + choose(day + 1, 2, activities, n, memo), activities[day][2] + choose(day + 1, 3, activities, n, memo)));

        }

        else if(last_activity == 1){

            ans = memo[day][1] = max(activities[day][1] + choose(day + 1, 2, activities, n, memo), activities[day][2] + choose(day + 1, 3, activities, n, memo));

        }

        else if(last_activity == 2){

            ans = memo[day][2] = max(activities[day][0] + choose(day + 1, 1, activities, n, memo), activities[day][2] + choose(day + 1, 3, activities, n, memo));

        }

        else{

            ans = memo[day][3] = max(activities[day][0] + choose(day + 1, 1, activities, n, memo), activities[day][1] + choose(day + 1, 2, activities, n, memo));

        }

    }

    return ans;

}



int solve(const int activities[][3], const int &n, int memo[][4]){

    return choose(0, 0, activities, n, memo);

}



int main(){

    int n;

    while(scanf("%d", &n) != EOF){

        int activities[n][3], memo[n][4];

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

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

            memo[i][0] = -1; memo[i][1] = -1; memo[i][2] = -1; memo[i][3] = -1;

        }

        printf("%d\n", solve(activities, n, memo));

    }

    return 0;

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

using namespace std;

const int mx=100010;

int arr[mx][3],n;

int dp[mx][3];

int f(int pos,int ty){

	if(pos==n)return 0;

	int &ans=dp[pos][ty];

	if(ans^-1)return ans;

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

		if(ty^i){

			ans=max(ans,f(pos+1,i)+arr[pos][i]);

		}

	}

	return ans;

}



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

{

	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];

		}

	}

	cout<<max({f(0,0),f(0,1),f(0,2)})<<endl;



	return 0;

}

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



using namespace std;



int choose(const int &day, const int &last_activity, const int activities[][3], const int &n, int memo[][4]){

    int ans;

    if(day == n){

        ans = 0;

    }

    else{

        if(memo[day][last_activity] != -1){

            ans = memo[day][last_activity];

        }

        else if(last_activity == 0){

            ans = memo[day][0] = max(activities[day][0] + choose(day + 1, 1, activities, n, memo), max(activities[day][1] + choose(day + 1, 2, activities, n, memo), activities[day][2] + choose(day + 1, 3, activities, n, memo)));

        }

        else if(last_activity == 1){

            ans = memo[day][1] = max(activities[day][1] + choose(day + 1, 2, activities, n, memo), activities[day][2] + choose(day + 1, 3, activities, n, memo));

        }

        else if(last_activity == 2){

            ans = memo[day][2] = max(activities[day][0] + choose(day + 1, 1, activities, n, memo), activities[day][2] + choose(day + 1, 3, activities, n, memo));

        }

        else{

            ans = memo[day][3] = max(activities[day][0] + choose(day + 1, 1, activities, n, memo), activities[day][1] + choose(day + 1, 2, activities, n, memo));

        }

    }

    return ans;

}



int solve(const int activities[][3], const int &n, int memo[][4]){

    return choose(0, 0, activities, n, memo);

}



int main(){

    int n;

    while(scanf("%d", &n) != EOF){

        int activities[n][3], memo[n][4];

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

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

            memo[i][0] = -1; memo[i][1] = -1; memo[i][2] = -1; memo[i][3] = -1;

        }

        printf("%d\n", solve(activities, n, memo));

    }

    return 0;

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

#define p5 100005

using namespace std;



int dp[p5][4],a[p5][4];

int n;



int solve(int day,int state)

{

    if(day==n) return a[day][state];

    if(dp[day][state]!=-1) return dp[day][state];

    int cost=a[day][state];

    if(state==1) cost+=max(solve(day+1,2),solve(day+1,3));

    else if(state==2) cost+=max(solve(day+1,1),solve(day+1,3));

    else if(state==3) cost+=max(solve(day+1,1),solve(day+1,2));

    else cost=max( solve(day+1,1), max(solve(day+1,2),solve(day+1,3)) );



    return dp[day][state]=cost;

}



int main()

{

    scanf("%d",&n);

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

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

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



    return 0;

}


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



using namespace std;



int choose(const int &day, const int &last_activity, const int activities[][3], const int &n, int memo[][4]){

    int ans;

    if(day == n){

        ans = 0;

    }

    else{

        if(memo[day][last_activity] != -1){

            ans = memo[day][last_activity];

        }

        else if(last_activity == 0){

            ans = memo[day][0] = max(activities[day][0] + choose(day + 1, 1, activities, n, memo), max(activities[day][1] + choose(day + 1, 2, activities, n, memo), activities[day][2] + choose(day + 1, 3, activities, n, memo)));

        }

        else if(last_activity == 1){

            ans = memo[day][1] = max(activities[day][1] + choose(day + 1, 2, activities, n, memo), activities[day][2] + choose(day + 1, 3, activities, n, memo));

        }

        else if(last_activity == 2){

            ans = memo[day][2] = max(activities[day][0] + choose(day + 1, 1, activities, n, memo), activities[day][2] + choose(day + 1, 3, activities, n, memo));

        }

        else{

            ans = memo[day][3] = max(activities[day][0] + choose(day + 1, 1, activities, n, memo), activities[day][1] + choose(day + 1, 2, activities, n, memo));

        }

    }

    return ans;

}



int solve(const int activities[][3], const int &n, int memo[][4]){

    return choose(0, 0, activities, n, memo);

}



int main(){

    int n;

    while(scanf("%d", &n) != EOF){

        int activities[n][3], memo[n][4];

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

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

            memo[i][0] = -1; memo[i][1] = -1; memo[i][2] = -1; memo[i][3] = -1;

        }

        printf("%d\n", solve(activities, n, memo));

    }

    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: 9.454574583398243x):
#include <bits/stdc++.h>



using namespace std;



int choose(const int &day, const int &last_activity, const int activities[][3], const int &n, int memo[][4]){

    int ans;

    if(day == n){

        ans = 0;

    }

    else{

        if(memo[day][last_activity] != -1){

            ans = memo[day][last_activity];

        }

        else if(last_activity == 0){

            ans = memo[day][0] = max(activities[day][0] + choose(day + 1, 1, activities, n, memo), max(activities[day][1] + choose(day + 1, 2, activities, n, memo), activities[day][2] + choose(day + 1, 3, activities, n, memo)));

        }

        else if(last_activity == 1){

            ans = memo[day][1] = max(activities[day][1] + choose(day + 1, 2, activities, n, memo), activities[day][2] + choose(day + 1, 3, activities, n, memo));

        }

        else if(last_activity == 2){

            ans = memo[day][2] = max(activities[day][0] + choose(day + 1, 1, activities, n, memo), activities[day][2] + choose(day + 1, 3, activities, n, memo));

        }

        else{

            ans = memo[day][3] = max(activities[day][0] + choose(day + 1, 1, activities, n, memo), activities[day][1] + choose(day + 1, 2, activities, n, memo));

        }

    }

    return ans;

}



int solve(const int activities[][3], const int &n, int memo[][4]){

    return choose(0, 0, activities, n, memo);

}



int main(){

    int n;

    while(scanf("%d", &n) != EOF){

        int activities[n][3], memo[n][4];

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

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

            memo[i][0] = -1; memo[i][1] = -1; memo[i][2] = -1; memo[i][3] = -1;

        }

        printf("%d\n", solve(activities, n, memo));

    }

    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: 7.189761439602953x):
#include <bits/stdc++.h>



using namespace std;



int choose(const int &day, const int &last_activity, const int activities[][3], const int &n, int memo[][4]){

    int ans;

    if(day == n){

        ans = 0;

    }

    else{

        if(memo[day][last_activity] != -1){

            ans = memo[day][last_activity];

        }

        else if(last_activity == 0){

            ans = memo[day][0] = max(activities[day][0] + choose(day + 1, 1, activities, n, memo), max(activities[day][1] + choose(day + 1, 2, activities, n, memo), activities[day][2] + choose(day + 1, 3, activities, n, memo)));

        }

        else if(last_activity == 1){

            ans = memo[day][1] = max(activities[day][1] + choose(day + 1, 2, activities, n, memo), activities[day][2] + choose(day + 1, 3, activities, n, memo));

        }

        else if(last_activity == 2){

            ans = memo[day][2] = max(activities[day][0] + choose(day + 1, 1, activities, n, memo), activities[day][2] + choose(day + 1, 3, activities, n, memo));

        }

        else{

            ans = memo[day][3] = max(activities[day][0] + choose(day + 1, 1, activities, n, memo), activities[day][1] + choose(day + 1, 2, activities, n, memo));

        }

    }

    return ans;

}



int solve(const int activities[][3], const int &n, int memo[][4]){

    return choose(0, 0, activities, n, memo);

}



int main(){

    int n;

    while(scanf("%d", &n) != EOF){

        int activities[n][3], memo[n][4];

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

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

            memo[i][0] = -1; memo[i][1] = -1; memo[i][2] = -1; memo[i][3] = -1;

        }

        printf("%d\n", solve(activities, n, memo));

    }

    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: 4.216152063089177x):
#include <bits/stdc++.h>



using namespace std;



int choose(const int &day, const int &last_activity, const int activities[][3], const int &n, int memo[][4]){

    int ans;

    if(day == n){

        ans = 0;

    }

    else{

        if(memo[day][last_activity] != -1){

            ans = memo[day][last_activity];

        }

        else if(last_activity == 0){

            ans = memo[day][0] = max(activities[day][0] + choose(day + 1, 1, activities, n, memo), max(activities[day][1] + choose(day + 1, 2, activities, n, memo), activities[day][2] + choose(day + 1, 3, activities, n, memo)));

        }

        else if(last_activity == 1){

            ans = memo[day][1] = max(activities[day][1] + choose(day + 1, 2, activities, n, memo), activities[day][2] + choose(day + 1, 3, activities, n, memo));

        }

        else if(last_activity == 2){

            ans = memo[day][2] = max(activities[day][0] + choose(day + 1, 1, activities, n, memo), activities[day][2] + choose(day + 1, 3, activities, n, memo));

        }

        else{

            ans = memo[day][3] = max(activities[day][0] + choose(day + 1, 1, activities, n, memo), activities[day][1] + choose(day + 1, 2, activities, n, memo));

        }

    }

    return ans;

}



int solve(const int activities[][3], const int &n, int memo[][4]){

    return choose(0, 0, activities, n, memo);

}



int main(){

    int n;

    while(scanf("%d", &n) != EOF){

        int activities[n][3], memo[n][4];

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

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

            memo[i][0] = -1; memo[i][1] = -1; memo[i][2] = -1; memo[i][3] = -1;

        }

        printf("%d\n", solve(activities, n, memo));

    }

    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: 3.5830932951282866x):
#include <bits/stdc++.h>



using namespace std;



typedef long long lint;

const lint N = 1e5+100;

lint n, happiness[N][3], abc[N][3];



int main(){

#ifdef LOCAL

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

#endif



	scanf("%lld", &n);



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

		scanf("%lld %lld %lld", &abc[i][0], &abc[i][1], &abc[i][2]);

	}



	happiness[0][0] = abc[0][0]; happiness[0][1] = abc[0][1]; happiness[0][2] = abc[0][2];



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

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

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

			else if (j==1) happiness[i][j] = max(happiness[i-1][0] + abc[i][j], happiness[i-1][2] + abc[i][j]);

			else happiness[i][j] = max(happiness[i-1][1] + abc[i][j], happiness[i-1][2] + abc[i][j]);

		}

	}

	

	printf("%lld\n", max(happiness[n-1][0], max(happiness[n-1][1], happiness[n-1][2])));



	return 0; 

}