// https://codeforces.com/contest/1140/problem/C
import java.util.*;
import java.io.*;

public class Solution_1140_C {

    static class Song {
        int t;
        int b;

        public Song() {

        }

        public Song(int t, int b) {
            this.t = t;
            this.b = b;
        }
        
        public String toString() {
            return "{" + this.t + " " + this.b + "}";
        }
        
    }

    static class Comparators {
        public static Comparator<Song> BEAUTY = new Comparator<Song>() {
            @Override
            public int compare(Song a, Song b) {
                if (a.b > b.b) {
                    return -1;
                }
                else if (a.b < b.b) {
                    return 1;
                }
                else {
                    return 0;
                }
            }
        };

        public static Comparator<Song> LENGTH = new Comparator<Song>() {
            @Override
            public int compare(Song a, Song b) {
                if (a.t < b.t) {
                    return -1;
                }
                else if (a.t > b.t) {
                    return 1;
                }
                else {
                    return 0;
                }
            }
        };
    }

    /* The data structure that will maintain the maximum sum of song length
        that is possible for a beauty that is smallest */
    static class SongSet {
        private PriorityQueue<Song> pq;

        public long sum;
        public Song minLengthSong;
        
        public SongSet() {
            pq = new PriorityQueue<>(Comparators.LENGTH);
            sum = 0;
            minLengthSong = null;
        }

        public void insertSong(Song s) {
            pq.add(s);
            
            sum += s.t;

            /* update minLengthSong */
            if(minLengthSong == null) {
                minLengthSong = pq.peek();
            }
            else {
                if(Comparators.LENGTH.compare(s, minLengthSong) < 0) {
                    minLengthSong = s;
                }
            }
        }

        public void removeMinLengthSong() {
            Song removed = pq.remove();

            sum -= removed.t;

            /* update minLengthSong */
            minLengthSong = pq.peek();
        }
        
        public int songCount() {
            return pq.size();
        }

        public String toString() {
            return pq.toString();
        }
    }

    static BufferedReader in;
    static FastScanner sc;
    static PrintWriter out;

    static int n;
    static int k;
    static List<Song> songs;

    /* The actual algorithm */
    public static void solve() {
        Collections.sort(songs, Comparators.BEAUTY);
        SongSet o = new SongSet();
        long result = 0;
        for(Song s : songs) {
            if(o.songCount() == k) {
                Song mn = o.minLengthSong;
                if(Comparators.LENGTH.compare(mn, s) < 0) {
                    o.removeMinLengthSong();
                    o.insertSong(s);
                    long currPleasure = o.sum * s.b;
                    result = Math.max(currPleasure, result);
                }
            }
            else {
                o.insertSong(s);
                long currPleasure = o.sum * s.b;
                result = Math.max(currPleasure, result);
            }
        }
        out.println(result);
    }
    public static void main(String[] args) throws Exception {
        in = new BufferedReader(new InputStreamReader(System.in));
        FastScanner sc = new FastScanner(in);
        out = new PrintWriter(System.out);
        n = sc.nextInt();
        k = sc.nextInt();
        songs = new ArrayList<>();
        for(int i = 0; i < n; i++) {
            int ti = sc.nextInt();
            int bi = sc.nextInt();
            songs.add(new Song(ti, bi));
        }

        solve();

        out.close();
    }
}

/* Class that simulates Scanner - but Faster?(taken from user on CodeForces) */
class FastScanner {
    BufferedReader in;
    StringTokenizer st;

    public FastScanner(BufferedReader in) {
        this.in = in;
    }

    public String nextToken() throws Exception {
        while (st == null || !st.hasMoreTokens()) {
            st = new StringTokenizer(in.readLine());
        }
        return st.nextToken();
    }

    public int nextInt() throws Exception {
        return Integer.parseInt(nextToken());
    }

    public long nextLong() throws Exception {
        return Long.parseLong(nextToken());
    }

    public double nextDouble() throws Exception {
        return Double.parseDouble(nextToken());
    }
}