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

public static class Combination
{
    public static IEnumerable<IEnumerable<T>> GetCombinations<T>(this IEnumerable<T> elements, int k)
    {
        return k == 0 ? new[] { new T[0] } :
          elements.SelectMany((e, i) =>
            elements.Skip(i + 1).GetCombinations(k - 1).Select(c => (new[] { e }).Concat(c)));
    }
}

public struct Point
{
    public long X;
    public long Y;

    public Point(Point p)
    {
        X = p.X;
        Y = p.Y;
    }

    public Point(long x, long y)
    {
        X = x;
        Y = y;
    }

    public static bool operator ==(Point a, Point b)
    {
        return (a.X == b.X && a.Y == b.Y);
    }

    public static bool operator !=(Point a, Point b)
    {
        return !(a == b);
    }

    //objと自分自身が等価のときはtrueを返す
    public override bool Equals(object obj)
    {
        if (!(obj is Point))
        {
            return false;
        }

        Point p = (Point)obj;
        return (X == p.X && Y == p.Y);
    }

    //Equalsがtrueを返すときに同じ値を返す
    public override int GetHashCode()
    {
        return (int)((X << 16) ^ Y);
    }

    public Point Clone()
    {
        return new Point(X, Y);
    }

    public void Reverse()
    {
        X = -X;
        Y = -Y;
    }

    public static Point operator +(Point a, Point b)
    {
        return new Point(a.X + b.X, a.Y + b.Y);
    }

    public static Point operator -(Point a, Point b)
    {
        return new Point(a.X - b.X, a.Y - b.Y);
    }

    public static Point operator *(Point a, int i)
    {
        return new Point(a.X * i, a.Y * i);
    }

    public static Point operator /(Point a, int i)
    {
        return new Point(a.X / i, a.Y / i);
    }
    public static Point operator +(Point a)
    {
        return new Point(+a.X, +a.Y);
    }

    public static Point operator -(Point a)
    {
        return new Point(-a.X, -a.Y);
    }

    public override string ToString()
    {
        return string.Format("({0},{1})", X, Y);
    }
}

class Solution
{
    static long Area(Point[] ps)
    {
        return Area(ps[0], ps[1]);
    }

    static long Area(Point a, Point b)
    {
        var diff = a - b;
        return Math.Abs(diff.X * diff.Y);
    }

    static void Main()
    {
        var vals = Console.ReadLine().Split(' ').Select(int.Parse).ToArray();
        int n = vals[0];
        int k = vals[1];
        var points = new Point[n];

        for (int i = 0; i < n; i++)
        {
            var vs = Console.ReadLine().Split(' ').Select(long.Parse).ToArray();
            var x = vs[0];
            var y = vs[1];
            points[i] = new Point(x, y);
        }

        var minArea = long.MaxValue;

        var list = new List<Point[]>();
        foreach (var ps in Combination.GetCombinations(points, Math.Min(k, 4)))
        {
            var ay = ps.Min(p => p.Y);
            var by = ps.Max(p => p.Y);
            var ax = ps.Min(p => p.X);
            var bx = ps.Max(p => p.X);
            var rect = new Point[] { new Point(ax, ay), new Point(bx, by) };
            list.Add(rect);
        }
        list.Sort((a, b) => Area(a).CompareTo(Area(b)));

        foreach (var rect in list)
        {
            int count = 0;
            foreach (var p in points)
            {
                if (rect[0].X <= p.X && p.X <= rect[1].X && rect[0].Y <= p.Y && p.Y <= rect[1].Y)
                {
                    count++;
                    if (count >= k)
                    {
                        Console.WriteLine(Area(rect));
                        return;
                    }
                }
            }
        }
    }
}

Measured memory_bytes: 36076