import qualified Data.Foldable as F

main :: IO ()
main = do
    n <- readLn
    as <- (map read . words) <$> getLine
    print $ solve n as

-- |
--
-- >>> solve 2 [3,1,4,1,5,9]
-- 1
--
-- >>> solve 1 [1,2,3]
-- -1
solve :: Int -> [Int] -> Int
solve n as = maximum $ zipWith (-) y1s y2s
  where
    (a1s,bs,a2s) = split3 as n
    y1s = map (F.foldl1 (+)) $ scanl (-<-) (fromListMin a1s) (reverse bs)
    y2s = map (F.foldl1 (+)) $ scanr (flip (->-)) (fromListMax a2s) bs

split3 :: [a] -> Int -> ([a], [a], [a])
split3 zs n = (xs,ys,zs'')
  where
    (xs, zs') = split2 ([], zs) n
    (ys, zs'') = split2 ([], zs') n

split2 :: ([a], [a]) -> Int -> ([a], [a])
split2 (_,[]) _ = undefined
split2 (xs,ys) 0 = (xs,ys)
split2 (xs,y0:ys) n = split2 (y0:xs,ys) (n - 1)

-- Heap
data SkewHeap a = Empty | Node a (SkewHeap a) (SkewHeap a)
            deriving (Show, Read, Eq)

singleton :: a -> SkewHeap a
singleton x = Node x Empty Empty

(+<+) :: Ord a => SkewHeap a -> SkewHeap a -> SkewHeap a
Empty               +<+ t2                  = t2
t1                  +<+ Empty               = t1
t1@(Node x1 l1 r1)  +<+ t2@(Node x2 l2 r2)
   | x1 <= x2   = Node x1 (t2 +<+ r1) l1
   | otherwise  = Node x2 (t1 +<+ r2) l2

(+>+) :: Ord a => SkewHeap a -> SkewHeap a -> SkewHeap a
Empty               +>+ t2                  = t2
t1                  +>+ Empty               = t1
t1@(Node x1 l1 r1)  +>+ t2@(Node x2 l2 r2)
   | x1 >= x2   = Node x1 (t2 +>+ r1) l1
   | otherwise  = Node x2 (t1 +>+ r2) l2

(+<) :: Ord a => SkewHeap a -> a -> SkewHeap a
heap +< x = singleton x +<+ heap

(+>) :: Ord a => SkewHeap a -> a -> SkewHeap a
heap +> x = singleton x +>+ heap

popMin :: Ord a => SkewHeap a -> (Maybe a, SkewHeap a)
popMin Empty        = (Nothing, Empty)
popMin (Node x l r) = (Just x, l +<+ r)

popMax :: Ord a => SkewHeap a -> (Maybe a, SkewHeap a)
popMax Empty        = (Nothing, Empty)
popMax (Node x l r) = (Just x, l +>+ r)

fromListMin :: Ord a => [a] -> SkewHeap a
fromListMin = foldl (+<) Empty

fromListMax :: Ord a => [a] -> SkewHeap a
fromListMax = foldl (+>) Empty

(-<-) :: Ord a => SkewHeap a -> a -> SkewHeap a
(-<-) heap x = snd . popMin $ heap +< x

(->-) :: Ord a => SkewHeap a -> a -> SkewHeap a
(->-) heap x = snd . popMax $ heap +> x

instance Foldable SkewHeap where
    foldMap _ Empty = mempty
    foldMap f (Node x l r) = foldMap f l `mappend` f x `mappend` foldMap f r
