n = int(eval(input()))

abc = []

for _ in range(n):

    abc.append(list(map(int, input().split()))) 



dp = [[0]*3 for _ in range(n)]

dp[0][0] = abc[0][0]

dp[0][1] = abc[0][1]

dp[0][2] = abc[0][2]



for i in range(1,n):

    for j in range(3):

        if j == 0:

            dp[i][j] = max(dp[i-1][1], dp[i-1][2]) + abc[i][j]

        if j == 1:

            dp[i][j] = max(dp[i-1][0], dp[i-1][2]) + abc[i][j]

        if j == 2:

            dp[i][j] = max(dp[i-1][0], dp[i-1][1]) + abc[i][j]

print((max(dp[n-1])))
INF = float("inf")



import sys

sys.setrecursionlimit(10**9)

input = sys.stdin.readline

input_int = lambda:int(eval(input()))

input_ints = lambda:list(map(int,input().split()))

input_ints_list = lambda:list(input_ints())

input_str = lambda:eval(input())

input_strs = lambda:input().split()

input_lines = lambda n,input_func:[input_func() for _ in range(n)]



import importlib

import_module = lambda module_name:importlib.import_module(module_name)



init_array_1dim = lambda value,n:[value]*n # 1次元配列を生成

init_array_2dim = lambda value,n,m:[init_array_1dim(value,n) for _ in range(m)] # 2次元配列を生成



gcd_base = lambda value1,value2:import_module('fractions').gcd(value1,value2) # 最大公約数（2値)

gcd = lambda lst:import_module('functools').reduce(gcd_base,lst) # 最大公約数（リスト）

lcm_base = lambda value1,value2:(value1*value2)//gcd_base(value1,value2) # 最小公倍数(2値)

lcm = lambda lst:import_module('functools').reduce(lcm_base,lst,1) # 最小公倍数(リスト)



permutations = lambda lst,n:import_module('itertools').permutations(lst,n) # 順列

combinations = lambda lst,n:import_module('itertools').combinations(lst,n) # 組み合わせ

product = lambda lst1,lst2:import_module('itertools').product(lst1,lst2) # 二つのリストの直積



round = lambda value:round(value) # 四捨五入

ceil = lambda value:import_module('math').ceil(value) # 切り上げ

floor = lambda value:import_module('math').floor(value) # 切り捨て



# キュー

init_q = lambda lst: import_module('collections').deque(lst)

q_pop = lambda q: q.popleft() # 先頭から取り出し

q_push = lambda q,value:q.appendleft(value) # 先頭に追加（値）

q_pushlist = lambda q,lst:q.extendleft(lst) # 先頭に追加（リスト）

q_append = lambda q,value:q.append(value) # 末尾に追加（値）

q_appendlist = lambda q,lst:q.extend(lst) # 末尾に追加（リスト）



# プライオリティキュー

init_heap = lambda a:import_module('heapq').heapify(a)

heap_push = lambda a,v:import_module('heapq').heappush(a,v)

heap_pop = lambda a:import_module('heapq').heappop(a) # 最小値を取り出す



def solution():

    # ここに実装

    N = input_int()

    abc = input_lines(N,input_ints_list)



    dp = init_array_2dim(-1,3,N)

    for i in range(N):

        if i == 0:

            dp[i][0] = abc[0][0]

            dp[i][1] = abc[0][1]

            dp[i][2] = abc[0][2]

        else:

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

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

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

    print((max(dp[N-1])))

    

if __name__ == '__main__':

    solution()
n = int(eval(input()))
abc = []
for _ in range(n):
    abc.append(list(map(int, input().split())))
dp = [[0] * 3 for _ in range(n)]
dp[0][0] = abc[0][0]
dp[0][1] = abc[0][1]
dp[0][2] = abc[0][2]
for i in range(1, n):
    for j in range(3):
        if j == 0:
            dp[i][j] = max(dp[i - 1][1], dp[i - 1][2]) + abc[i][j]
        if j == 1:
            dp[i][j] = max(dp[i - 1][0], dp[i - 1][2]) + abc[i][j]
        if j == 2:
            dp[i][j] = max(dp[i - 1][0], dp[i - 1][1]) + abc[i][j]
print((max(dp[n - 1])))

INF = float("inf")
import sys

sys.setrecursionlimit(10**9)
input = sys.stdin.readline
input_int = lambda: int(eval(input()))
input_ints = lambda: list(map(int, input().split()))
input_ints_list = lambda: list(input_ints())
input_str = lambda: eval(input())
input_strs = lambda: input().split()
input_lines = lambda n, input_func: [input_func() for _ in range(n)]
import importlib

import_module = lambda module_name: importlib.import_module(module_name)
init_array_1dim = lambda value, n: [value] * n  # 1次元配列を生成
init_array_2dim = lambda value, n, m: [
    init_array_1dim(value, n) for _ in range(m)
]  # 2次元配列を生成
gcd_base = lambda value1, value2: import_module("fractions").gcd(
    value1, value2
)  # 最大公約数（2値)
gcd = lambda lst: import_module("functools").reduce(gcd_base, lst)  # 最大公約数（リスト）
lcm_base = lambda value1, value2: (value1 * value2) // gcd_base(
    value1, value2
)  # 最小公倍数(2値)
lcm = lambda lst: import_module("functools").reduce(lcm_base, lst, 1)  # 最小公倍数(リスト)
permutations = lambda lst, n: import_module("itertools").permutations(lst, n)  # 順列
combinations = lambda lst, n: import_module("itertools").combinations(lst, n)  # 組み合わせ
product = lambda lst1, lst2: import_module("itertools").product(lst1, lst2)  # 二つのリストの直積
round = lambda value: round(value)  # 四捨五入
ceil = lambda value: import_module("math").ceil(value)  # 切り上げ
floor = lambda value: import_module("math").floor(value)  # 切り捨て
# キュー
init_q = lambda lst: import_module("collections").deque(lst)
q_pop = lambda q: q.popleft()  # 先頭から取り出し
q_push = lambda q, value: q.appendleft(value)  # 先頭に追加（値）
q_pushlist = lambda q, lst: q.extendleft(lst)  # 先頭に追加（リスト）
q_append = lambda q, value: q.append(value)  # 末尾に追加（値）
q_appendlist = lambda q, lst: q.extend(lst)  # 末尾に追加（リスト）
# プライオリティキュー
init_heap = lambda a: import_module("heapq").heapify(a)
heap_push = lambda a, v: import_module("heapq").heappush(a, v)
heap_pop = lambda a: import_module("heapq").heappop(a)  # 最小値を取り出す


def solution():
    # ここに実装
    N = input_int()
    abc = input_lines(N, input_ints_list)
    dp = init_array_2dim(-1, 3, N)
    for i in range(N):
        if i == 0:
            dp[i][0] = abc[0][0]
            dp[i][1] = abc[0][1]
            dp[i][2] = abc[0][2]
        else:
            dp[i][0] = abc[i][0] + max(dp[i - 1][1], dp[i - 1][2])
            dp[i][1] = abc[i][1] + max(dp[i - 1][0], dp[i - 1][2])
            dp[i][2] = abc[i][2] + max(dp[i - 1][0], dp[i - 1][1])
    print((max(dp[N - 1])))


if __name__ == "__main__":
    solution()

-n = int(eval(input())) -abc = [] -for _ in range(n): -    abc.append(list(map(int, input().split()))) -dp = [[0] * 3 for _ in range(n)] -dp[0][0] = abc[0][0] -dp[0][1] = abc[0][1] -dp[0][2] = abc[0][2] -for i in range(1, n): -    for j in range(3): -        if j == 0: -            dp[i][j] = max(dp[i - 1][1], dp[i - 1][2]) + abc[i][j] -        if j == 1: -            dp[i][j] = max(dp[i - 1][0], dp[i - 1][2]) + abc[i][j] -        if j == 2: -            dp[i][j] = max(dp[i - 1][0], dp[i - 1][1]) + abc[i][j] -print((max(dp[n - 1]))) +INF = float("inf") +import sys + +sys.setrecursionlimit(10**9) +input = sys.stdin.readline +input_int = lambda: int(eval(input())) +input_ints = lambda: list(map(int, input().split())) +input_ints_list = lambda: list(input_ints()) +input_str = lambda: eval(input()) +input_strs = lambda: input().split() +input_lines = lambda n, input_func: [input_func() for _ in range(n)] +import importlib + +import_module = lambda module_name: importlib.import_module(module_name) +init_array_1dim = lambda value, n: [value] * n  # 1次元配列を生成 +init_array_2dim = lambda value, n, m: [ +    init_array_1dim(value, n) for _ in range(m) +]  # 2次元配列を生成 +gcd_base = lambda value1, value2: import_module("fractions").gcd( +    value1, value2 +)  # 最大公約数（2値) +gcd = lambda lst: import_module("functools").reduce(gcd_base, lst)  # 最大公約数（リスト） +lcm_base = lambda value1, value2: (value1 * value2) // gcd_base( +    value1, value2 +)  # 最小公倍数(2値) +lcm = lambda lst: import_module("functools").reduce(lcm_base, lst, 1)  # 最小公倍数(リスト) +permutations = lambda lst, n: import_module("itertools").permutations(lst, n)  # 順列 +combinations = lambda lst, n: import_module("itertools").combinations(lst, n)  # 組み合わせ +product = lambda lst1, lst2: import_module("itertools").product(lst1, lst2)  # 二つのリストの直積 +round = lambda value: round(value)  # 四捨五入 +ceil = lambda value: import_module("math").ceil(value)  # 切り上げ +floor = lambda value: import_module("math").floor(value)  # 切り捨て +# キュー +init_q = lambda lst: import_module("collections").deque(lst) +q_pop = lambda q: q.popleft()  # 先頭から取り出し +q_push = lambda q, value: q.appendleft(value)  # 先頭に追加（値） +q_pushlist = lambda q, lst: q.extendleft(lst)  # 先頭に追加（リスト） +q_append = lambda q, value: q.append(value)  # 末尾に追加（値） +q_appendlist = lambda q, lst: q.extend(lst)  # 末尾に追加（リスト） +# プライオリティキュー +init_heap = lambda a: import_module("heapq").heapify(a) +heap_push = lambda a, v: import_module("heapq").heappush(a, v) +heap_pop = lambda a: import_module("heapq").heappop(a)  # 最小値を取り出す + + +def solution(): +    # ここに実装 +    N = input_int() +    abc = input_lines(N, input_ints_list) +    dp = init_array_2dim(-1, 3, N) +    for i in range(N): +        if i == 0: +            dp[i][0] = abc[0][0] +            dp[i][1] = abc[0][1] +            dp[i][2] = abc[0][2] +        else: +            dp[i][0] = abc[i][0] + max(dp[i - 1][1], dp[i - 1][2]) +            dp[i][1] = abc[i][1] + max(dp[i - 1][0], dp[i - 1][2]) +            dp[i][2] = abc[i][2] + max(dp[i - 1][0], dp[i - 1][1]) +    print((max(dp[N - 1]))) + + +if __name__ == "__main__": +    solution()