import java.io.*;
import java.text.DecimalFormat;
import java.text.NumberFormat;
import java.util.*;

public class Main {

    public static void main(String[] args) {

        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        Input cin = new Input(inputStream);
        Output cout = new Output(outputStream);

      	int n = cin.nextInt(), k = cin.nextInt();
        int dp[][] = new int[n][2];
        for (int i = 0; i < n; i++) {
        	dp[i][0] = cin.nextInt();
          	dp[i][1] = cin.nextInt();
        }
        Arrays.sort(dp, (x, y) -> (y[1] - x[1]));
        long max = Long.MIN_VALUE, sum = 0;
        PriorityQueue<Integer> pq = new PriorityQueue<>();
        for (int i = 0; i < n; i++) {
            sum += dp[i][0];
            pq.add(dp[i][0]);
            while (pq.size() > k) {
              	sum -= pq.remove();
            }
            max = Math.max(max, sum * dp[i][1]);
        }
        cout.print(max);
        cout.close();
    }

    private static double apothemGivenSide(int n, double s) {
        return (s / (2*Math.tan(Math.toRadians((double)180/n))));
    }

    private static double sideGivenArea(int n, double a) {
        return (2*Math.sqrt( (a*Math.tan(Math.PI/n)) / n));
    }

    private static double areaGivenCircRadius(int n, double r) {
        return ( ( Math.pow(r, 2) * n * Math.sin((2*Math.PI)/n) ) / 2);
    }

    private static double nextInsidePolyArea(int n, double a) {
        return areaGivenCircRadius( n , apothemGivenSide(n, sideGivenArea(n, a)) );
    }

    static class Output {
        private final PrintWriter writer;

        Output(OutputStream outputStream) {
            writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
        }

        public Output(Writer writer) {
            this.writer = new PrintWriter(writer);
        }

        void close() {
            writer.close();
        }

        void println(Object i) {
            writer.println(i);
        }
        void print(Object i) {
            writer.print(i);
        }
    }

    static class Input {
        private InputStream stream;
        private byte[] buf = new byte[1024];
        private int curChar;
        private int numChars;
        private Input.SpaceCharFilter filter;

        Input(InputStream stream) {
            this.stream = stream;
        }

        int read() {
            if (numChars == -1) {
                throw new InputMismatchException();
            }
            if (curChar >= numChars) {
                curChar = 0;
                try {
                    numChars = stream.read(buf);
                } catch (IOException e) {
                    throw new InputMismatchException();
                }
                if (numChars <= 0) {
                    return -1;
                }
            }
            return buf[curChar++];
        }

        String nextString() {
            int c = read();
            while (isSpaceChar(c)) {
                c = read();
            }
            StringBuilder res = new StringBuilder();
            do {
                if (Character.isValidCodePoint(c)) {
                    res.appendCodePoint(c);
                }
                c = read();
            } while (!isSpaceChar(c));
            return res.toString();
        }

        int nextInt() {
            return Integer.parseInt(this.next());
        }

        boolean isSpaceChar(int c) {
            if (filter != null) {
                return filter.isSpaceChar(c);
            }
            return isWhitespace(c);
        }

        static boolean isWhitespace(int c) {
            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        }

        String next() {
            return nextString();
        }

        public interface SpaceCharFilter {
            boolean isSpaceChar(int ch);

        }

    }
}