{-# LANGUAGE BangPatterns #-}
import Control.Arrow
import Control.Monad.Fix
import Data.Foldable
import qualified Data.Vector.Unboxed as VU
import qualified Data.Vector.Unboxed.Mutable as VUM
import qualified Data.ByteString.Char8 as B
import Data.ByteString.Internal (accursedUnutterablePerformIO)
import qualified Data.Set as S
import System.IO.Unsafe
import Debug.Trace

unew :: VU.Unbox a => Int -> VUM.IOVector a
unew !n = accursedUnutterablePerformIO $ VUM.unsafeNew n

uread :: VU.Unbox a => Int -> VUM.IOVector a -> a
uread !i !v = accursedUnutterablePerformIO $ VUM.unsafeRead v i

uwrite :: VU.Unbox a => Int -> a -> VUM.IOVector a -> VUM.IOVector a
uwrite !i !a !v =
  accursedUnutterablePerformIO $ VUM.unsafeWrite v i a >> return v

umodify :: VU.Unbox a => Int -> (a -> a) -> VUM.IOVector a -> VUM.IOVector a
umodify !i !f !v =
  accursedUnutterablePerformIO $ VUM.unsafeModify v f i >> return v

uthaw :: VU.Unbox a => VU.Vector a -> VUM.IOVector a
uthaw !v = accursedUnutterablePerformIO $ VU.unsafeThaw v

ufreeze :: VU.Unbox a => VUM.IOVector a -> VU.Vector a
ufreeze !v = accursedUnutterablePerformIO $ VU.unsafeFreeze v

solve :: Int -> VU.Vector (Int, Int, Int) -> Int
solve n abcs =
  uread (toIndex (n - 1) 'a') dp
    `max` uread (toIndex (n - 1) 'b') dp
    `max` uread (toIndex (n - 1) 'c') dp
 where
  toIndex i 'a' = i
  toIndex i 'b' = i + n
  toIndex i 'c' = i + 2 * n

  dp = VU.foldl'
    ( \(!dp) (!i, (!ai, !bi, !ci)) -> if i == 0
      then uwrite (toIndex i 'a') ai $ uwrite (toIndex i 'b') bi $ uwrite
        (toIndex i 'c')
        ci
        dp
      else
        let ai' = uread (toIndex (i - 1) 'a') dp
            bi' = uread (toIndex (i - 1) 'b') dp
            ci' = uread (toIndex (i - 1) 'c') dp
        in  uwrite (toIndex i 'a') (ai + max bi' ci')
            $ uwrite (toIndex i 'b') (bi + max ai' ci')
            $ uwrite (toIndex i 'c') (ci + max ai' bi') dp
    )
    (unew (n * 3))
    (VU.indexed abcs)

main = do
  let readInt = fmap (second B.tail) . B.readInt

  n    <- (\vec -> vec VU.! 0) . VU.unfoldrN 1 readInt <$> B.getLine
  abcs <-
    VU.replicateM n
    $   (\vec -> (vec VU.! 0, vec VU.! 1, vec VU.! 2))
    .   VU.unfoldrN 3 readInt
    <$> B.getLine
  print $ solve n abcs
