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 (Python):
h, a= map(int, input().split())
print(-(-h//a))

Solution (Python):
H, A = list(map(int, input().split()))
x = H // A
if H % A != 0:
  x += 1
print(x)

Solution (Python):

H, A = map(int, input().split())

print((H + A - 1) // A)

Solution (Python):
import math
a,b=map(int,input().split())

print(math.ceil(a/b))

Solution (Python):
h, a = map(int, input().split())
if h % a == 0:
    print(h//a)
else:
    print(h//a+1)

Solution (Python):
import math
h,a=map(int,input().split())
print(math.ceil(h/a))

Solution (Python):
from math import ceil
h,a = map(int,input().split())
print(ceil(h/a))

Solution (Python):


H, A = map(int, input().split())


ans = 0
while H > 0:
  ans += 1
  H -= A

print(ans)

Solution (Python):
h, a = map(int, input().split())
print((h - 1) // a + 1)

Solution (Python):




def solve(inp):
    import math
    (H, A) = map(int, inp.readline().strip().split(' '))

    r = math.ceil(H / A)
    return r


def main():
    import sys
    result = solve(sys.stdin)
    if result is not None and result != '':
        print(result)


if __name__ == '__main__':
    main()

Solution (Python):
A,B = [int(n) for n in input().split()]
print(A//B + (1 if A%B != 0 else 0))

Solution (Python):
import math
H, A = map(int, input().split())
print(math.ceil(H/A))

Solution (Python):
H,A=map(int,input().split())

print(H//A if H%A==0 else H//A+1)

Solution (Python):
import sys, math
def input():
    return sys.stdin.readline()[:-1]
from itertools import permutations, combinations
from collections import defaultdict, Counter, deque
from math import factorial
from fractions import gcd
e = enumerate

sys.setrecursionlimit(10**7)
H, A = map(int, input().split())

if H%A==0:
    print(H//A)
else:
    print(H//A+1)

Solution (Python):
h,a = map(int,input().split())
print(h//a+1 if h%a!=0 else h//a)

Solution (Python):
h,a=map(int,input().split())

print((h-1)//a+1)

Solution (Python):
import math
H, A = map(int, input().split())
print(math.ceil(H / A))

Solution (Python):
import math
h,a=map(int,input().split())

print(math.ceil(h/a))

Solution (Python):
H, A = map(int,input().split())

count = 0
while H > 0:
    H -= A
    count += 1

print(count)

Solution (Python):
H, A = map(int, input().split())

ans = -(-H//A)
print(ans)

Solution (Python):
h, a = map(int, input().split())
n = (h + a - 1) // a
print(n)

Solution (Python):
H, A = map(int, input().split())
print(H//A + (0 if H%A == 0 else 1))

Solution (Python):
H, A = map(int, input().split())
print((H+A-1)//A)

Solution (Python):
import sys
sys.setrecursionlimit(10**6)
from math import floor,ceil,sqrt,factorial,log
from heapq import heappop, heappush, heappushpop
from collections import Counter,defaultdict,deque
from itertools import accumulate,permutations,combinations,product,combinations_with_replacement
from bisect import bisect_left,bisect_right
from copy import deepcopy
from operator import itemgetter
from fractions import gcd
mod = 10 ** 9 + 7
 

def ii(): return int(sys.stdin.readline().rstrip()) 
def mii(): return map(int,sys.stdin.readline().rstrip().split())
def limii(): return list(mii()) 
def lin(n:int): return [ii() for _ in range(n)]
def llint(n: int): return [limii() for _ in range(n)]

def ss(): return sys.stdin.readline().rstrip() 
def mss(): return sys.stdin.readline().rstrip()
def limss(): return list(mss()) 
def lst(n:int): return [ss() for _ in range(n)]
def llstr(n: int): return [limss() for _ in range(n)]

h,a = mii()
cnt=0
while h >0:
    h -=a
    cnt+=1
    
print(cnt)

Solution (Python):
import math
h,a = map(int,input().split())
print(math.ceil(h/a))

Solution (Python):
H, A = map(int, input().split())
n = 0
while H > 0:
  H -= A
  n += 1
print(n)

Solution (Python):
import sys
input=sys.stdin.readline
h,a=map(int,input().split())
ans=(h+a-1)//a
print(ans)

Solution (Python):
H, A = map(int,input().split())

if H % A == 0:
    print(H // A)
else:
    print((H // A) + 1)

Solution (Python):
import math
h,a=map(int,input().split())
print(math.ceil(h/a))

Solution (Python):
import sys
import math
import heapq
sys.setrecursionlimit(10**7)
INTMAX = 9223372036854775807
INTMIN = -9223372036854775808
DVSR = 1000000007
def POW(x, y): return pow(x, y, DVSR)
def INV(x, m=DVSR): return pow(x, m - 2, m)
def DIV(x, y, m=DVSR): return (x * INV(y, m)) % m
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def II(): return int(sys.stdin.readline())
def FLIST(n):
    res = [1]
    for i in range(1, n+1): res.append(res[i-1]*i%DVSR)
    return res

H, A = LI()
print(H // A + (1 if H%A else 0))

Solution (Python):
H, A = map(int, input().split())
print((H + A - 1) // A)

Solution (Python):


iim = lambda: map(int, input().rstrip().split())

def resolve():
    H, A = iim()

    a, b = divmod(H, A)
    if b: a += 1
    print(a)

if __name__ == "__main__":
    resolve()

Solution (Python):
import sys







def main():
    H, A = map(int, input().split())
    print((H+A-1)//A)


if __name__ == '__main__':
    main()

Solution (Python):
H, A = map(int, input().split())

print((H + (A - 1)) // A)

Solution (Python):
H,A=[int(i) for i in input().split(" ")]
if H%A==0:
    print(H//A)
else:
    print(H//A+1)

Solution (Python):
from math import ceil
h, a = map(int, input().split())

print(ceil(h/a))

Solution (Python):
H, A = map(int, input().split())

q, r = divmod(H, A)
if r > 0:
    q += 1
print(q)

Solution (Python):
import sys
import math
from collections import deque
input = sys.stdin.readline
H , A = map(int,input().split())
for i in range(1, 10**9):
    H -= A
    if H <= 0:
        print(i)
        break

Solution (Python):
h,a=map(int,input().split())
print((h+a-1)//a)

Solution (Python):
a,b=map(int,input().split())
print((a+b-1)//b)

Solution (Python):
H,A = map(int,input().split())
if H%A==0:
  print(H//A)
else:
  print((H//A)+1)

Solution (Python):

H,A = list(map(int,input().split()))

print((H+A-1)//A)

Solution (Python):
from math import ceil
h, a = map(int, input().split())

print(ceil(h/a))

Solution (Python):

import copy
import random
import bisect 
import fractions 
import math
import sys
import bisect

mod = 10**9+7
sys.setrecursionlimit(mod) 

def LI(): return list(map(int, sys.stdin.readline().split()))

H, A = LI()
print(math.ceil(H/A))

Solution (Python):
from heapq import heappush, heappop, heapify
from collections import deque, defaultdict, Counter
import itertools
from itertools import permutations, combinations, accumulate
import sys
import bisect
import string
import math
import time


def I(): return int(input())


def S(): return input()


def MI(): return map(int, input().split())


def MS(): return map(str, input().split())


def LI(): return [int(i) for i in input().split()]


def LI_(): return [int(i)-1 for i in input().split()]


def StoI(): return [ord(i)-97 for i in input()]


def ItoS(nn): return chr(nn+97)


def input(): return sys.stdin.readline().rstrip()


def show(*inp, end='\n'):
    if show_flg:
        print(*inp, end=end)


YN = {False: 'No', True: 'Yes'}
MOD = 10**9+7
inf = float('inf')
IINF = 10**10
l_alp = string.ascii_lowercase
u_alp = string.ascii_uppercase
ts = time.time()
sys.setrecursionlimit(10**6)
nums = ['1', '2', '3', '4', '5', '6', '7', '8', '9', '10']

show_flg = False



def main():
    A, B = MI()
    print(int(math.ceil(A / B)))


if __name__ == '__main__':
    main()

Solution (Python):
H, A = map(int, input().split())

print(-(-H//A))

Solution (Python):
import queue
import copy
import math
from collections import deque

h, a = map(int, input().split())

d, m = divmod(h, a)

if m == 0:
    print(d)
else:
    print(d+1)

Solution (Python):
from math import ceil
h,a= map(int, input().split())
print(ceil(h/a))

Solution (Python):
H, A = map(int, input().split())
ans = (H+A-1) // A
print(ans)

Solution (Python):
from math import ceil
h, a = map(int, input().split())
print(ceil(h/a))

Solution (Python):
H,A=map(int, input().split())
import math
print(math.ceil(H/A))

Solution (Python):
a,b=list(map(int, input().split()))
if a%b==0:
  print(a//b)
else:
  print(a//b +1)

Solution (Python):

import sys
input = sys.stdin.buffer.readline


from collections import defaultdict

con = 10 ** 9 + 7

def getlist():
	return list(map(int, input().split()))


def main():
	H, A = getlist()
	if H % A == 0:
		print(int(H // A))
	else:
		print(int(H // A) + 1)
	


if __name__ == '__main__':
	main()

Solution (Python):
h,a = map(int,input().split())
print(-(-h//a))

Solution (Python):
inputs = input().split(" ")
h = int(inputs[0])
a = int(inputs[1])

print(h//a if h%a == 0 else h//a+1)

Solution (Python):



import array
from bisect import *
from collections import *
import fractions
import heapq
from itertools import *
import math
import random
import re
import string
import sys

H, A = map(int, input().split())
print((H + (A - 1)) // A)

Solution (Python):

h,a=map(int,input().split())
import math
print(math.ceil(h/a))

Solution (Python):
import math
H, A = map(int, input().split())
print(math.ceil(H/A))

Solution (Python):
import math

h,a = map(int,input().split())

print(math.ceil(h/a))

Solution (Python):
H, A = map(int, input().split())

ans = (H+A-1)//A

print(ans)

Solution (Python):
H, A=map(int, input().split())
out=H//A
if H%A>0:
  out+=1
print(out)

Solution (Python):
import copy
a,b=map(int,input().split())
cut=0
while a>0:
    a-=b
    cut+=1

print(cut)

Solution (Python):
h,a = map(int, input().split())
import math
print(math.ceil(h/a))

Solution (Python):
import math
H, A = map(int, input().split())

print(math.ceil(H / A))

Solution (Python):
import math
import fractions
import bisect
import collections
import itertools
import heapq
import string
import sys
import copy
from collections import deque
sys.setrecursionlimit(10**7)
MOD = 10**9+7
def gcd(a,b):return fractions.gcd(a,b) 
def lcm(a,b):return (a*b) // fractions.gcd(a,b) 
def iin(): return int(input()) 
def ifn(): return float(input()) 
def isn(): return input().split() 
def imn(): return map(int, input().split()) 
def fmn(): return map(float, input().split()) 
def iln(): return list(map(int, input().split())) 
def iln_s(): return sorted(iln()) 
def iln_r(): return sorted(iln(), reverse=True) 
def fln(): return list(map(float, input().split())) 
def join(l, s=''): return s.join(l) 
def perm(l, n): return itertools.permutations(l, n) 
def perm_count(n, r): return math.factorial(n) // math.factorial(n-r) 
def comb(l, n): return itertools.combinations(l, n) 
def comb_count(n, r): return math.factorial(n) // (math.factorial(n-r) * math.factorial(r)) 
def two_distance(a, b, c, d): return ((c-a)**2 + (d-b)**2)**.5 
def m_add(a,b): return (a+b) % MOD

H,A = imn()

print(math.ceil(H/A))

Solution (Python):
h, a = map(int, input().split())
print((h - 1) // a + 1)

Solution (Python):














a, b = map(int, input().split())


def ceil(a, b):
    return -(-a // b)


print(ceil(a, b))

Solution (Python):
h,a=map(int,input().split())
print(h//a+(h%a>0))

Solution (Python):
h, a = map(int, input().split())
print(-(-h//a))

Solution (Python):

h, a = map(int, input().split())
if h%a == 0:
    print(h//a)
else:
    print(h//a+1)

Solution (Python):
H,A = map(int,input().split())
print((H-1)//A+1)

Solution (Python):
h, a = map(int, input().split())

print(-(-h//a))

Solution (Python):


from fractions import gcd
import math

from math import factorial as f

from math import ceil,floor,sqrt


import bisect
import re
import heapq


from copy import deepcopy
import itertools

from sys import exit

ii = lambda : int(input())
mi = lambda : map(int,input().split())
li = lambda : list(map(int,input().split()))


def main():
    h,a = mi()
    print(ceil(h/a))

        



main()

Solution (Python):
import math
H, A = [int(i) for i in input().split()]
print(math.ceil(H/A))

Solution (Python):
import math
H,A=map(int,input().split())
print(math.ceil(H/A))

Solution (Python):
import math
H, A = map(int, input().split())
print(math.ceil(H / A))

Solution (Python):
h, a = map(int, input().split())

result = h // a
if h % a != 0:
    result+= 1
print(result)

Solution (Python):



H,A=map(int,input().split())

print(-(-H//A))

Solution (Python):

h, a = map(int, input().split())

print(-(-h//a))

Solution (Python):
import math
H, A = map(int, input().split())

ans = math.ceil(H/A)

print(ans)

Solution (Python):
import math

h, a = map(int, input().split())

print(math.ceil(h/a))

Solution (Python):
h,a=map(int,input().split())
print(-(-h//a))

Solution (Python):
h,a=map(int,input().split())
print(-(-h//a))

Solution (Python):
a,b = map(int,input().split())
print((b+a-1)//b)

Solution (Python):

H, A = map(int, input().split())
ans = 0
while H > 0:
    H = H - A
    ans += 1
    
print(ans)

Solution (Python):
import sys
from math import ceil

def get_array(): return list(map(int, sys.stdin.readline().split()))
def get_ints(): return map(int, sys.stdin.readline().split())

h,a = get_ints()
print(int(ceil(h/a)))

Solution (Python):
H, A = map(int, input().split())

if H % A == 0:
    print(H // A)
else:
    print(H // A + 1)

Solution (Python):
h, a = map(int, input().split())
import math
print(math.ceil(h / a))

Solution (Python):
h,a=[int(j) for j in input().split()]
import math
print(math.ceil(h/a))

Solution (Python):

H,A = map(int,input().split())

if H % A == 0:
    print (H // A)
else:
    print (H//A + 1)

Solution (Python):
h,a = map(int,input().split())
print((h+a-1)//a)

Solution (Python):
H, A = map(int, input().split())

import math

print(math.ceil(H/A))

Solution (Python):
def main():

    H, A = map(int, input().split())
    if H % A == 0:
        return H // A
    return H // A + 1

if __name__ == '__main__':
    print(main())

Solution (Python):
import math

h,a=map(int,input().split())
print(math.ceil(h/a))

Solution (Python):
H, A = map(int, input().split())

ans = -(-H // A)

print(ans)

Solution (Python):
import sys
sys.setrecursionlimit(4100000)

import math

import logging

logging.basicConfig(level=logging.DEBUG)

logger = logging.getLogger(__name__)


def resolve():
    
    
    H, A = [int(x) for x in sys.stdin.readline().split()]  
    
    
    

    logger.debug('{}'.format([]))

    print(math.ceil(H / A))


if __name__ == "__main__":
    resolve()





import sys
from io import StringIO
import unittest


class TestClass(unittest.TestCase):
    def assertIO(self, input, output):
        stdout, stdin = sys.stdout, sys.stdin
        sys.stdout, sys.stdin = StringIO(), StringIO(input)
        resolve()
        sys.stdout.seek(0)
        out = sys.stdout.read()[:-1]
        sys.stdout, sys.stdin = stdout, stdin
        self.assertEqual(out, output)

    def test_入力例_1(self):
        input = """10 4"""
        output = """3"""
        self.assertIO(input, output)

    def test_入力例_2(self):
        input = """1 10000"""
        output = """1"""
        self.assertIO(input, output)

    def test_入力例_3(self):
        input = """10000 1"""
        output = """10000"""
        self.assertIO(input, output)

Solution (Python):
import math

H,A=map(int,input().split())
print(math.ceil(H/A))

Solution (Python):
h,a = map(int,input().split())
print(((h-1)//a)+1)

Solution (Python):
import math
a,b=map(int,input().split())
print(math.ceil(a/b))

Solution (Python):
h, a = map(int, input().split())

count = h // a + bool(h % a)
print(count)

Solution (Python):
h,a = map(int, input().split())
ans = -(-h//a)
print(ans)

Solution (Python):
H, A = map(int, input().split())
print(-(-H//A))

Solution (Python):
H,A = map(int,input().split())
if H % A == 0:
    print(H // A)
else:
    print(H // A + 1)

Solution (Python):
import math

h, a = map(int, input().split())
print(math.ceil(h / a))

Solution (Python):
def examA():
    H,A = LI()
    ans = (H-1)//A+1
    print(ans)
    return

def examB():
    ans = 0
    print(ans)
    return

def examC():
    ans = 0
    print(ans)
    return

def examD():
    ans = 0
    print(ans)
    return

def examE():
    ans = 0
    print(ans)
    return

def examF():
    ans = 0
    print(ans)
    return

import sys,copy,bisect,itertools,heapq,math
from heapq import heappop,heappush,heapify
from collections import Counter,defaultdict,deque
def I(): return int(sys.stdin.readline())
def LI(): return list(map(int,sys.stdin.readline().split()))
def LSI(): return list(map(str,sys.stdin.readline().split()))
def LS(): return sys.stdin.readline().split()
def SI(): return sys.stdin.readline().strip()
global mod,mod2,inf,alphabet
mod = 10**9 + 7
mod2 = 998244353
inf = 10**18
alphabet = [chr(ord('a') + i) for i in range(26)]

if __name__ == '__main__':
    examA()

"""

"""

Solution (Python):
import math
h, a = map(int, input().split())

print(math.ceil(h / a))

Solution (Python):
from math import ceil
h, a = map(int,input().split())
print(ceil(h/a))

Solution (Python):
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(500000)

H, A = map(int, read().split())

print((H + A - 1) // A)

Solution (Python):
import math
h, a = map(int, input().split())

print(math.ceil(h/a))

Solution (Python):
H,A=map(int,input().split())
import math

print(math.ceil(H/A))

Solution (Python):
H,A=map(int, input().split())
print((H+A-1)//A)

Solution (Python):
import math
a,b = map(int,input().split())
print(math.ceil(a/b))

Solution (Python):
H, A = map(int, input().split())
f = H // A
if H % A > 0: f += 1
print(f)

Solution (Python):
H, A = map(int, input().split())

print((H-1)//A+1)

Solution (Python):
H,A = map(int,input().split())

from math import ceil
print(ceil(H/A))

Solution (Python):
import math

def makelist(n, m):
    return [[0 for _ in range(m)] for _ in range(n)]





H, A = list(map(int, input().split()))
ans = (H + (A-1)) // A
print(ans)

Solution (Python):
from math import ceil
H, A  = list(map(int, input().split()))



print(ceil(H / A))

Solution (Python):
H, A = map(int, input().split())

print(-(-H // A))

Solution (Python):
import numpy as np 
h,a = map(int, input().split())
print(int(np.ceil(h/a)))

Solution (Python):
h, a = map(int, input().split())

ans = h / a
if int(ans) == ans:
    print(int(ans))
else:
    print(int(ans) + 1)

Solution (Python):
H, A = map(int, input().split())

print((H-1) // A + 1)

Solution (Python):
import math

H,A = list(map(int,input().split()))

print(math.ceil(H/A))

Solution (Python):
h,a=map(int,input().split())

if h%a==0:
 print(h//a)
else:
 print(h//a+1)

Solution (Python):
h,a=map(int,input().split())

print((h+a-1)//a)

Solution (Python):
from sys import stdin
import math
a,b = [int(x) for x in stdin.readline().rstrip().split()]
print(math.ceil(a/b))

Solution (Python):
import math
h, a= map(int, input().split())
print(int(math.ceil(h/a)))

Solution (Python):
def main():
    H, A = map( int, input().split())
    print((H+A-1)//A)
if __name__ == '__main__':
    main()

Solution (Python):
H,A = map(int,input().split())
print(-(-H//A))

Solution (Python):

import sys, math, itertools, collections, bisect
input = lambda: sys.stdin.buffer.readline().rstrip().decode('utf-8')
inf = float('inf') ;mod = 10**9+7
mans = inf ;ans = 0 ;count = 0 ;pro = 1

a,b=map(int,input().split())
print(math.ceil(a/b))

Solution (Python):
h, a = list(map(int, input().split()))
print((h + a - 1) // a)

Solution (Python):
h, a = [int(i) for i in input().split()]
if h%a==0:
    print(h//a)
else:
    print(h//a+1)

Solution (Python):
h, a = map(int, input().split())
print(h // a + 1 if h % a else h // a)

Solution (Python):
import math
H, A = map(int, input().split())
print(math.ceil(H/A))

Solution (Python):
from math import ceil

H, A = map(int, input().split())

print(ceil(H/A))

Solution (Python):
H, A = map(int, input().split())
print(-(-H//A))

Solution (Python):
h,a = map(int,input().split())
if h%a==0:
    print(h//a)
else:
    print(h//a+1)

Solution (Python):
H, A = map(int, input().split())

ret = H // A
if H % A != 0 :
  ret += 1
  
print(ret)

Solution (Python):
import math
a,b = map(int,input().split())
print(math.ceil(a/b))

Solution (Python):
H,A = map(int,input().split())

if H % A == 0:
    ans = H // A
else:
    ans = H // A + 1
print(ans)

Solution (Python):
h,a = map(int,input().split())
ngo = h//a
if ngo == h/a:
    print(ngo)
else:
    print(ngo+1)

Solution (Python):
def div_ceil(x, y): return (x + y - 1) // y

H, A = map(int, input().split())
print(div_ceil(H, A))

Solution (Python):


import math
h,a=map(int,input().split())
print(math.ceil(h/a))

Solution (Python):
H,A= map(int,input().split())
import math
ans = math.ceil(H/A)
print(ans)

Solution (Python):
H,A = map(int,input().split())
print((H+A-1)//A)

Solution (Python):
import math
H,A = map(int,input().split())

print(math.ceil(H/A))

Solution (Python):
H, A = map(int, input().split())

print ((H + A - 1) // A)

Solution (Python):
import sys
 
stdin = sys.stdin

mod = 1000000007
inf = 1 << 60
 
ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))
ns = lambda: stdin.readline().rstrip()
nas = lambda: stdin.readline().split()

h, a = na()

if h % a == 0:
    print(h // a)
else:
    print(h // a + 1)

Solution (Python):
H, A = [int(i) for i in input().split()]
ans = -(-H // A)
print(ans)

Solution (Python):
import sys, re, os
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians

from itertools import permutations, combinations, product, accumulate
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from functools import reduce
from bisect import bisect_left, insort_left
from heapq import heapify, heappush, heappop

INPUT = lambda: sys.stdin.readline().rstrip()
INT = lambda: int(INPUT())
MAP = lambda: map(int, INPUT().split())
S_MAP = lambda: map(str, INPUT().split())
LIST = lambda: list(map(int, INPUT().split()))
S_LIST = lambda: list(map(str, INPUT().split()))

sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7


def main():
    H, A = MAP()
    print(ceil(H/A))


if __name__ == '__main__':
    main()

Solution (Python):
def main():
    from sys import stdin, setrecursionlimit
    
    
    r = stdin.readline()[:-1]
    
    
    
    
    
    
    a,b = map(int, r.split())
    
    
    
    
    print(-(-a//b))

if __name__ == '__main__':
    main()

Solution (Python):
H,A = map(int,input().split())
print((H-1)//A+1)

Solution (Python):
import sys
input = sys.stdin.readline
H, A = map(int, input().split())
print(-(-H // A))

Solution (Python):
import sys

h, a = map(int, sys.stdin.readline().split())

def main():
    return (h + a - 1) // a

if __name__ == '__main__':
    ans = main()
    print(ans)

Solution (Python):
import math

h, a = map(int,input().split())
print(math.ceil(h/a))

Solution (Python):
h, a = map(int, (input().split()))
print(-(-h // a))

Solution (Python):
from math import ceil
H,A = map(int,input().split())
print(ceil(H/A))

Solution (Python):
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10 ** 7)

H, A = map(int, input().split())

print(-(-H//A))

Solution (Python):
import math
h,a=map(int,input().split())
print(math.ceil(h/a))

Solution (Python):
def main():
    a, b = map(int, input().split())
    print((a-1)//b+1)


main()

Solution (Python):
h,a=map(int,input().split())
print(h//a+1 if h%a!=0 else h//a)

Solution (Python):
from math import ceil

h, a = map(int, input().split())

ans = ceil(h / a)
print(ans)

Solution (Python):
def main():
    H, A = (int(i) for i in input().split())
    from math import ceil
    print(ceil(H/A))


if __name__ == '__main__':
    main()

Solution (Python):
H,A = map(int,input().split())
if H%A == 0:
    print(H//A)
else:
    print(H//A+1)

Solution (Python):

import sys


def solve(H: int, A: int):
    print(-(-H//A))
    return



def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    H = int(next(tokens))  
    A = int(next(tokens))  
    solve(H, A)

if __name__ == '__main__':
    main()

Solution (Python):
import math
h,a = map(int,input().split())
print(math.ceil(h/a))

Solution (Python):
h,a = map(int,input().split())
print(-(-h//a))

Solution (Python):
h, a = map(int, input().split())
if h % a == 0:
    print(h // a)
else:
    print(h // a + 1)

Solution (Python):
import sys
from collections import *
import heapq
import math
import bisect
from itertools import permutations,accumulate,combinations,product
from fractions import gcd
def input():
    return sys.stdin.readline()[:-1]
mod=10**9+7

h,a=map(int,input().split())
print((h+a-1)//a)

Solution (Python):
H, A = map(int, input().split())
print((H + A - 1) // A)

Solution (Python):
H, A = map(int, input().split())

print(-(-H//A))

Solution (Python):
H, a = map(int, input().split())
ans = (H + a - 1) // a
print(ans)

Solution (Python):
import os,sys
from io import BytesIO, IOBase

def ii(): return int(input())
def si(): return input()
def mi(): return map(int,input().split())
def li(): return list(mi())

mod=1000000007

import math  

for i in range(1):
    n,m=mi()
    print(math.ceil(n/m))

Solution (Python):
import math
H, A = map(int, input().split())
print(math.ceil(H / A))

Solution (Python):
H, A = map(int, input().split())
ans = (H+A-1)//A
print(ans)

Solution (Python):
import sys
input = sys.stdin.readline
h,a=map(int,input().split())

print(-(-h//a))

Solution (Python):
h,a=map(int,input().split())
print(-(-h//a))

Solution (Python):
h,a=map(int,input().split())
print((h-1)//a+1)

Solution (Python):

h,a = map(int, input().split())
print(-(-h//a))

Solution (Python):

import sys
INF = float("inf")


def solve(H: int, A: int):
    print(-(-H//A))
    return


def main():

    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    H = int(next(tokens))  
    A = int(next(tokens))  
    solve(H, A)


if __name__ == '__main__':
    main()

Solution (Python):
h,a = map(int, input().split())
ans = -(-h//a)
print(ans)

Solution (Python):
H, A = map(int, input().split())
if H % A == 0:
    print(H // A)
else:
    print(H // A + 1)

Solution (Python):
H, A = map(int, input().split())
print(-(-H // A))

Solution (Python):
import math
h, a = map(int, input().split())
print(math.ceil(h / a))

Solution (Python):
h, a = map(int, input().split())
ans = -(-h // a)
print(int(ans))

Solution (Python):
from math import ceil
H, A = map(int, input().split())
print(ceil(H / A))

Solution (Python):
H,A = map(int,input().split())
print(H//A + bool(H%A))

Solution (Python):
h,a=map(int,input().split())
print((h+a-1)//a)

Solution (Python):
H,A=map(int,input().split())
print((H+A-1)//A)

Solution (Python):
H,A=map(int,input().split())
print(-(-H//A))

Solution (Python):
h,a=map(int,input().split())
print(-(-h//a))

Solution (Python):
h,a = map(int,input().split())
print(((h-1)//a)+1)

Solution (Python):
def main():
    h, a = map(int, input().split())
    x = (h + (a - 1)) // a
    print(x)


if __name__ == '__main__':
    main()

Solution (Python):
h, a = map(int, input().split())
print(-((-h) // a))

Solution (Python):
import math
a,b=map(int,input().split())
print(math.ceil(a/b))

Solution (Python):
h,a = map(int,input().split())

def ceil(a, b):
   return a // b + (a % b > 0)

print(ceil(h,a))

Solution (Python):
h, a = [int(i) for i in input().split()]
if h % a == 0:
    print(h // a)
else:
    print(h//a+1)

Solution (Python):

H,A = map(int,input().split())
import math
ans = math.ceil(H/A)
print(ans)

Solution (Python):
n, a = map(int, input().split())
print((n+a-1)//a)

Solution (Python):
H,A=map(int,input().split())
print(-(-H//A))

Solution (Python):

h,a = map(int,input().split())

import math
print(math.ceil(h/a))

Solution (Python):
h,a=map(int,input().split())
print(h//a+(h%a>0))

Solution (Python):
import math
import itertools
import fractions
import heapq
import collections
import bisect
import sys
import copy

sys.setrecursionlimit(10**9)
mod = 998244353
inf = 10**20

def LI(): return list(map(int, sys.stdin.readline().split()))
def LLI(): return [list(map(int, l.split())) for l in sys.stdin.readlines()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def S(): return input()

h,a = LI()
print(math.ceil(h/a))

Solution (Python):
h,a=map(int,input().split())
print((h+a-1)//a)

Solution (Python):
a,b=map(int,input().split())
print(-(-a//b))

Solution (Python):
h,a = map(int,input().split())
print(h//a + int(bool(h%a)))

Solution (Python):
h,a=map(int,input().split())
print((h+a-1)//a)

Solution (Python):
h, a = map(int, input().split())
print(-(-h//a))

Solution (Python):
import sys

input = sys.stdin.readline


def main():
    H, A = [int(x) for x in input().split()]
    print(-(-H // A))
    



if __name__ == '__main__':
    main()

Solution (Python):
H, A = [int(i) for i in input().split()]
print((H + A - 1) // A)

Solution (Python):
import math
h,a = map(int, input().split())
print(math.ceil(h/a))

Solution (Python):
H, A = map(int, input().split())

print(-(-H//A))

Solution (Python):
b, c = map(int, input().split())

print((b+c-1) // c)

Solution (Python):
h,a = map(int, input().split())

print((h+a-1)//a)

Solution (Python):



def main():
    import sys
    input = sys.stdin.readline
    sys.setrecursionlimit(10**6)

    h, a = map(int, input().split())

    from math import ceil

    print(ceil(h/a))


if __name__ == '__main__':
    main()

Solution (Python):
def main():
    H, A = map(int, input().split())
    print((H + A - 1) // A)

main()

Solution (Python):
h,a=map(int,input().split())
print(-(-h//a))

Solution (Python):
import math
h,a = map(int,input().split())
print(math.ceil(h / a))

Solution (Python):


from collections import deque, defaultdict
import itertools as ite
import sys
import math
from decimal import *

sys.setrecursionlimit(1000000)

INF = 10 ** 18
MOD = 10 ** 9 + 7

A, B = map(int, raw_input().split())
print A / B + (A % B != 0)

Solution (Python):
H,A= map(int,input().split())

print(-(-H//A))

Solution (Python):
H,A = map(int,input().split())

print(-(-H//A))

Solution (Python):
H, A = map(int, input().split())
print((H+A-1)//A)

Solution (Python):
H, A = map(int, input().split())
print(-(-H//A))

Solution (Python):
a, b = map(int,input().split())
print(-(-a//b))