using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ABC88D
{
    class Program
    {
        static void Main(string[] args)
        {
            EDPC.C_Vacation();
        }

        class EDPC
        {
            public static void B_Frog2()
            {
                var NK = ReadIntN();
                int N = NK[0];
                int K = NK[1];
                var Hs = ReadIntN();
                int inf = 100000;

                var dp = new long[N];

                for (int i = 1; i < dp.Length; i++)
                {
                    dp[i] = (long)Math.Pow(10,10);
                }

                for (int i = 0; i < N-1; i++)
                {
                    for (int j = i+1; j <= Math.Min(i+K,N-1); j++)
                    {
                        dp[j] = Math.Min(dp[j],dp[i]+Math.Abs(Hs[j] - Hs[i]));
                    }
                }

                Console.WriteLine(dp[N-1]);
                Console.ReadLine();
            }

            public static void C_Vacation()
            {
                #region Read
                int N = ReadInt();
                var happinesses = new int[N][];
                for (int i = 0; i < N; i++)
                {
                    happinesses[i] = ReadIntN();
                }
                #endregion

                var dp = new int[N][];
                dp[0] = happinesses[0];

                for (int i = 1; i < N; i++)
                {
                    dp[i] = new int[3];

                    dp[i][0] = Math.Max(dp[i - 1][1], dp[i - 1][2]) + happinesses[i][0];
                    dp[i][1] = Math.Max(dp[i - 1][2], dp[i - 1][0]) + happinesses[i][1];
                    dp[i][2] = Math.Max(dp[i - 1][0], dp[i - 1][1]) + happinesses[i][2];
                }

                Console.WriteLine(Math.Max(Math.Max(dp[N - 1][0], dp[N - 1][1]), dp[N - 1][2]));
                Console.ReadLine();
            }
        }

        #region Reader
        static string ReadStr()
        {
            return Console.ReadLine();
        }
        static string[] ReadStrN()
        {
            return Console.ReadLine().Split(' ');
        }
        static int ReadInt()
        {
            return Convert.ToInt32(Console.ReadLine());
        }
        static int[] ReadIntN()
        {
            return Console.ReadLine().Split(' ').Select(s => Convert.ToInt32(s)).ToArray();
        }
        static long ReadLong()
        {
            return Convert.ToInt64(Console.ReadLine());
        }
        static long[] ReadLongN()
        {
            return Console.ReadLine().Split(' ').Select(s => Convert.ToInt64(s)).ToArray();
        }
        static long[,] ReadLongMatrix(int r, int c)
        {
            var mat = new long[r, c];
            for (int i = 0; i < r; ++i)
            {
                var x = ReadLongN();
                for (int j = 0; j < c; ++j)
                {
                    mat[i, j] = x[j];
                }
            }
            return mat;
        }
        static Tuple<string, string>[] ReadTupleStr(int n)
        {
            List<Tuple<string, string>> list = new List<Tuple<string, string>>();
            for (int i = 0; i < n; ++i)
            {
                var ab = ReadStrN();
                list.Add(new Tuple<string, string>(ab[0], ab[1]));
            }
            return list.ToArray();
        }
        static Tuple<long, long>[] ReadTupleLong(int n)
        {
            List<Tuple<long, long>> list = new List<Tuple<long, long>>();
            for (int i = 0; i < n; ++i)
            {
                var ab = ReadLongN();
                list.Add(new Tuple<long, long>(ab[0], ab[1]));
            }
            return list.ToArray();
        }
        static Tuple<int, int>[] ReadTupleInt(int n)
        {
            List<Tuple<int, int>> list = new List<Tuple<int, int>>();
            for (int i = 0; i < n; ++i)
            {
                var ab = ReadIntN();
                list.Add(new Tuple<int, int>(ab[0], ab[1]));
            }
            return list.ToArray();
        }
        static Tuple<double, double>[] ReadTupleDouble(int n)
        {
            List<Tuple<double, double>> list = new List<Tuple<double, double>>();
            for (int i = 0; i < n; ++i)
            {
                var ab = ReadLongN();
                list.Add(new Tuple<double, double>(ab[0], ab[1]));
            }
            return list.ToArray();
        }
        static Dictionary<int, HashSet<int>> ReadAdjacencyList(int N, int M)
        {
            Dictionary<int, HashSet<int>> dict = new Dictionary<int, HashSet<int>>();
            for (int i = 0; i <= N; ++i)
            {
                dict.Add(i, new HashSet<int>());
            }
            for (int i = 0; i < M; ++i)
            {
                var ab = ReadIntN();
                dict[ab[0]].Add(ab[1]);
                dict[ab[1]].Add(ab[0]);
            }
            return dict;
        }
        #endregion
    }
}


Measured memory_bytes: 30252