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 Ruby (2.3.3) (judge verdict: Wrong Answer)

n,m = gets.split.map(&:to_i)
t = [0,0].freeze
ab = Array.new(n+1) {|i|
  x = (gets||'0 0').split.map(&:to_i) 
  x[0] <= m ? x : t
}.sort!
h = {}
(n+1).times {|i|
  x = ab[-1-i][0]
  next  if x == h.keys[-1]
  break  if x == 0
  h[x] = n-i
}
h[0] = 0

ks = h.keys.reverse!
v = 0
mi = Array.new(x=h.size)
mv = Array.new(x)
bv = Array.new(x) {|i|
  mi[i], mv[i] = (t[1]<v ? (t=[i,v]) : t)
  v = ab[h[ks[i]]][1]
}

pop_max = lambda {|o,hi;i,x|
    i = mv[o]>bv[o] ? mi[o] : o
    ai = h[hi]
    ai = h[hi] = ab[ai-1][0]==ab[ai][0] ? ai-1 : 0
    max = bv[i]
    bv[i] = v = ab[ai][1]

    return max  if max == mv[o]
    o,x = mv[i]<v ? [i,v] : [mi[i],mv[i]]    
    while v = mv[i+=1]
      break i+=1  if v > max
      if v > x
        t = (o+1)..i
        mi.fill(o,t)
        mv.fill(x,t)
        o,x = i,v
        return max  if o+1 == mv.size
      end
    end
    t = (o+1)...i
    mi.fill(o,t)
    mv.fill(x,t)
    max
  }

ki = 0
p (1..m).inject(0) {|x,i|
  ki += 1  if h[i]
  x + pop_max[ki,ks[ki]]
}