import Data.List (foldl')
import Data.Maybe (fromJust)
import qualified Data.ByteString.Char8 as B

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

-- |
--
-- >>> solve 2 [3,1,4,1,5,9]
-- 1
--
-- >>> solve 1 [1,2,3]
-- -1
--
-- >>> solve 3 [8,2,2,7,4,6,5,3,8]
-- 5
solve :: Int -> [Int] -> Int
solve n as = maximum $ zipWith diff y1s y2s
  where
    diff (lh,_) (rh,_) = lh - negate rh
    (a1s, cs) = splitAt n as
    (bs, a2s) = splitAt n cs
    q1 = foldl' push Empty a1s
    q2 = foldl' push Empty (map negate a2s)
    lh0 = sum a1s
    rh0 = negate $ sum a2s
    y1s = scanl (flip pushpop) (lh0,q1) bs
    y2s = scanr pushpop (rh0,q2) (map negate bs)

-- Util
readInt :: B.ByteString -> Int
readInt = fst . fromJust . B.readInt

-- 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

push :: Ord a => SkewHeap a -> a -> SkewHeap a
heap `push` x = singleton x +@+ heap

pop :: Ord a => SkewHeap a -> (a, SkewHeap a)
pop Empty         = undefined
pop (Node x l r)  = (x, l +@+ r)

pushpop :: (Num a, Ord a) => a -> (a, SkewHeap a) -> (a, SkewHeap a)
x `pushpop` (y, h) = (y + x - x', h')
  where (x', h') = pop $ push h x
