import qualified Data.Text as T
import qualified Data.Text.IO as T
import qualified Data.Text.Read as T
import Data.List (sortBy, unfoldr)
import qualified Data.Vector.Unboxed as V
import Data.Maybe (isNothing, fromJust)

main :: IO ()
main = do
  (n : m : _) <- map unsafeSignedDecimal . T.words <$> T.getLine :: IO [Int]
  as <- V.fromList . sortBy (flip compare) . map unsafeSignedDecimal . T.words <$> T.getLine :: IO (V.Vector Int)
  let
    hs = map f [0..(pred n)]
      where
        f :: Int -> PH Int
--        f l = foldl (flip insert) empty . map (\i -> as V.! i + as V.! (l - i)) $ [0..l]
        f l = foldl (flip insert) empty $ let y = as V.! l in ([0..(pred l)] >>= \i -> let x = as V.! i + y in [x, x]) ++ [2 * y]
--    bs = scanl step (2 * (as V.! 0), empty) $ hs
    bs = unfoldr view . foldl merge empty $ hs
      where
        step (x, h0) h = fromJust . view $ merge h0 h
--  print . sum . take m . map fst $ bs
  print . sum . take m $ bs

data PH' a = PH' a [PH' a]

newtype PH a = PH {unPH :: Maybe (PH' a)}

ph :: b -> (PH' a -> b) -> PH a -> b
ph d f = maybe d f . unPH

singleton' :: a -> PH' a
singleton' = flip PH' []

merge' :: Ord a => PH' a -> PH' a -> PH' a
merge' u@(PH' x us) v@(PH' y vs)
  | x < y
    = PH' y (u : vs)
  | otherwise
    = PH' x (v : us)

view' :: Ord a => PH' a -> (a, Maybe (PH' a))
view' (PH' x us) = (x, v)
  where
    v = case us of
      [] -> Nothing
      u : [] -> Just u
      u : u' : us' -> Just . (($) <$> maybe id merge' . snd <*> fst) . foldl step (merge' u u', Nothing) $ us'
      where
        step (v', Nothing) u = (v', Just u)
        step (v', Just u) u' = (merge' v' (merge' u u'), Nothing)

empty :: PH a
empty = PH Nothing

isEmpty :: PH a -> Bool
isEmpty = ph True (const False)

singleton :: a -> PH a
singleton = PH . Just . singleton'

insert :: Ord a => a -> PH a -> PH a
insert = merge . singleton

merge :: Ord a => PH a -> PH a -> PH a
merge = ph id (((PH . Just) .) . (ph <$> id <*> merge'))

view :: Ord a => PH a -> Maybe (a, PH a)
view = ph Nothing (Just . fmap PH . view')

unsafeSignedDecimal :: T.Text -> Int
unsafeSignedDecimal s = case T.signed T.decimal s of
  Right (n, _) -> n
