Problem:
Score : 100 points

Problem Statement

Serval is fighting with a monster.

The health of the monster is H.

In one attack, Serval can decrease the monster's health by A.
There is no other way to decrease the monster's health.

Serval wins when the monster's health becomes 0 or below.

Find the number of attacks Serval needs to make before winning.

Constraints

1 \leq H \leq 10^4

1 \leq A \leq 10^4

All values in input are integers.

Input

Input is given from Standard Input in the following format:

H A

Output

Print the number of attacks Serval needs to make before winning.

Sample Input 1

10 4

Sample Output 1

3

After one attack, the monster's health will be 6.

After two attacks, the monster's health will be 2.

After three attacks, the monster's health will be -2.

Thus, Serval needs to make three attacks to win.

Sample Input 2

1 10000

Sample Output 2

1

Sample Input 3

10000 1

Sample Output 3

10000

Solution in Fortran (gfortran v4.8.4) (judge verdict: Runtime Error)

program main

  implicit none

  integer    :: n, k, i, j
  integer(8),allocatable :: h(:)
  integer(8) :: sumh
  
  read(*,*) n,k
  allocate( h(n) )
  read(*,*) h

  if ( k == 0 ) then
    sumh = 0
    do i = 1 ,n
      sumh = sumh + h(i)
    end do
    print*, sumh
    stop
  end if

  if ( k >= n ) then 
    print*, "0"
  else
    call quick_sort( h, 1, n ) 
    sumh = 0
    do i = 1 ,n-k
      sumh = sumh + h(i)
    end do
    print "(i0)", sumh
  end if

end program main
 recursive subroutine quick_sort( a, i, j )

  implicit none
  integer, intent(in) :: i,j
  integer(8), intent(inout) :: a(i:j)
  integer :: p, k

  if( i == j ) return
 
  p  = pivot(a,i,j)
 
  if( p /= -1 ) then
    call partition(a(i:j),i,j,a(p),k)
    call quick_sort(a(i:k-p),i,k-1)
    call quick_sort(a(k:j),k,j)
  end if

contains 

subroutine partition( a, i, j, x, l ) 
  
  implicit none
  integer, intent(in) :: i,j
  integer(8), intent(in) :: x
  integer(8), intent(inout) :: a(i:j)
  integer, intent(out) :: l
  integer :: r
  integer(8) :: t
   
  l = i 
  r = j 

  do while( l<=r )
    do while( l<=j .and. a(l) <  x ) 
      l = l+1
    end do
    do while( r> i .and. a(r) >= x ) 
      r = r-1
    end do
    if(l>r) exit
    t = a(l)
    a(l) = a(r)
    a(r) = t
    l = l+1
    r = r-1
  end do
  
end subroutine partition

function pivot( a, i, j ) result( k )

  implicit none
  integer, intent(in) :: i,j
  integer:: k
  integer(8), intent(in) :: a(i:j)

  k = i + 1

  do while( k<=j .and. a(i) == a(k) ) 
    k = k + 1
  end do

  if(k>j) k = -1

  if(a(i)>a(k)) k = i

end function pivot

end subroutine quick_sort