{-# OPTIONS_GHC -O2 #-}
import qualified Control.Arrow         as Arrow
import qualified Control.Monad         as Monad
import qualified Data.Bits             as Bits
import qualified Data.ByteString.Char8 as BSC8
import qualified Data.Char             as Char
import qualified Data.List             as List
import qualified Data.Vector.Unboxed   as VU

main :: IO ()
main = do
    n  <- readLn :: IO Int
    xs <- VU.replicateM n getABC
    print $ solver xs $ n - 1

data VacationF a
    = VacationF !(Int, Int, Int) (Maybe a)
instance Functor VacationF where
    fmap f (VacationF x Nothing)  = VacationF x Nothing
    fmap f (VacationF x (Just y)) = VacationF x (Just (f y))

-- 3つの幸福度候補から最大値を求める
max' :: Ord a => (a, a, a) -> a
max' (x, y, z) = max x (max y z)

solver :: VU.Vector (Int, Int, Int) -> (Int -> Int)
solver xs = max' . dyna phi psi
    where
        -- dp[i] := i日目に得る幸福度の候補
        psi 0 = VacationF (xs VU.! 0) Nothing -- 最初
        psi i = VacationF (xs VU.! i) (Just (i - 1)) -- i日目

        phi (VacationF m Nothing) = m -- dp[1] = (a1, b1, c1)
        phi (VacationF (a, b, c) (Just t)) = (max (a + b') (a + c'), max (b + c') (b + a'), max (c + a') (c + b')) -- dp[i]
            where
                (a', b', c') = extract t -- 一日前までの幸福度の最大値候補

-- * 入出力
getI :: BSC8.ByteString -> Maybe (Int, BSC8.ByteString)
getI = fmap (Arrow.second BSC8.tail) . BSC8.readInt
getABC :: IO (Int, Int, Int)
getABC = (\vec -> (vec VU.! 0, vec VU.! 1, vec VU.! 2)) . VU.unfoldrN 3 getI <$> BSC8.getLine
-- ! 射
newtype Fix f
    = InF { outF :: f (Fix f) }

pair :: (a -> b, a -> c) -> a -> (b, c)
pair (f, g) x = (f x, g x)

-- ! 下方射
cata :: Functor f => (f a -> a) -> (Fix f -> a)
cata phi = phi . fmap (cata phi) . outF
-- ! 上方射
ana  :: Functor f => (b -> f b) -> (b -> Fix f)
ana psi = InF . fmap (ana psi) . psi
-- ! 双方射
hylo :: Functor f => (f b -> b) -> (a -> f a) -> (a -> b)
hylo phi psi = cata phi . ana psi

-- * 未来用データ(直和)
data Fx f a x
    = Fx { unFx :: Either a (f x) }
-- * 過去用データ（直積）
data Hx f a x
    = Hx { unHx :: (a, f x) }

-- * Fx f a は関手
instance Functor f => Functor (Fx f a) where
    fmap f (Fx (Left x))  = Fx (Left x)
    fmap f (Fx (Right x)) = Fx (Right (fmap f x))
-- * Hx f a は関手
instance Functor f => Functor (Hx f a) where
    fmap f (Hx (x, y)) = Hx (x, fmap f y)

-- * Fx f a の不動点
newtype Free f a
    = Free { unFree :: Fix (Fx f a) }
-- * Hx f a の不動点
newtype CoFree f a
    = CoFree { unCoFree :: Fix (Hx f a) }

-- * Free f は関手
instance Functor f => Functor (Free f) where
    fmap f = Free . cata (InF . phi) . unFree
        where
            phi (Fx (Left a))  = Fx (Left (f a))
            phi (Fx (Right b)) = Fx (Right b)
-- * CoFree f は関手
instance Functor f => Functor (CoFree f) where
    fmap f = CoFree . ana (psi . outF) . unCoFree
        where
            psi (Hx (a, x)) = Hx (f a, x)

-- * Free と CoFree の情報を出し入れする関数
extract :: Functor f => CoFree f t -> t
extract cf = case outF (unCoFree cf) of
    Hx (a, _) -> a

sub :: Functor f => CoFree f a -> f (CoFree f a)
sub cf = case outF (unCoFree cf) of
    Hx (_, b) -> fmap CoFree b

inject :: Functor f => a -> Free f a
inject = Free
        . InF
        . Fx
        . Left

-- ! 時空射
chrono :: Functor f => (f (CoFree f b) -> b) -> (a -> f (Free f a)) -> (a -> b)
chrono phi psi = extract . hylo phi' psi' . inject
    where
        phi' = CoFree
            . InF
            . fmap unCoFree
            . Hx
            . pair (phi, id)
        psi' = uncurry either (psi, id)
            . unFx
            . fmap Free
            . outF
            . unFree

-- ! dp射
dyna :: Functor f => (f (CoFree f b) -> b) -> (a -> f a) -> (a -> b)
dyna phi psi = chrono phi (fmap inject . psi)