import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.PriorityQueue;
import java.util.Set;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.HashSet;
import java.util.List;
import java.util.AbstractCollection;
import java.util.Vector;
import java.util.StringTokenizer;
import java.io.BufferedReader;
import java.util.Collections;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        ReaderFastIO in = new ReaderFastIO(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        CPlaylist solver = new CPlaylist();
        solver.solve(1, in, out);
        out.close();
    }

    static class CPlaylist {
        public void solve(int testNumber, ReaderFastIO in, PrintWriter out) {

            int n = in.nextInt();
            int k = in.nextInt();

            List<Music> musics = new Vector<>();
            Set<Long> p = new HashSet<>();

            for (int i = 0; i < n; i++) {

                long t = in.nextLong();
                long b = in.nextLong();
                musics.add(new Music(t, b));
                p.add(b);
            }

            Collections.sort(musics, (x, y) -> Long.compare(y.T, x.T));
            List<Long> po = new Vector<>(p);
            Collections.sort(po);
            PriorityQueue<Music> queue = new PriorityQueue<>();
            int indexM = 0;
            long sum = 0;
            long best = 0;

            for (Long BMin : po) {

                while (queue.isEmpty() == false) {
                    if (queue.peek().B >= BMin) {
                        break;
                    }
                    sum -= queue.peek().T;
                    queue.poll();

                }

                while (indexM < n && queue.size() < k) {
                    if (musics.get(indexM).B >= BMin) {
                        queue.add(musics.get(indexM));
                        sum += musics.get(indexM).T;
                    }
                    indexM++;
                }

                best = Math.max(best, sum * BMin);
            }

            out.println(best);
        }

    }

    static class ReaderFastIO {
        BufferedReader br;
        StringTokenizer st;

        public ReaderFastIO() {
            br = new BufferedReader(new InputStreamReader(System.in));
        }

        public ReaderFastIO(InputStream input) {
            br = new BufferedReader(new InputStreamReader(input));
        }

        public String next() {
            while (st == null || !st.hasMoreElements()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }

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

        public long nextLong() {
            return Long.parseLong(next());
        }

    }

    static class Music implements Comparable<Music> {
        public long T;
        public long B;

        public Music(long T, long B) {

            this.T = T;
            this.B = B;

        }

        public int compareTo(Music o) {
            return Long.compare(B, o.B);
        }

    }
}

