using System;
using System.Linq;
using System.Collections.Generic;

namespace Contest
{
  class Program
  {
    static void Main(string[] args)
    {
      ABC075.D();
    }
    class ABC075
    {
      public static void A()
      {
        var A = Read.IntN().OrderBy(x => x).ToArray();
        Console.WriteLine(A[0] == A[1] ? A[2] : A[0]);
      }
      public static void B()
      {
        var H = Read.Int();
        var W = Read.Int();
        var S = Enumerable.Range(0, H).Select(i => Read.Str()).ToArray();
        var board = new int[H + 2, W + 2];
        for(int i = 0; i < H; ++i)
        {
          for(int j = 0; j < W; ++j)
          {
            if (S[i][j] == '#')
            {
              for(int c1 = 0; c1 < 3; ++c1)
              {
                for(int c2 = 0; c2 < 3; ++c2)
                {
                  board[i + c1, j + c2]++;
                }
              }
            }
          }
        }
        for(int i = 0; i < H; ++i)
        {
          Console.WriteLine(String.Join("", Enumerable.Range(0, W).Select(j => S[i][j] == '#' ? "#" : board[i + 1, j + 1].ToString())));
        }
      }
      public static void C()
      {
        var N = Read.Int();
        var M = Read.Int();
        var AB = Read.TupleInt(M);
        int count = 0;
        for(int i = 0; i < M; ++i)
        {
          var uft = new Util.UnionFindTree(N);
          for(int j = 0; j < M; ++j)
          {
            if (i != j) { uft.Unite(AB[j].Item1 - 1, AB[j].Item2 - 1); }
          }
          if(Enumerable.Range(0,N).Select(i=> uft.Root(i)).Distinct().Count() > 1)
          {
            count++;
          }
        }
        Console.WriteLine(count);
      }
      public static void D()
      {
        var N = Read.Int();
        var K = Read.Int();
        var XY = Read.TupleLong(N).OrderBy(x => x.Item1).ToArray();
        long min = (long)4e18;
        for(int i = 0; i < N; ++i)
        {
          for(int j = i + K; j <= N; ++j)
          {
            var dx = XY[j - 1].Item1 - XY[i].Item1;
            var Y = XY.Skip(i).Take(j - i).Select(x => x.Item2).OrderBy(x => x).ToArray();
            var mindy = (long)2e18;
            for(int k = 0; k <= j - i - K; ++k)
            {
              mindy = Math.Min(mindy, Y[k + K - 1] - Y[k]);
            }
            min = Math.Min(min, dx * mindy);
          }
        }
        Console.WriteLine(min);
      }
    }

    class Util
    {
      public static T[,] Gen<T>(int r, int c, T v)
      {
        var matrix = new T[r, c];
        for (int i = 0; i < r; ++i)
        {
          for (int j = 0; j < c; ++j)
          {
            matrix[i, j] = v;
          }
        }
        return matrix;
      }
      public static long[] ASum(long[] array)
      {
        var res = new long[array.Length + 1];
        for (int i = 0; i < array.Length; ++i)
        {
          res[i + 1] = res[i] + array[i];
        }
        return res;
      }
      public static long[,] ASum(long[,] matrix)
      {
        var N = matrix.GetLength(0);
        var M = matrix.GetLength(1);
        var res = new long[N + 1, M + 1];
        for(int i = 0; i < N; ++i)
        {
          for(int j = 0; j < M; ++j)
          {
            res[i + 1, j + 1] = res[i, j + 1] + res[i + 1, j] - res[i, j] + matrix[i, j];
          }
        }
        return res;
      }
      public static Dictionary<T, long> Frequency<T>(T[] array)
      {
        var dict = new Dictionary<T, long>();
        foreach (var a in array)
        {
          if (!dict.ContainsKey(a)) { dict.Add(a, 0); }
          dict[a]++;
        }
        return dict;
      }

      public class UnionFindTree
      {
        int[] parent; int[] count;
        public UnionFindTree(int n) { parent = new int[n]; count = new int[n]; for (int i = 0; i < n; ++i) { parent[i] = i; count[i] = 1; } }
        public int Root(int i) { if (parent[i] == i) { return i; } else { return parent[i] = Root(parent[i]); } }
        public int Count(int i) { return count[Root(i)]; }
        public bool Same(int i, int j) { return Root(i) == Root(j); }
        public void Unite(int i, int j) { var ri = Root(i); var rj = Root(j); if (ri != rj) { parent[ri] = rj; count[rj] += count[ri]; } }
      }
    }

    static class Read
{
static Queue<string> queue = new Queue<string>();
static void Enqueue() { var ss = Console.ReadLine().Split(' '); foreach (var s in ss) { queue.Enqueue(s); } }
public static int Int() { if (queue.Count == 0) { Enqueue(); } return Convert.ToInt32(queue.Dequeue()); }
public static long Long() { if (queue.Count == 0) { Enqueue(); } return Convert.ToInt64(queue.Dequeue()); }
public static string Str() { if (queue.Count == 0) { Enqueue(); } return queue.Dequeue(); }
public static int[] IntN() { return Console.ReadLine().Split(' ').Select(s => Convert.ToInt32(s)).ToArray(); }
public static long[] LongN() { return Console.ReadLine().Split(' ').Select(s => Convert.ToInt64(s)).ToArray(); }
public static ulong[] ULongN() { return Console.ReadLine().Split(' ').Select(s => Convert.ToUInt64(s)).ToArray(); }
public static string[] StrN() { return Console.ReadLine().Split(' '); }
public static Tuple<int, int>[] TupleInt(int n) { List<Tuple<int, int>> list = new List<Tuple<int, int>>(); for (int i = 0; i < n; ++i) { var ab = Read.IntN(); list.Add(new Tuple<int, int>(ab[0], ab[1])); } return list.ToArray(); }
public static Tuple<long, long>[] TupleLong(int n) { List<Tuple<long, long>> list = new List<Tuple<long, long>>(); for (int i = 0; i < n; ++i) { var ab = Read.LongN(); list.Add(new Tuple<long, long>(ab[0], ab[1])); } return list.ToArray(); }
public static Tuple<string, string>[] TupleStr(int n) { List<Tuple<string, string>> list = new List<Tuple<string, string>>(); for (int i = 0; i < n; ++i) { var ab = Read.StrN(); list.Add(new Tuple<string, string>(ab[0], ab[1])); } return list.ToArray(); }
public static Tuple<double, double>[] TupleDouble(int n) { List<Tuple<double, double>> list = new List<Tuple<double, double>>(); for (int i = 0; i < n; ++i) { var ab = Read.LongN(); list.Add(new Tuple<double, double>(ab[0], ab[1])); } return list.ToArray(); }
public static long[,] LongMatrix(int r, int c) { var mat = new long[r, c]; for (int i = 0; i < r; ++i) { var x = Read.LongN(); for (int j = 0; j < c; ++j) { mat[i, j] = x[j]; } } return mat; }
public static Dictionary<int, HashSet<int>> AdjacencyList(int N, int M, bool isDirectional = false)
{
Dictionary<int, HashSet<int>> dict = new Dictionary<int, HashSet<int>>();
for (int i = 0; i <= N; ++i) { dict.Add(i, new HashSet<int>()); }
        for (int i = 0; i < M; ++i) { var ab = Read.IntN(); if (!dict[ab[0]].Contains(ab[1])) { dict[ab[0]].Add(ab[1]); } if (!isDirectional && !dict[ab[1]].Contains(ab[0])) { dict[ab[1]].Add(ab[0]); } }
        return dict;
}
public static Dictionary<int, Dictionary<int, long>> AdjacencyListWithWeight(int N, int M)
{
Dictionary<int, Dictionary<int, long>> dict = new Dictionary<int, Dictionary<int, long>>(); for (int i = 0; i <= N; ++i) { dict.Add(i, new Dictionary<int, long>()); }
for (int i = 0; i < M; ++i) { var ab = Read.IntN(); dict[ab[0]].Add(ab[1], ab[2]); dict[ab[1]].Add(ab[0], ab[2]); }
return dict;
}
}
    }
}


Measured memory_bytes: 20916