import Data.List

type Point = (Integer, Integer)

windows :: Integer -> [a] -> [[a]]
windows k xs
    | length xs < fromIntegral k = []
    | otherwise = (take (fromIntegral k) xs) : windows k (tail xs)

minArea :: [Point] -> Integer -> (Integer, Integer) -> Integer
minArea points k (x1, x2) =
    let insidePoints = filter (\(x, _) -> x1 <= x && x <= x2) points
        sortedPoints = sortBy (\(_, y1) (_, y2) -> compare y1 y2) insidePoints
        groups = windows k sortedPoints
    in if null groups
       then 40000000000000000000
       else minimum $ map area groups
    where area ps = xDist * (yDist ps)
          xDist = x2 - x1
          yDist ps = (snd $ last ps) - (snd $ head ps)

solve :: [Point] -> Integer -> Integer
solve points k =
    let xs = sort $ map fst points
        pairs = [(x1, x2) | x1 <- xs, x2 <- xs, x1 < x2]
    in minimum $ map (minArea points k) pairs

makePoint :: [Integer] -> Point
makePoint (x:y:_) = (x, y)

readIntegers :: IO [Integer]
readIntegers = map read . words <$> getLine :: IO [Integer]

readPoint :: IO Point
readPoint = makePoint <$> readIntegers

readPoints :: Integer -> IO [Point]
readPoints n
    | n <= 0 = return []
    | otherwise = do
        currPoint <- makePoint <$> readIntegers
        otherPoints <- readPoints (n - 1)
        return (currPoint : otherPoints)

main = do
    [n, k] <- readIntegers
    points <- readPoints n
    putStrLn . show $ solve points k
