module priority_queue_modules
implicit none
integer(4), parameter:: inf = 1000000
integer(8), pointer:: array(:)
contains

subroutine build_heap(original)
    integer(8):: original(:)
    
    allocate(array(size(original)))
    array(:) = original(:)
    call build_max_heap()
end subroutine

recursive subroutine max_heapify(index)
    integer(8)::rc, lc, self
    integer(4):: index
    
    rc = array(index*2)
    lc = array(index*2+1)
    self = array(index)

    if (self > max(rc,lc)) return
    if (index*2 > size(array)) return
    if (index*2+1 > size(array)) lc = -1 

    if (rc >= lc)then
        array(index) = rc
        array(index*2) = self
        call max_heapify(index*2)
    else
        array(index) = lc
        array(index*2+1) = self
        call max_heapify(index*2+1)
    end if
end subroutine

subroutine build_max_heap()
    integer(4):: i
    
    do i = size(array)/2, 1, -1
        call max_heapify(i)
    end do
end subroutine

function pop_max_heap() result(ret)
    integer(8)::ret
    integer(8), pointer:: tmp(:)
    
    ret = array(1)
    array(1) = array(size(array))
    allocate(tmp(size(array)-1))
    tmp(:) = array(:size(array)-1)
    deallocate(array)
    allocate(array(size(tmp(:))))
    array(:) = tmp(:)
    deallocate(tmp)
    call max_heapify(1)
end function

function can_pop() result(ret)
    logical:: ret
    if (size(array) >= 1)then
        ret = .true.
    else
        ret = .false.
    end if
end function

end module


program main
    use priority_queue_modules, only: build_heap, pop_max_heap, can_pop
    implicit none
    integer(8), allocatable:: h(:), sorted_h(:)
    integer(4):: n, k, i
    logical:: l_can_pop

    read*, n, k
    allocate(h(n), sorted_h(n))
    read*, h(:)
    call build_heap(h(:))
    deallocate(h)
    do i=1, size(sorted_h(:))
        l_can_pop = can_pop()
        sorted_h(i) = pop_max_heap()
    end do

    print*, sum(sorted_h(k+1:))

end program main