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 Python (3.4.3) (judge verdict: Wrong Answer)

import bisect
n, m = [int(i) for i in input().split()]
d = []
for i in range(n):
    a, b = [int(_) for _ in input().split()]
    d.append([a, b])

d.sort(reverse=True)
l = [-1 for i in range(m+1)]
for i in range(n):
    if d[i][0] <= m and l[d[i][0]] == -1:
        l[d[i][0]] = i
ans = 0
cand = []
key = []
for i in range(1, m+1):
    idx = bisect.bisect_left(cand, d[l[i]][1])
    if l[i] != -1 and idx == len(cand):
        ans += d[l[i]][1]
        if l[i] + 1 < n and d[l[i]+1][0] == d[l[i]][0]:
            idx = bisect.bisect_left(cand, d[l[i]+1][1])
            cand.insert(idx, d[l[i]+1][1])
            key.insert(idx, i)
            l[i] += 1
    else:
        if len(cand) > 0:
            ans += cand[-1]
            if l[key[-1]] + 1 < n and d[l[key[-1]]+1][0] == d[l[key[-1]]][0]:
                idx = bisect.bisect_left(cand, d[l[key[-1]]+1][1])
                cand[-1] = d[l[key[-1]]+1][1]
                l[key[-1]] += 1
            else:
                del cand[-1]
                del key[-1]
        if l[i] != -1:
            idx = bisect.bisect_left(cand, d[l[i]][1])
            cand.insert(idx, d[l[i]][1])
            key.insert(idx, i)
print(ans)