import Data.Maybe (fromJust)
import qualified Data.Foldable as F
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 (-) y1s (map negate y2s)
  where
    (a1s, cs) = splitAt n as
    (bs, a2s) = splitAt n cs
    a2s' = map negate a2s
    bs' = map negate bs
    y1s = map (F.foldl1 (+)) $ scanl pushpop (fromList a1s) bs
    y2s = map (F.foldl1 (+)) $ scanr (flip pushpop) (fromList a2s') 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 -> (Maybe a, SkewHeap a)
pop Empty        = (Nothing, Empty)
pop (Node x l r) = (Just x, l +<+ r)

fromList :: Ord a => [a] -> SkewHeap a
fromList = foldl push Empty

pushpop :: Ord a => SkewHeap a -> a -> SkewHeap a
pushpop heap x = snd . pop $ heap `push` x

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