/**
*   @author: Kshitiz Srivastava (Pirate_ksh) @ MNNIT Allahabad
*/
#include<bits/stdc++.h>
using namespace std;
 
// General
#define ll long long
#define io ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL);
#define mod 1000000007
#define mod9 998244353 
#define endl "\n"
#define debug(x) cout<<x<<endl
#define REP(i,n) for(i=0;i<n;++i)
#define FOR(i,x,n) for(i=x;i<n;++i)
 
// Bounds
#define lb(a, x) a.lower_bound(x)
#define ub(a, x) a.upper_bound(x)
#define all(a) a.begin(),a.end()
 
// Vector
#define vi vector <int>
#define pb(v, x) v.push_back(x)
#define vsi vector <set <int> >
 
// Map
#define mii map <int, int>
 
// Set
#define si set <int>
 
// Pair
#define vpii vector<pair < int, int > >
#define pii pair < int, int >
#define F first
#define S second
 
 
ll power_Mod(ll x, ll y) {
    ll res = 1;
    while (y > 0){
        if (y & 1)
            res = ((res % (ll)mod) * (x % (ll)mod)) % (ll)mod;
        y = y>>1;
        x = ((x % (ll)mod)*(x % (ll)mod)) % (ll)mod;
    }
    return res;
}
 
ll power(ll x, ll y) {
    ll res = 1;
    while (y > 0) {
        if (y & 1)
            res = res * x;
        y = y>>1;
        x = x * x;
    }
    return res;
}
 
int is_palin(string s) {
    int i, len = s.length();
    for(i = 0; i < len/2; i++)
        if(s[i] != s[len - i - 1])
            break;
    if(i == len/2) return 1;
    else return 0;
}
 
ll ceiling(double d) {
    ll d_ = (ll)d;
    if(d == d_)
        return d_;
    else
        return d_ + 1;
}
 
ll flooring(double d) {
    ll d_ = (ll)d;
    return d_;
}
 
void showSet(set<int> s) {
    si::iterator it;
    it = s.begin();
    while(it != s.end()) {
        cout << (*it) << " ";
        it++;
    }
    cout << endl;
}
 
bool cmp(string a, string b) {
    ll x = a.length();
    ll y = b.length();
    // if(x != y) return x < y;
    return x < y;
}

/*******************
    NUMBER THEORY
********************/

void prime_factors(int n) {
    for(int i=2;i*i<=n;i++) {
        if(n%i==0) {
            cout << i << " ";
            while(n%i==0)  n/=i;
        }
    }
    if(n>1) cout << n << " ";
}   

bool is_prime(int n) {
    int i, flag=0;
    for(i = 2; i * i <= n; i++) {
        if(n % i == 0) {
                flag=1;
            break;
        }
    }
    if(flag==1) return false;
    return true;
}
 
// bool prime[1000000+1]; 
// void SieveOfEratosthenes() 
// { 
//     memset(prime, true, sizeof(prime)); 
//     for (int p=2; p*p<=1000000+1; p++) 
//     { 
//         if (prime[p] == true) 
//         { 
//             for (int i=p*p; i<=1000000+1; i += p) 
//                 prime[i] = false; 
//         } 
//     } 
// } 

/**********************
    NUMBER THEORY ENDS
***********************/
 
/*****************************
    FOR C(n, r) and P(n, r)
*****************************/
/*
ll fact[1000000 + 1];
ll invfact[1000000 + 1];
void calcFact() {
    fact[0] = 1;
    for(ll i = 1; i <= 1000000; i++)
        fact[i] = ((fact[i - 1] % mod) * (i % mod) ) % mod;
}
 
void calcInvFact() {
    invfact[0] = 1;
    for(ll i = 1; i <= 1000000; i++)
        invfact[i] = (power_moD(fact[i], mod - 2) % mod);
}
 
ll nCr(ll n, ll r) {
    return ((((fact[n] % mod) * (invfact[r] % mod)) % mod) * (invfact[n-r] % mod) ) % mod;
}
*/
/*****************************
    C(n, r) and P(n, r) ENDS
*****************************/
 
/*************************
     GRAPH ALGORITHMS
**************************/
// bool visited[100000+1] = {false};
/* Depth First Search */
// void dfs(vi graph[], int n) {
//     visited[n] = true;
//     ll size = graph[n].size();
//     for(int i: graph[n]) {
//         if(!visited[i]) {
//             dfs(graph, i);
//         }
//     }
// }
/* Breadth First Search */
// queue<int> Q;
// void bfs(vi graph[], int n) {
//     int v;
//     Q.push(n);
//     visited[n] = true;
//     while(!Q.empty()) {
//         v = Q.front();
//         Q.pop();
//         for(int i: graph[v]) {
//             if(!visited[i]){
//                 visited[i] = true;
//                 Q.push(i);    
//             }
//         }
//     }
//  }
 
// void add_edge(vi graph[], int a, int b) {
//     pb(graph[a], b);
//     pb(graph[b], a);
// }

/* Disjoint Set Union (DSU) */
// vi size(100000+1, 1);
// vi graph(100000+1);
// int root(int i) {
//     // Finding root of any element
//     while(graph[i] != i) {
//         graph[i] = graph[graph[i]]; // Path compression
//         i = graph[i];
//     }
//     return i;
// }

// bool find_(int p, int q) {
//     // Check whether two elements are in same subset
//     int root_p = root(p);
//     int root_q = root(q);
//     if(root_p == root_q) return true;
//     return false;
// }

// void dsu(int p, int q) {
//     // Union of two elements
//     int root_p = root(p);
//     int root_q = root(q);
//     if(!find_(p, q)) {
//         if(size[root_p] > size[root_q]) {
//             // root of p will be ultimate root
//             graph[root_q] = root_p;
//             size[root_p] += size[root_q];
//         }
//         else {
//             // root of q will be ultimate root
//             graph[root_p] = root_q;
//             size[root_q] += size[root_p];
//         }
//     }
// }

/*******************
   GRAPH ALGO ENDS
*******************/
// int bits[32] = {0};
// mii chk;
// void countSetBits(int n) {
//     int  i = 0;
//     int temp = n;
//     while(temp) {
//         if(temp&1){
//             bits[i]++;
//             chk[i] = n;
//         } 
//         temp>>=1;
//         ++i;
//     }
// }

int main(){
    io;
    ll t, n, i, j;
    t=1;
    // cin >> t;
    while(t--) {
        cin >> n;
        vi a(n), b(n), c(n);
        REP(i, n) cin >> a[i] >> b[i] >> c[i];
        int dp[n][3];
        dp[0][0] = a[0];
        dp[0][1] = b[0];
        dp[0][2] = c[0];
        FOR(i, 1, n) {
            dp[i][0] = a[i] + max(dp[i-1][1], dp[i-1][2]);
            dp[i][1] = b[i] + max(dp[i-1][0], dp[i-1][2]);
            dp[i][2] = c[i] + max(dp[i-1][1], dp[i-1][0]);
        }

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

Measured memory_bytes: 2560