// Slower C++ solution:
/**

 * @author      : Luis Miguel Baez <es.luismiguelbaez@gmail.com>

 * @created     : Thursday August 13, 2020

 */



#include <bits/stdc++.h>



using namespace std;



#define endl '\n'

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

#define rall(x) (x).rbegin(), (x).rend()

#define ms(arr, value) memset(arr, value, sizeof arr)

#define ll    int64_t



#define pii   pair<int, int>

#define piii  tuple<int, int, int>

#define pll   pair<ll, ll>

#define plll  tuple<ll, ll, ll>



#define F  first

#define S  second



const int oo  = (int)(1e9);

const ll lloo  = (ll)(1e18);



const int N = int(1e5) + 10;



class Task {

public:



    int n;

    vector<piii> A;



    ll dp[N][4];





    ll go(int index, int last) {

        if(index > n) return 0LL;

        ll &ans = dp[index][last];

        if(ans != -1) return ans;

        ll x=0, y=0;

        if(last == 1) {

            x = get<1>(A[index]) + go(index+1, 2);

            y = get<2>(A[index]) + go(index+1, 3);

        } else if(last == 2) {

            x = get<0>(A[index]) + go(index+1, 1);

            y = get<2>(A[index]) + go(index+1, 3);

        } else if(last == 3) {

            x = get<0>(A[index]) + go(index+1, 1);

            y = get<1>(A[index]) + go(index+1, 2);

        } else {

            ll z = 0;

            x = get<0>(A[index]) + go(index+1, 1);

            y = get<1>(A[index]) + go(index+1, 2);

            z = get<2>(A[index]) + go(index+1, 3);

            x = max(x, z);

        }

        ans = max(x, y);

        return ans;

    }



    ll solveOne(istream &in, ostream &out) {

        int a, b, c;

        in >> n;

        A.resize(n+1);

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

            in >> a >> b >> c;

            A[i] = {a, b, c};

        }

        memset(dp, -1, sizeof dp);

        ll ans = go(1, -1);

        return ans;  

    }

    

    void solve(istream &in, ostream &out) {

        int t = 1;

        while(t--) {

            out << solveOne(in, out) << endl;

        }

    }

};



auto main() -> int {

    ios_base::sync_with_stdio(false);

    cin.tie(NULL);

    cout.tie(NULL);

    

    Task solver;

    istream &in(cin);

    ostream &out(cout);

    solver.solve(in, out);

    return 0;

}

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

using namespace std;

int ara[100005][3];

int dp[100005][3];



int func(int pos,int des,int idx){

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

    int res;

    if(pos>des) res=0;

    else{

        int t1,t2;

        if(idx==0){

            t1=ara[pos][0]+func(pos+1,des,1);

            t2=ara[pos][0]+func(pos+1,des,2);

        }

        else if(idx==1){

             t1=ara[pos][1]+func(pos+1,des,0);

            t2=ara[pos][1]+func(pos+1,des,2);

        }

        else{

             t1=ara[pos][2]+func(pos+1,des,1);

            t2=ara[pos][2]+func(pos+1,des,0);

        }

        res=max(t1,t2);

    }

    dp[pos][idx]=res;

    return res;

}

int main(){

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

    int n,x,y,z;

    cin >> n;

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

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

    }

    x=func(1,n,0);

    y=func(1,n,1);

    z=func(1,n,2);

    int ans;

    

    ans=max(x,y);

    ans=max(ans,z);

    

    cout << ans << endl;

    

}