Problem:
Score : 400 points

Problem Statement

There are N one-off jobs available. If you take the i-th job and complete it, you will earn the reward of B_i after A_i days from the day you do it.

You can take and complete at most one of these jobs in a day.

However, you cannot retake a job that you have already done.

Find the maximum total reward that you can earn no later than M days from today.

You can already start working today.

Constraints

All values in input are integers.

1 \leq N \leq 10^5

1 \leq M \leq 10^5

1 \leq A_i \leq 10^5

1 \leq B_i \leq 10^4

Input

Input is given from Standard Input in the following format:

N M
A_1 B_1
A_2 B_2
\vdots
A_N B_N

Output

Print the maximum total reward that you can earn no later than M days from today.

Sample Input 1

3 4
4 3
4 1
2 2

Sample Output 1

5

You can earn the total reward of 5 by taking the jobs as follows:

Take and complete the first job today. You will earn the reward of 3 after four days from today.

Take and complete the third job tomorrow. You will earn the reward of 2 after two days from tomorrow, that is, after three days from today.

Sample Input 2

5 3
1 2
1 3
1 4
2 1
2 3

Sample Output 2

10

Sample Input 3

1 1
2 1

Sample Output 3

0

Solution in Rust (1.15.1) (judge verdict: Time Limit Exceeded)

pub struct Poper<'a> {
	iter: std::str::SplitWhitespace<'a>,
}

impl<'a> Poper<'a> {
	pub fn new(iter: std::str::SplitWhitespace) -> Poper {
		Poper { iter: iter }
	}
	pub fn read<T: std::str::FromStr>(&mut self) -> T
	where
		<T as std::str::FromStr>::Err: std::fmt::Debug,
	{
		self.iter.next().unwrap().parse().unwrap()
	}
}

// const MOD: u64 = 1_000_000_007;

fn main() {
	let input = {
		use std::io::Read;
		let mut s = String::new();
		std::io::stdin().read_to_string(&mut s).unwrap();
		s
	};
	let mut iter = Poper::new(input.split_whitespace());

	let n: usize = iter.read();
	let m: usize = iter.read();

	let works = {
		let mut works: Vec<(u64, isize)> = (0..n)
			.into_iter()
			.map(|_| {
				let a: isize = iter.read();
				let b: u64 = iter.read();
				(b, 1 - a)
			})
			.collect();
		works.sort_by(|a, b| b.cmp(a));
		works
	};

	// println!("{:?}", works);

	let mut free: Vec<Option<usize>> = vec![None; m];
	let mut sum: u64 = 0;
	// let mut m = m;
	'h: for (b, i) in works {
		let i = (0 - i) as usize;
		if i < m {
			let mut j = i;
			'c: while j < m {
				match free[j] {
					None => {
						sum += b;
						for l in i..j + 1 {
							free[l] = Some(j + 1);
						}
						continue 'h;
					}
					Some(j1) => {
						j = j1;
						continue 'c;
					}
				}
			}
		}
	}

	println!("{}", sum);
}