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: Accepted)

class Updatable_Binary_Heap
  def initialize(list: [])
    @a = [nil] + list.sort{ |a,b| (a <= b) ? -1 : 1 }.map.with_index{ |v,i| { i: i+1, v: v }  }
    @m = @a.size
  end

  def insert(x)
    node = { i: @m, v: x }
    case 
    when @m < @a.size
      @a[@m] = node
    else
      @a << node
    end
    up_heap(@m)
    @m += 1
    node
  end

  def up_heap(i)
    while (j = i >> 1) > 0
      break if @a[j][:v] <= @a[i][:v]
      swap_node(i,j)
      i = j
    end
    i
  end

  def head
    @a[@m > 1 ? 1 : 0]
  end

  def shift
    return nil if @m <= 1
    @m -= 1
    swap_node(1, @m)
    down_heap(1)
    @a[@m]
  end

  def down_heap(i)
    while (j = i << 1) < @m
      j |= ((j|1) < @m && @a[j][:v] > @a[j|1][:v]) ? 1 : 0
      break if (@a[i][:v] <= @a[j][:v])
      swap_node(i,j)
      i = j
    end
    i
  end

  def swap_node(i,j)
    ai = @a[i]; aj = @a[j]
    ai[:i], aj[:i] = aj[:i], ai[:i]
    @a[i], @a[j] = aj, ai
  end

  def update_node(node, x)
    i = node[:i]
    node[:v] = x
    down_heap(i) == i && up_heap(i)
  end

  def a
    @a[1...@m]
  end
end

N,M = gets.split.map &:to_i
ab = (0...N).map{ gets.split.map &:to_i }.sort_by{ |a,b| a }
st = Updatable_Binary_Heap.new()
D = 10000
ans = 0
(1..M).each{ |d|
  while ab.size > 0 && ab[0][0] <= d do
    a,b = ab.shift
    st.insert(-b)
  end
  b = st.shift
  next if !b
  ans -= b[:v]
}
p ans