Valera loves his garden, where n fruit trees grow.

This year he will enjoy a great harvest! On the i-th tree bi fruit grow, they will ripen on a day number ai. Unfortunately, the fruit on the tree get withered, so they can only be collected on day ai and day ai + 1 (all fruits that are not collected in these two days, become unfit to eat).

Valera is not very fast, but there are some positive points. Valera is ready to work every day. In one day, Valera can collect no more than v fruits. The fruits may be either from the same tree, or from different ones. What is the maximum amount of fruit Valera can collect for all time, if he operates optimally well?

Input

The first line contains two space-separated integers n and v (1 ≤ n, v ≤ 3000) — the number of fruit trees in the garden and the number of fruits that Valera can collect in a day. 

Next n lines contain the description of trees in the garden. The i-th line contains two space-separated integers ai and bi (1 ≤ ai, bi ≤ 3000) — the day the fruits ripen on the i-th tree and the number of fruits on the i-th tree.

Output

Print a single integer — the maximum number of fruit that Valera can collect. 

Examples

Input

2 3
1 5
2 3


Output

8


Input

5 10
3 20
2 20
1 20
4 20
5 20


Output

60

Note

In the first sample, in order to obtain the optimal answer, you should act as follows. 

  * On the first day collect 3 fruits from the 1-st tree. 
  * On the second day collect 1 fruit from the 2-nd tree and 2 fruits from the 1-st tree. 
  * On the third day collect the remaining fruits from the 2-nd tree. 



In the second sample, you can only collect 60 fruits, the remaining fruit will simply wither.
import java.util.*;
import java.io.*;
import java.math.BigInteger;
import java.math.MathContext;
import java.text.DecimalFormat;
import java.text.Format;

import static java.lang.Math.*;
import static java.util.Arrays.*;
import static java.util.Collections.*;
 
 
public class Main {
	public static void main(String[] args) throws IOException{
		InputReader in = new InputReader(System.in);
		Printer out = new Printer(System.out);
		TaskA solver = new TaskA();
		solver.solve(1, in, out);
		out.close();
	}

 
static class TaskA {
	//public ArrayList<Integer> ar;
	public boolean[] bs;
	
  // GCD && LCM 
	 long gcd(long a ,long b){return b == 0 ? a : gcd(b , a % b);}
	 long lcm(long a , long b){return a*(b/gcd(a, b));}
	
  // Sieve of erothenese
	void sieve(int UB){
	//	ar = new ArrayList();
		bs = new boolean[UB+1];
		bs[0] = bs[1] = true;
		for(int i = 2; i*i <= UB; i++){
			if(!bs[i]){
				for(int j = i*i ; j <= UB ; j += i)
					bs[j] = true;
			}
		}
		/* for(int i = 2; i <= UB; i++){
		      if(!bs[i])ar.add(i);
		}*/
	}
	
	
	
	
	
	
	
	
	/*          SOLUTION  IS RIGHT HERE     */
	public void solve(int testNumber, InputReader in, Printer out) throws IOException{
		 // BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		 // Scanner sc = new Scanner(System.in);
		
		
		
		 int n = in.nextInt(),
			 v = in.nextInt();
		Map<Integer, Integer> map = new HashMap<Integer, Integer>();
		int max = 0;
		for(int i = 0; i < n; i++){
			int s = in.nextInt();
			int t = in.nextInt();
			int tt = map.getOrDefault(s, 0);
			map.put(s, tt+t);
			max = max(max , s);
		}
		int count = 0 , s = 0 , vv = v;
		for(int i = 1; i <= max+1; i++){
			vv = v;
			if(s > 0){
				count += (s > vv)?vv:s;
				//out.println(vv+" q "+s);
				vv -= (s > vv)?vv:s;
				//out.println(vv+" w");
				s = 0;
			}
			//out.println(s+" po");
			if(map.containsKey(i)){
				    s = map.get(i);
				   // out.println(vv);
				    int ss = (s > vv)?vv:s;
					count += ss;
					s -= ss;
					vv -= ss;
				    //out.println(vv+" p"+s);
			}	
		}
		out.println(count);
 	 }
}
  
  
 // ||||||| INPUT READER ||||||||
 static class InputReader {
	private byte[] buf = new byte[2048];
	private int index;
	private int total;
	private InputStream in;
	
	public InputReader(InputStream stream){
		in = stream;
	}
	
	public int scan() throws IOException{
		if(total < 0)
			throw new InputMismatchException();
		if(index >= total){
			index = 0; 
			total = in.read(buf);
			if(total <= 0)
				return -1;
		}
		return buf[index++];
	}
	public long scanlong() throws IOException{
		long integer = 0;
		int n = scan();
		while(isWhiteSpace(n))
			n = scan();
		int neg = 1;
		if(n == '-'){
			neg = -1;
			n = scan();
		}
		while(!isWhiteSpace(n)){
			if(n >= '0' && n <= '9'){
				integer *= 10;
				integer += n - '0';
				n = scan();
			}
			else throw new InputMismatchException();
		}
		return neg*integer;
	}
	
	private int scanInt() throws IOException {
		int integer = 0;
		int n = scan();
		while(isWhiteSpace(n))
			n = scan();
		int neg = 1;
		if(n == '-'){
			neg = -1;
			n = scan();
		}
		while(!isWhiteSpace(n)){
			if(n >= '0' && n <= '9'){
				integer *= 10;
				integer += n - '0';
				n = scan();
			}
			else throw new InputMismatchException();
		}
		return neg*integer;
	}
	
	public double scandouble() throws IOException{
		double doubll = 0;
		int n = scan();
		int neg = 1;
		while(isWhiteSpace(n))
			n = scan();
		if(n == '-'){
			neg = -1;
			n = scan();
		}
		while(!isWhiteSpace(n) && n != '.'){
			if(n >= '0' && n <= '9'){
				doubll *= 10;
				doubll += n - '0';
				n = scan();
			}
		}
		if(n == '.'){
			n = scan();
			double temp = 1;
			while(!isWhiteSpace(n)){
				if(n >= '0' && n <= '9'){
					temp /= 10;
					doubll += (n - '0')*temp;
					n = scan();
				}
			}
		}
		return neg*doubll;
	}
	
	private float scanfloat() throws IOException {
		float doubll = 0;
		int n = scan();
		int neg = 1;
		while(isWhiteSpace(n))
			n = scan();
		if(n == '-'){
			neg = -1;
			n = scan();
		}
		while(!isWhiteSpace(n) && n != '.'){
			if(n >= '0' && n <= '9'){
				doubll *= 10;
				doubll += n - '0';
				n = scan();
			}
		}
		if(n == '.'){
			n = scan();
			double temp = 1;
			while(!isWhiteSpace(n)){
				if(n >= '0' && n <= '9'){
					temp /= 10;
					doubll += (n - '0')*temp;
					n = scan();
				}
			}
		}
		return neg*doubll;
	}
	public String scanstring() throws IOException{
		StringBuilder sb = new StringBuilder();
		int n = scan();
		while(isWhiteSpace(n))
			n = scan();
		while(!isWhiteSpace(n)){
			sb.append((char)n);
			n = scan();
		}
		return sb.toString();
	}
	
	
	public boolean isWhiteSpace(int n){
		if(n == ' ' || n == '\n' || n == '\r' || n == '\t' || n == -1)
			return true;
		return false;
	}
/// Input module 	
	
	public int nextInt() throws IOException{
	  return scanInt();
	}
	
	public long nextLong() throws IOException{
		  return  scanlong();
		}
	
	public double nextDouble() throws IOException{
		  return  scandouble();
		}
	
	public float nextFloat() throws IOException{
		  return scanfloat();
		}

	public String next() throws IOException{
		return scanstring();
	}
}


// output writer
static class Printer{
	private final BufferedWriter bw;
	public Printer(OutputStream out){
		bw = new BufferedWriter(new OutputStreamWriter(out));
	}
	
    public void print(Object...objects) throws IOException{
    	for(int i = 0; i < objects.length; i++){
    		if(i != 0)
    			bw.append(' ');
    		bw.append(objects[i].toString());
    	}
    }
	public void print(String str) throws IOException{
		bw.append(str);
	}
	
	public void println(Object...objects) throws IOException {
		print(objects);
		bw.append("\n");
	}
	
	public void close() throws IOException{
		bw.close();
	}
	
	public void flush() throws IOException{
		bw.flush();
	}
}

static class IOUtils {
    public static int[] readIntArray(InputReader in, int size) throws IOException {
        int[] array = new int[size];
        for (int i = 0; i < size; i++) {
            array[i] = in.nextInt();
        }
        return array;
    }
  }
}

