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 Fortran (gfortran v4.8.4) (judge verdict: Wrong Answer)

program kadai
implicit none
integer  ::  n,m
integer,allocatable  ::  a(:),b(:)
integer  ::  i,k,j
integer  ::  ans
integer  ::  loc

read(*,*) n,m
allocate(a(n))
allocate(b(n))

do i=1,n
    read(*,*) a(i),b(i)
end do


ans=0
call qsort(a,b)
j=1

do while (m>0)
    !write(*,*) a
    !write(*,*) ""
    if (a(1)==0) then
        write(*,*) ans
        stop
    end if
    do i=j,n
        if (a(i)>M) then
            a(i)=0
            b(i)=0
            j=j+1
        else
            exit
        end if
    end do
    !write(*,*) a
    !write(*,*) ""

    loc=maxloc(b,1)
    ans=ans+maxval(b)
    a(loc)=0
    b(loc)=0
    m=m-1

    !write(*,*) loc,ans,m

end do

write(*,*) ans


stop

contains


subroutine swap(a,b)
implicit none
integer,intent(inout)  ::  a,b
integer  ::  c
c=a
a=b
b=c
end subroutine swap

subroutine qsort(x,y)
implicit none
integer, intent(inout)  ::  x(:)
integer, intent(inout)  ::  y(:)
integer  ::  first,last
first=1
last=size(x)
call q2sort(x,y,first,last)
return
end subroutine qsort

recursive subroutine q2sort(x,y,first,last)
implicit none
integer, intent(inout)  ::  x(:)
integer, intent(inout)  ::  y(:)
integer, intent(inout) ::  first,last
integer  ::  fir, las
integer  ::  i,j
integer  ::  n
    n=x((first+last)/2)
    i=first
    j=last
    do
        do while (x(i)>n)
            i=i+1
        end do
        do while(x(j)<n)
            j=j-1
        end do
        if (i>j .or. i==j) then
            exit
        end if
        call swap(x(i),x(j))
        call swap(y(i),y(j))
        i=i+1
        j=j-1
    end do
    if (first<i-1) then
        las=i-1
        call q2sort(x,y,first,las)
    end if
    if (last>j+1) then
        fir=j+1
        call q2sort(x,y,fir,last)
    end if
end subroutine q2sort





end program kadai