You have unlimited number of coins with values $1, 2, \ldots, n$. You want to select some set of coins having the total value of $S$. 

It is allowed to have multiple coins with the same value in the set. What is the minimum number of coins required to get sum $S$?


-----Input-----

The only line of the input contains two integers $n$ and $S$ ($1 \le n \le 100\,000$, $1 \le S \le 10^9$)


-----Output-----

Print exactly one integer — the minimum number of coins required to obtain sum $S$.


-----Examples-----
Input
5 11

Output
3
Input
6 16

Output
3


-----Note-----

In the first example, some of the possible ways to get sum $11$ with $3$ coins are: 

  $(3, 4, 4)$

 $(2, 4, 5)$

 $(1, 5, 5)$

 $(3, 3, 5)$ 

It is impossible to get sum $11$ with less than $3$ coins.

In the second example, some of the possible ways to get sum $16$ with $3$ coins are: 

  $(5, 5, 6)$

 $(4, 6, 6)$ 

It is impossible to get sum $16$ with less than $3$ coins.

Difficulty: EASY
Tags: Mathematics

Implementation

Greedy algorithms
Skill types: Greedy algorithms
Expected Time Complexity: O(1)

Starter code:

Solutions:
import math

def transform(x):
	return int(x)
(n, S) = tuple(map(transform, input().split()))
minimum = math.ceil(S / n)
print(minimum)


(n, s) = list(map(int, input().split()))
ans = 0
while s > 0:
	s = s - min(s, n)
	ans += 1
print(ans)


import math
(a, b) = [int(i) for i in input().split()]
print(math.ceil(b / a))


(n, k) = map(int, input().split())
sum = 0
if k % n == 0:
	sum += int(k / n)
else:
	sum += int(k / n) + 1
print(int(sum))


(n, S) = map(int, input().split())
c = 0
while S != 0:
	c += S // n
	S = S % n
	n -= 1
print(c)


import math
stringa = input()
spazio = stringa.find(' ')
n = int(stringa[0:spazio])
S = int(stringa[spazio + 1:])
print(math.ceil(S / n))


(n, s) = map(int, input().split())
for i in range(1, n + 1):
	if s % n != 0:
		print(s // n + 1)
		break
	else:
		print(s // n)
		break


import math
(n, s) = input().strip().split(' ')
n = int(n)
s = int(s)
print(math.ceil(s / n))


(n, m) = map(int, input().split())
count = 0
if m % n == 0:
	count = m // n
else:
	count = m // n + 1
print(count)


(n, s) = input().split()
n = int(n)
s = int(s)
c = s // n
if s % n != 0:
	print(c + 1)
else:
	print(c)


def solve():
	(N, S) = map(int, input().split())
	res = 0
	i = min(N, S)
	while i > 0 and S > 0:
		res += S // i
		S %= i
		i = S
	print(res)
solve()


(n, s) = map(int, input().split())
if s <= n:
	print(1)
else:
	sum = s // n
	if s % n > 0:
		sum += 1
	print(sum)


(n, s) = map(int, input().split())
print(s // n + (s % n > 0))


(n, m) = map(int, input().split())
ans = m // n + min(1, m % n)
print(ans)


(n, s) = map(int, input().split())
if s <= n:
	print(1)
else:
	print((s + n - 1) // n)


s = input()
l = s.split()
n = int(l[0])
S = int(l[1])
c = S // n
x = c * n
if x < S:
	c += 1
print(c)


(maximal_value, s) = map(int, input().split())
units = 0
current_s = s
while current_s > 0:
	max_unit = min(current_s, maximal_value)
	um = current_s // max_unit
	units += um
	current_s %= max_unit
print(units)


(n, s) = [int(s) for s in input().split()]
if s % n == 0:
	print(s // n)
else:
	print(s // n + 1)


def int_lst_input():
	return [int(val) for val in input().split(' ')]

def int_input():
	return int(input())

def print_lst(lst):
	print(' '.join([str(val) for val in lst]))

def solve():
	(n, S) = int_lst_input()
	coins = 0
	for i in range(n, -1, -1):
		if S == 0:
			break
		if S // i > 0:
			coins += S // i
			S %= i
	print(coins)
solve()


def answer():
	b = input().split()
	a = int(b[0])
	c = int(b[1])
	return int(c / a) + (not c % a == 0)
print(answer())


(n, s) = map(int, input().split(' '))
c = 0
i = n
a = s
while i > 0:
	if a // i > 0:
		c = c + a // i
		a = a % i
	i = i - 1
print(c)


a = input()
n = int(a.split()[0])
s = int(a.split()[1])
if s >= n:
	if s % n == 0:
		print(s // n)
	else:
		print(1 + s // n)
else:
	print('1')


import sys
input = sys.stdin.readline
(n, s) = map(int, input().split())
print(s // n + int(bool(s % n)))


(a, b) = map(int, input().split())
if b < a:
	print(1)
elif int(b / a) == b / a:
	print(int(b / a))
else:
	print(int(b / a) + 1)


from sys import stdin
import math
(n, S) = map(int, stdin.readline().rstrip().split(' '))
print(math.ceil(S / n))


ns = list(map(int, input().split()))
n = ns[0]
s = ns[1]
if s % n == 0:
	c = int(s / n)
else:
	c = int(s // n + 1)
print(c)


import sys
line = sys.stdin.readline()
line = line.strip()
(a, b) = line.split()
n = int(a)
num = int(b)
nc = num // n if num % n == 0 else num // n + 1
print(nc)


arr = [int(i) for i in input().split()]
out = arr[1] / arr[0]
if out % 1 == 0:
	print(int(out))
else:
	print(int(out) + 1)


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


def monety(n, s):
	return (n + s - 1) // n
(N, S) = [int(i) for i in input().split()]
print(monety(N, S))


import sys

def main():
	data = sys.stdin.readlines()
	words = data[0].split()
	n = int(words[0])
	s = int(words[1])
	ans = s // n
	s -= n * ans
	if s > 0:
		ans += 1
	print(ans)
main()


import math
(n, s) = [int(i) for i in input().split(' ')]
print(math.ceil(s / n))


(n, s) = map(int, input().split())
print((s + n - 1) // n)


(n, s) = map(int, input().split())
sch = n
if s > 1 and s % n != 0:
	res = s // n + 1
elif s > 1 and s % n == 0:
	res = s // n
else:
	res = 1
print(res)


(n, s) = map(int, input().split())
if s <= n:
	print(1)
else:
	c = 0
	k = s // n
	k1 = s / n
	if k == k1:
		print(k)
	else:
		print(k + 1)


n_A = input()
n_A = n_A.split(' ')
n = int(n_A[0])
s = int(n_A[1])
n_1 = s // n
n_2 = 0
if s % n == 0:
	n_2 = 0
else:
	n_2 = 1
ans = n_1 + n_2
print(ans)


(a, b) = map(int, input().split())
c = b // a
if c * a < b:
	c += 1
	print(c)
else:
	print(c)


def f(nn, ss):
	if ss == 0:
		return int(0)
	if nn == 0:
		return int(0)
	ab = 1
	for i in reversed(range(1, nn + 1)):
		if ss >= i:
			ab = i
			break
	return int(ss / ab + int(f(ab, ss % ab)))
(n, s) = input().split()
li = []
li.append(0)
for i in range(1, int(n) + 1):
	li.append(i)
print(f(int(n), int(s)))


(n, s) = map(int, input().split())
ans = 0
while s > 0:
	a = s // n
	s -= n * a
	ans += a
	n -= 1
print(ans)


(n, k) = input().split()
n = int(n)
k = int(k)
gesamt = 0
for i in range(n, 0, -1):
	if k < i:
		continue
	else:
		rest = k % i
		x_rest = (k - rest) / i
		gesamt = gesamt + x_rest
		k = rest
print(int(gesamt))


(a, b) = map(int, input().split())
if b % a == 0 and b >= a:
	print(b // a)
elif b <= a:
	print(1)
else:
	print((b - b % a) // a + 1)


def Num_of_Coins():
	(num, Sum) = [int(x) for x in input('').split()]
	if Sum % num == 0:
		return int(Sum / num)
	else:
		return int(Sum / num) + 1
print(Num_of_Coins())


(n, s) = input().split(' ')
n = int(n)
s = int(s)
if s <= n:
	print('%d' % 1)
elif s % n == 0:
	print('%d' % (s / n))
else:
	print('%d' % (s / n + 1))


(n, k) = [*map(int, input().split())]
ans = int(k / n)
if k % n != 0:
	ans += 1
print(ans)


def r(n):
	if n % 1 == 0:
		return int(n)
	return int(n) + 1

def main():
	(a, b) = map(int, input().split())
	print(r(b / a))
main()


(n, s) = map(int, input().split())
cnt = 0
for i in range(n, 0, -1):
	cnt += s // i
	s %= i
print(cnt)


import math
(n, S) = map(int, input().strip().split())
print(math.ceil(S / n))


l = list(map(int, input().split()))

def coins_count(n, s):
	l = list(range(1, n + 1))
	if s in l:
		return 1
	i = n
	if s % i == 0:
		return s // i
	elif s % i in l:
		return s // i + 1
	else:
		i -= 1
		while i > 0:
			if s % i == 0:
				return s // i
			elif s % i in l:
				return s // i + 1
			else:
				i -= 1
print(coins_count(l[0], l[1]))


(n, s) = map(int, input().strip().split())
x = s // n
if s % n == 0:
	print(x)
else:
	print(x + 1)


import sys
from math import ceil
input_file = sys.stdin
[n, s] = list((int(x) for x in input_file.readline().split()))
print(ceil(s / n))


(s, n) = [int(a) for a in input().split(' ')]
o = n // s
if o * s < n:
	o += 1
print(o)


(a, b) = map(int, input().split())
print(b // a + (b % a != 0))


from math import ceil as g
(a, k) = map(int, input().split())
print(g(k / a) if k > a else 1)


def main():
	(n, s) = map(int, input().split())
	result = 0
	while n > 0 and s > 0:
		result += s // n
		s -= n * (s // n)
		n -= 1
	print(result)
main()


(n, s) = list(map(int, input().split()))
num_1 = s // n
if s % n == 0:
	print(num_1)
else:
	print(num_1 + 1)


string = input()
l = string.split()
n = int(l[0])
S = int(l[1])
count = S // n
x = count * n
if x < S:
	x += n
	count += 1
print(count)


(a, b) = map(int, input().split())
k = int(b / a)
if b % a != 0:
	k += 1
print(k)


import math, string, itertools, fractions, heapq, collections, re, array, bisect, sys, random, time, queue, copy
sys.setrecursionlimit(10 ** 7)
inf = 10 ** 20
mod = 10 ** 9 + 7
dd = [(-1, 0), (0, 1), (1, 0), (0, -1)]
ddn = [(-1, 0), (-1, 1), (0, 1), (1, 1), (1, 0), (1, -1), (0, -1), (-1, -1)]

def LI():
	return [int(x) for x in sys.stdin.readline().split()]

def LI_():
	return [int(x) - 1 for x in sys.stdin.readline().split()]

def I():
	return int(sys.stdin.readline())

def LS():
	return sys.stdin.readline().split()

def S():
	return input()

def main():
	(n, k) = LI()
	return -(-k // n)
print(main())


(n, s) = map(int, input().split())
if s % n == 0:
	s -= 1
print(s // n + 1)


(n, S) = map(int, input().split())
if n >= S:
	print(1)
elif S % n == 0:
	print(S // n)
else:
	print(S // n + 1)


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


from math import ceil
(n, s) = [int(x) for x in input().split()]
ans = ceil(s / n)
print(ans)


(n, S) = [int(s) for s in input().split()]
mass = []
num_of_coins = 0
if S % n == 0:
	num_of_coins = S // n
else:
	num_of_coins = S // n + 1
print(num_of_coins)


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


(n, s) = (int(x) for x in input().split())
ans = s // n
if s % n != 0:
	ans += 1
print(ans)


(n, s) = list(map(int, input().split()))
coins = {}
for i in range(n, 0, -1):
	coins[i] = 1
su = 0
count = 0
if n < s:
	temp = s // n
	count += temp
	su += temp * n
	if su != s:
		count += 1
else:
	count = 1
print(count)


(n, s) = map(int, input().split())
d = s // n
d += 1 if s % n else 0
print(d)


import sys
input = sys.stdin.buffer.readline
(n, s) = map(int, input().split())
if s % n == 0:
	print(s // n)
else:
	print(s // n + 1)


import math
(n, m) = map(int, input().split())
print(math.ceil(m / n))


(n, s) = map(int, input().split())
k = 0
cnt = 0
if s > n:
	while k < s:
		for i in range(n, 0, -1):
			k += i
			cnt += 1
			break
	print(cnt)
else:
	print(1)


(n, S) = map(int, input().split())
print(-(-S // n))


(n, s) = map(int, input().split())
if s % n == 0:
	print(s // n)
elif s <= n:
	print('1')
else:
	print(s // n + 1)


(n, s) = map(int, input().split())
count = 1
tmp = int(n)
while s > tmp:
	count += 1
	tmp += n
print(count)


from math import ceil
(n, m) = map(int, input().split())
div = m / n
print(ceil(div))


ns = input().split()
n = int(ns[0])
s = int(ns[1])
if s / n != int(s / n):
	print(s // n + 1)
else:
	print(s // n)


(n, s) = map(int, input().split())
count = 0
for coin in reversed(range(1, n + 1)):
	count += s // coin
	s %= coin
print(count)


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


(n, s) = map(int, input().split())
l = [s // n, s // n + 1]
print(l[s % n != 0])


import math
inputLine = [int(c) for c in input().split()]
n = inputLine[0]
S = inputLine[1]
result = 0
while n > 0 and S > 0:
	count = math.ceil(S / n)
	result += count
	S = S - n * count
	n = n - 1
print(result)


(n, m) = map(int, input().split())
k = m // n
ans = k + int(m - k * n > 0)
print(ans)


(n, k) = [int(i) for i in input().split()]
if k % n == 0:
	print(k // n)
else:
	print(k // n + 1)


import math

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


(n, k) = map(int, input().split())
print(k // n + (k % n > 0))


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


(n, s) = input().split()
n = int(n)
s = int(s)
c = 0
while s != 0:
	if n <= s:
		c = c + s // n
		s = s - s // n * n
	n = n - 1
print(c)


import math
(x, y) = [int(x) for x in input().split()]
print(math.ceil(y / x))


l = list(input().split())
n = int(l[0])
s = int(l[1])
if s % n != 0:
	print(s // n + 1)
else:
	print(s // n)


(x, y) = [int(i) for i in input().split()]
k = (x + y - 1) // x
print(k)


(n, s) = map(int, input().split())
(r, y) = (s, 0)
c = 0
while y != 1:
	if 1 <= r <= n:
		c += 1
		y = 1
	else:
		r = s % n
		c += s // n
		if r == 0:
			y = 1
print(c)


(n, s) = list(map(int, input().split()))
ans = 0
for i in range(n, 0, -1):
	ans += s // i
	s %= i
print(ans)


s = input()
s = s.split(' ')
n = int(s[0])
S = int(s[1])
min = 0
if S <= n:
	min = 1
else:
	min = S // n
	resto = S % n
	if resto > 0:
		min += 1
print(min)


a = [int(x) for x in input().split()]
n = a[0]
S = a[1]
if S % n == 0:
	print(S // n)
else:
	print(S // n + 1)


(n, s) = map(int, input().split())
c = 0
while s != 0:
	c += s // n
	s %= n
	n -= 1
print(c)


from math import inf as inf
from math import *
from collections import *
import sys
input = sys.stdin.readline
t = 1
while t:
	t -= 1
	(n, a) = map(int, input().split())
	print(ceil(a / n))


(n, s) = map(int, input().split())

def mincoin(n, s):
	c = 0
	while s:
		while not s >= n:
			n -= 1
		c += s // n
		s %= n
	return c
print(mincoin(n, s))


li = [int(x) for x in input().split()]
total = li[1]
n = li[0]
if total <= n:
	print(1)
elif total > n:
	count = 0
	count += total // n
	if total % n == 0:
		print(count)
	else:
		print(count + 1)


(n, S) = map(int, input().split())
result = 0
while S:
	result += S // n
	S = S % n
	n = n - 1
print(result)


from random import randint
(n, s) = map(int, input().split())
ans = (s + n - 1) // n
print(ans)


(number, value) = map(int, input().split())
ans = value // number
ans += 1 if value % number > 0 else 0
print(ans)


(n, s) = list(map(int, input().split()))
su = s // n
s = s - su * n
if s != 0:
	su += 1
print(su)


from collections import *
from math import *
I = lambda : map(int, input().split())
(n, s) = I()
if s % n == 0:
	print(s // n)
else:
	print(s // n + 1)


(a, b) = input().split()
a = int(a)
b = int(b)
c = b
d = 0
while c is not 0:
	k = c // a
	d += k
	c = c - k * a
	a -= 1
print(d)


from math import ceil
(n, s) = map(int, input().split())
if s <= n:
	print(1)
else:
	print(ceil(s / n))


(n, S) = [int(i) for i in input().split()]
res = 0
s = 0
while s != S:
	if (S - s) % n == 0:
		res += (S - s) // n
		break
	else:
		res += (S - s) // n
		s += (S - s) // n * n
		n -= 1
print(res)


from math import ceil
(n, s) = map(int, input().split())
print(ceil(s / n))


from sys import stdin, stdout
import bisect
import math

def st():
	return list(stdin.readline().strip())

def inp():
	return int(stdin.readline())

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

def mp():
	return map(int, stdin.readline().split())

def pr(n):
	stdout.write(str(n) + '\n')

def soe(limit):
	l = [1] * (limit + 1)
	prime = []
	for i in range(2, limit + 1):
		if l[i]:
			for j in range(i * i, limit + 1, i):
				l[j] = 0
	for i in range(2, limit + 1):
		if l[i]:
			prime.append(i)
	return prime

def segsoe(low, high):
	limit = int(high ** 0.5) + 1
	prime = soe(limit)
	n = high - low + 1
	l = [0] * (n + 1)
	for i in range(len(prime)):
		lowlimit = low // prime[i] * prime[i]
		if lowlimit < low:
			lowlimit += prime[i]
		if lowlimit == prime[i]:
			lowlimit += prime[i]
		for j in range(lowlimit, high + 1, prime[i]):
			l[j - low] = 1
	for i in range(low, high + 1):
		if not l[i - low]:
			if i != 1:
				print(i)

def gcd(a, b):
	while b:
		a = a % b
		(b, a) = (a, b)
	return a

def power(a, n):
	r = 1
	while n:
		if n & 1:
			r = r * a
		a *= a
		n = n >> 1
	return r

def solve():
	(n, k) = mp()
	if k <= n:
		print(1)
	else:
		c = 0
		x = n
		while k != 0:
			if k >= x:
				k -= x
				c += 1
			else:
				x -= 1
		print(c)
for _ in range(1):
	solve()


import sys
import math
import re
import string

def swap(a, l, r):
	temp = a[l]
	a[l] = a[r]
	a[r] = temp

def f():
	(n, s) = [int(x) for x in input().split(' ')]
	res = s // n if s % n == 0 else s // n + 1
	return res

def main():
	t = 1
	for i in range(t):
		print(f())
main()


(n, S) = map(int, input().split())
coin = min(n, S)
rem = S % coin
if rem == 0:
	print(S // coin)
else:
	print(S // coin + 1)


(a, b) = map(int, input().split())
w = int(b / a)
k = b % a
if k != 0:
	w = w + 1
	print(w)
else:
	print(w)


ns = [int(x) for x in input().split()]
n = ns[0]
s = ns[1]
c = s // n
if s % n != 0:
	c += 1
print(c)


(a, b) = map(int, input().split())
c = 0
while b > 0:
	if b != b % a:
		c += b // a
		b = b % a
	a -= 1
print(c)


import sys
line = sys.stdin.readline()
(n, S) = [int(x) for x in line.split(' ')]
print(S // n + (1 if S % n != 0 else 0))


(n, x) = map(int, input().split())
k = x // n
if x % n > 0:
	k += 1
print(k)


(n, s) = [int(x) for x in input().split(' ')]
if s % n == 0:
	print(s // n)
else:
	print(s // n + s % n // (s % n))


(n, S) = list(map(int, input().split()))
res = -(-S // n)
print(res)


(n, s) = map(int, input().split())
ans = 0
i = n
while i > 0:
	ans += s // i
	s %= i
	i -= 1
print(int(ans))


import math
import time
from collections import defaultdict, deque
from sys import stdin, stdout
from bisect import bisect_left, bisect_right

def find(n, s):
	if s <= n:
		return 1
	else:
		return find(n, s - n) + 1
(n, s) = map(int, stdin.readline().split())
print(math.ceil(s / n))


from math import ceil
s = input().split(' ')
n = int(s[0])
v = int(s[1])
print(ceil(v / n))


class CodeforcesTask1061ASolution:

	def __init__(self):
		self.result = ''
		self.n_s = []

	def read_input(self):
		self.n_s = [int(x) for x in input().split(' ')]

	def process_task(self):
		r = 0
		while self.n_s[1] > self.n_s[0]:
			r += 1
			self.n_s[1] -= self.n_s[0]
		r += 1
		self.result = str(r)

	def get_result(self):
		return self.result
Solution = CodeforcesTask1061ASolution()
Solution.read_input()
Solution.process_task()
print(Solution.get_result())


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


(n, S) = list(map(int, input().split()))
print((S + n - 1) // n)


def coins():
	(n, s) = map(int, input().split())
	su = s // n
	if s % n > 0:
		su = su + 1
	print(su)
coins()


(n, s) = input().split()
n = int(n)
s = int(s)
r = s // n
if s % n > 0:
	r += 1
print(r)


(max, sum) = input('').split()
c = int(sum) // int(max)
if int(sum) % int(max):
	print(c + 1)
else:
	print(c)


ab = input().split()
a = int(ab[0])
b = int(ab[1])
c = b // a
d = c
if b % a != 0:
	d = c + 1
print(d)


import collections, atexit, math, sys, bisect
sys.setrecursionlimit(1000000)

def getIntList():
	return list(map(int, input().split()))
try:
	import numpy

	def dprint(*args, **kwargs):
		print(*args, file=sys.stderr)
	dprint('debug mode')
except Exception:

	def dprint(*args, **kwargs):
		pass
inId = 0
outId = 0
if inId > 0:
	dprint('use input', inId)
	sys.stdin = open('input' + str(inId) + '.txt', 'r')
if outId > 0:
	dprint('use output', outId)
	sys.stdout = open('stdout' + str(outId) + '.txt', 'w')
	atexit.register(lambda : sys.stdout.close())
(N, S) = getIntList()
r = (S - 1) // N + 1
print(r)


(n, s) = map(int, input().split())
rem = s // n
if s % n == 0:
	print(rem)
else:
	print(rem + 1)


(n, s) = map(int, input().split())
if s % n == 0:
	kol = s // n
else:
	kol = s // n + 1
print(kol)


(n, s) = input().split(' ')
n = int(n)
s = int(s)
su = 0
count = 0
if n > s:
	print(1)
if n < s:
	while su < s:
		su += n
		count += 1
	print(count)


(n, k) = map(int, input().split())
s = 0
for i in range(n, 0, -1):
	if k >= 0:
		s = s + int(k / i)
		k = k % i
print(s)


(a, b) = map(int, input().split())
c = b
r = c
k = 0
i = a
while c != 0 and i != 0:
	if i > c:
		i -= 1
	else:
		k = k + c // i
		c %= i
		i -= 1
print(k)


import sys
from math import floor, ceil
input = sys.stdin.readline
(n, s) = map(int, input().split())
ans = 0
for i in range(n, 0, -1):
	while s // i > 0:
		ans += s // i
		s -= i * (s // i)
print(ans)


def main():
	from math import ceil
	[n, s] = [int(_) for _ in input().split()]
	print(ceil(s / n))
main()


(n, s) = [int(x) for x in input().split()]
if s > n:
	t = s // n
	if s % n:
		t += 1
	print(t)
else:
	print(s)


(n, S) = map(int, input().split())
if S == n * (S // n):
	print(S // n)
else:
	print(S // n + 1)


def coins(n):
	if n[1] % n[0] == 0:
		return n[1] // n[0]
	return n[1] // n[0] + 1
nn = list(map(int, input().split()))
print(coins(nn))


def run():
	(n, s) = map(int, input().split())
	print(s // n + (1 if s % n != 0 else 0))
run()


(n, m) = map(int, input().strip().split()[:2])
if n >= m:
	print(1)
else:
	k = m // n
	if m % n == 0:
		print(k)
	else:
		print(k + 1)


from sys import stdin, stdout
(n, s) = map(int, stdin.readline().split())
ans = 0
if s <= n:
	ans = 1
else:
	ans = s // n
	ans += 1 if s % n != 0 else 0
stdout.write('{}'.format(ans))


from math import ceil
[n, S] = [int(i) for i in input().split()]
if S <= n:
	print(1)
else:
	print(ceil(S / n))


(n, S) = map(int, input().strip().split())
print(S // n if S % n == 0 else S // n + 1)


from sys import stdin

def main():
	(N, S) = map(int, input().split())
	(div_, mod_) = divmod(S, N)
	if not mod_:
		ans = div_
	else:
		ans = div_ + 1
	print(ans)
input = lambda : stdin.readline()
main()


a = input().split()
x = int(a[0])
y = int(a[1])
k = int(y / x)
if y % x == 0:
	print(k)
else:
	print(k + 1)


(n, S) = map(int, input().split())
ans = S // n
if S % n != 0:
	ans += 1
print(ans)


import math
(n, S) = map(int, input().split())
ans = math.ceil(S / n)
print(ans)


(n, s) = map(int, input().split())
k = 0
d = s // n
r = s % n
if r != 0:
	d += 1
print(d)


(N, S) = map(int, input().split())
ans = 0
if S >= N:
	while S > 0:
		ans += S // N
		S = S % N
		N = N - 1
else:
	ans = 1
print(ans)


from math import ceil
q = lambda : map(int, input().split())
(n, m) = q()
print(ceil(m / n))


(x, y) = [int(i) for i in input().split()]
if y % x == 0:
	print(y // x)
else:
	print(y // x + 1)


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


(n, s) = map(int, input().split())
cnt = 0
for c in range(n, 0, -1):
	if not s:
		break
	tmp = s // c
	cnt += tmp
	s -= c * tmp
print(cnt)


import math as ma
import sys
from sys import exit
from decimal import Decimal as dec
from itertools import permutations

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

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

def nu():
	return int(input())
(n, s) = num()
cc = 0
for i in range(n, 0, -1):
	cc += s // i
	s = s % i
print(cc)


import math
(x, s) = list(map(int, input().strip().split()))
print(math.ceil(s / x))


s = [int(n) for n in input().split()]
m = 0
u = s[1]
k = 0
z = [int(n) for n in range(1, s[0] + 1)]
z = z[::-1]
for n in z:
	k = int(u / n)
	if k != 0:
		m += k
	u = int(u % n)
print(m)


import math as m
(n, s) = map(int, input().split())
print((s + n - 1) // n)


n = list(map(int, input().split()))
if n[1] % n[0] == 0:
	print(n[1] // n[0])
else:
	print(n[1] // n[0] + 1)


from sys import stdin, stdout
(n, r) = map(int, stdin.readline().strip().split())
if n >= r:
	print(1)
else:
	total = r // n
	if r % n == 0:
		print(total)
	else:
		print(total + 1)


(n, S) = map(int, input().split())
result = 0
while S > 0:
	if n == 1:
		result += S
		break
	if n > S:
		result += 1
		break
	temp = S // n
	result += temp
	S -= temp * n
	n -= 1
print(result)


import math
s = input().split()
n = int(s[0])
m = int(s[1])
print(math.ceil(m / n))


n = str(input()).split(' ')
if int(n[1]) / int(n[0]) == int(n[1]) // int(n[0]):
	print(int(int(n[1]) / int(n[0])))
else:
	print(int(int(n[1]) // int(n[0])) + 1)


(n, s) = map(int, input().split())
coins = 0
while s >= n:
	s -= n
	coins += 1
if s % n != 0:
	print(coins + 1)
else:
	print(coins)


a = list(map(int, input().split()))
l = 0
for i in range(a[0], 0, -1):
	if a[1] // i >= 1:
		l += a[1] // i
		a[1] = a[1] % i
	if a[1] <= 0:
		break
print(l)


(n, s) = map(int, input().split())
l = [i for i in range(1, n + 1)]
l.reverse()
count = 0
for i in l:
	if s >= i:
		z = s // i
		count += z
		s = s % i
		if s == 0:
			print(count)
			quit()


def ii():
	return int(input())

def si():
	return input()

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

def li():
	return list(mi())
abc = 'abcdefghijklmnopqrstuvwxyz'
(n, m) = mi()
c = m // n
m = m % n
if m == 0:
	print(c)
else:
	print(c + 1)


import sys
import math
import os
import itertools
import string
import heapq
import _collections
from collections import Counter
from collections import defaultdict
from functools import lru_cache
import bisect
import re
import queue
from decimal import *

class Scanner:

	@staticmethod
	def int():
		return int(sys.stdin.readline().rstrip())

	@staticmethod
	def string():
		return sys.stdin.readline().rstrip()

	@staticmethod
	def map_int():
		return [int(x) for x in Scanner.string().split()]

	@staticmethod
	def string_list(n):
		return [Scanner.string() for i in range(n)]

	@staticmethod
	def int_list_list(n):
		return [Scanner.map_int() for i in range(n)]

	@staticmethod
	def int_cols_list(n):
		return [Scanner.int() for i in range(n)]

class Math:

	@staticmethod
	def gcd(a, b):
		if b == 0:
			return a
		return Math.gcd(b, a % b)

	@staticmethod
	def lcm(a, b):
		return a * b // Math.gcd(a, b)

	@staticmethod
	def divisor(n):
		res = []
		i = 1
		for i in range(1, int(n ** 0.5) + 1):
			if n % i == 0:
				res.append(i)
				if i != n // i:
					res.append(n // i)
		return res

	@staticmethod
	def round_up(a, b):
		return -(-a // b)

	@staticmethod
	def is_prime(n):
		if n < 2:
			return False
		if n == 2:
			return True
		if n % 2 == 0:
			return False
		d = int(n ** 0.5) + 1
		for i in range(3, d + 1, 2):
			if n % i == 0:
				return False
		return True

def pop_count(x):
	x = x - (x >> 1 & 6148914691236517205)
	x = (x & 3689348814741910323) + (x >> 2 & 3689348814741910323)
	x = x + (x >> 4) & 1085102592571150095
	x = x + (x >> 8)
	x = x + (x >> 16)
	x = x + (x >> 32)
	return x & 127
MOD = int(1000000000.0) + 7
INF = int(1000000000000000.0)

def solve():
	(N, S) = Scanner.map_int()
	print(Math.round_up(S, N))

def main():
	solve()
main()


nm = list(map(int, input().split(' ')))
n = nm[1] / nm[0]
res = int(n)
print(res if res == n or n < 0 else res + 1)


import math
(n, s) = map(int, input().split())
if s % n == 0:
	print(s // n)
else:
	print(s // n + 1)


(n, S) = input().split(' ')
n = int(n)
S = int(S)
k = 0
j = 0
if n > S:
	print('1')
elif n < S:
	while k < S:
		k = k + n
		j = j + 1
	print(j)


import math as m
[a, b] = [int(x) for x in input().split()]
print(m.ceil(b / a))


import math

def ok(n, k):
	return math.ceil(k / n)
(n, k) = map(int, input().split())
print(ok(n, k))


import math
(n, s) = map(int, input().split())
j = 0
for i in range(n, 0, -1):
	j = j + int(s / i)
	s = s % i
print(j)


(n, k) = map(int, input().split())
print((k + n - 1) // n)


(n, s) = map(int, input().split(' '))
k = i = 0
while s != 0:
	k += s // n
	s -= s // n * n
	n -= 1
print(k)


(n, s) = input().split()
(n, s) = (int(n), int(s))
out = s // n
if s % n != 0:
	out += 1
print(out)


R = lambda : map(int, input().split())
(n, k) = R()
print((k + n - 1) // n)


l = [int(x) for x in input().split()]
if l[1] % l[0] == 0:
	print(l[1] // l[0])
else:
	print(l[1] // l[0] + 1)


(n, x) = map(int, input().split())
count = 0
answer = 0
answer = int(x / n)
if x % n == 0:
	print(answer)
else:
	answer += 1
	print(answer)


(a, b) = map(int, input().split())
c = int(b / a)
d = b % a
if d != 0:
	c = c + 1
print(c)


def main():
	(n, s) = map(int, input().split())
	if s <= n:
		res = 1
	else:
		res = s // n
		if s % n > 0:
			res += 1
	print(res)
main()


from operator import itemgetter
(n, s) = map(int, input().split())
print(s // n + (s % n != 0))


(n, s) = map(int, input().split())
r = s // n
if s % n == 0:
	print(r)
else:
	print(r + 1)


(n, S) = [int(x) for x in input().split()]
print((S - 1) // n + 1)


import math, string, itertools, fractions, heapq, collections, re, array, bisect, sys, random, time, copy, functools
sys.setrecursionlimit(10 ** 7)
inf = 10 ** 20
eps = 1.0 / 10 ** 10
mod = 10 ** 9 + 7
dd = [(-1, 0), (0, 1), (1, 0), (0, -1)]
ddn = [(-1, 0), (-1, 1), (0, 1), (1, 1), (1, 0), (1, -1), (0, -1), (-1, -1)]

def LI():
	return [int(x) for x in sys.stdin.readline().split()]

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()

def pf(s):
	return print(s, flush=True)

def main():
	(n, m) = LI()
	return (n + m - 1) // n
print(main())


(n, s) = map(int, input().split())
x = s // n
if x * n < s:
	x += 1
print(x)


import sys
input = sys.stdin.readline

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

def coins(n, s):
	counter = 0
	while s > 0:
		if s - n < 0:
			n = n - 1
		else:
			s = s - n
			counter = counter + 1
	return counter
inputs = inlt()
print(coins(inputs[0], inputs[1]))


import math
(n, S) = map(int, input().split())
t = math.ceil(S / n)
print(t)


a = []
b = 0
(n, s) = map(int, input().split())
for x in range(n, 0, -1):
	b += s // x
	s = s % x
print(b)


s = input()
s = s.split()
for j in range(len(s)):
	s[j] = int(s[j])
d = s[1] // s[0]
if s[1] % s[0] == 0:
	print(d)
else:
	print(d + 1)


(n, s) = map(int, input().strip().split(' '))
coins = s // n
if coins * n < s:
	coins += 1
print(coins)


s = input().rstrip().split(' ')
a = int(s[0])
b = int(s[1])
if b <= a:
	print(1)
elif b % a == 0:
	print(b // a)
else:
	O = 0
	while 1:
		t = b // a
		v = b % a
		O += t
		b = v
		if t + v <= a:
			O += 1
			break
	print(O)


(n, s) = map(int, input().split(' '))
if n >= s:
	print(1)
elif not s % n:
	print(s // n)
else:
	print(s // n + 1)


(n, S) = map(int, input().split())

def coins(n, S):
	if n >= S:
		k = 1
	else:
		k = 0
		while S != 0 and S > -1:
			k += S // n
			S = S - S // n * n
			n -= 1
	return k
print(coins(n, S))


(n, s) = [int(i) for i in input().split()]
print(s // n + min(s % n, 1))


(n, s) = map(int, input().split())
ans = 0
while True:
	ans = ans + s // n
	s = s % n
	n = n - 1
	if s == 0:
		break
	pass
print(ans)


(n, S) = map(int, input().split())
ans = S + 1
for i in range(n, 0, -1):
	ans = min(ans, S // i + bool(S % i))
print(ans)


(n, s) = map(int, input().split())
l = [i for i in range(1, n + 1)]
res = s // n
k = s % n
if k != 0:
	print(res + 1)
else:
	print(res)


(a, b) = input().split()
a = int(a)
b = int(b)
c = b // a
if b % a != 0:
	c += 1
print(c)


(n, S) = map(int, input().split())
c = 0
if S % n == 0:
	c = S / n
else:
	c = S / n + 1
print(int(c))


x = list(map(int, input().split()))
if x[1] % x[0] == 0:
	c = x[1] // x[0]
else:
	c = x[1] // x[0] + 1
print(c)


o = input().rstrip().split(' ')
n = int(o[0])
s = int(o[1])
if n >= s:
	print(1)
else:
	S = 0
	T = s // n
	S += T
	A = s - T * n
	if A == 0:
		print(S)
	else:
		print(S + 1)


import math
a = [int(x) for x in input().split()]
num = a[0]
summ = a[1]
print(math.ceil(summ / num))


import os
import sys
from io import BytesIO, IOBase
import math
from decimal import Decimal
from decimal import *
from collections import defaultdict, deque
import heapq
from decimal import Decimal
getcontext().prec = 25
abcd = 'abcdefghijklmnopqrstuvwxyz'
MOD = 1000000007
BUFSIZE = 8192
from bisect import bisect_left, bisect_right

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')
(n, k) = map(int, input().split(' '))
print(math.ceil(k / n))


t = input().split(' ')
(n, s) = (int(t[0]), int(t[1]))
r = int(s / n)
print(r + 1) if r * n != s else print(r)


x = input()
y = x.split()
if int(y[1]) > int(y[0]):
	a = int(y[1]) // int(y[0])
	if int(y[1]) % int(y[0]) != 0:
		q = a + 1
	else:
		q = a
else:
	q = 1
print(q)


_L = list(map(int, input().split()))
_COUNTER = 0
while True:
	if _L[0] <= _L[1]:
		_COUNTER += _L[1] // _L[0]
		_L[1] %= _L[0]
	_L[0] -= 1
	if _L[0] == 0:
		print(_COUNTER)
		break


inp = input()
li = inp.split()
n = int(li[0])
s = int(li[1])
r = 0
while n > 0:
	c = int(s / n)
	r += c
	s -= c * n
	if s == 0:
		break
	n -= 1
print(r)


(*a,) = map(int, input().split())
(n, s) = (a[0], a[1])
print(int(s / n) + (int(s % n) != 0))


import os
import sys
import math
import collections
import cmath

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

def inp():
	return input()
(a, b) = mp()
if b % a == 0:
	print(b // a)
else:
	print(b // a + 1)


params = input().split()
maxCoin = int(params[0])
totalValue = int(params[1])
counter = 0
while totalValue > 0 and maxCoin > 0:
	while totalValue - maxCoin >= 0:
		f = int(totalValue / maxCoin)
		totalValue = totalValue - maxCoin * f
		counter = counter + f
	maxCoin = maxCoin - 1
print(counter)


input_num = input('')
input_list = input_num.split(' ', 2)
coins_num = int(input_list[0])
amount_num = int(input_list[1])
result_list = 0
while True:
	if amount_num != 0:
		if amount_num >= coins_num:
			coins_count = int(amount_num / coins_num)
			if coins_count != 0:
				result_list += coins_count
				amount_num = amount_num - coins_count * coins_num
		coins_num -= 1
	else:
		break
print(result_list)


import math
ns = input().split(' ')
n = int(ns[0])
s = int(ns[1])
if s <= n:
	print(1)
else:
	print(math.ceil(s / n))


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


def ans(arr):
	(n, s) = (arr[0], arr[1])
	if s > n:
		if s % n:
			return s // n + 1
		else:
			return s // n
	elif s <= n:
		return 1
n = list(map(int, input().strip().split()))
print(ans(n))


import sys

def minimal_coin_count(n, S, already_used):
	already_used += S // n
	S %= n
	if S == 0:
		return already_used
	else:
		return already_used + 1
(n, S) = map(int, sys.stdin.readline().split())
print(minimal_coin_count(n, S, 0))


gi = lambda : list(map(int, input().split()))
(n, s) = gi()
ans = s // n
if s % n:
	ans += 1
print(ans)


from math import ceil
(n, m) = input().split()
(n, m) = (int(n), int(m))
counter = ceil(m / n)
print(counter)


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

def coins(n, s):
	if s % n == 0:
		return s // n
	else:
		return s // n + 1
inputs = inlt()
print(coins(inputs[0], inputs[1]))


(noOfCoins, total_value) = map(int, input().split(' '))
min_required_coins = total_value // noOfCoins
if total_value % noOfCoins == 0:
	print(min_required_coins)
else:
	print(min_required_coins + 1)


(n, s) = map(int, input().split())
co = 0
su = 0
co = s / n
if co == int(co):
	print(int(co))
else:
	print(int(co + 1))


lis = input().split()
n = int(lis[0])
s = int(lis[1])
ans = s // n + (s % n != 0)
print(ans)


(n, s) = tuple(map(int, input().strip().split()))
coins = [0] + [i for i in range(1, n + 1)]
count = 0
while s > 0:
	if s > coins[n]:
		s -= coins[n]
	else:
		s -= coins[s]
	count += 1
print(count)


(a, b) = list(map(int, input().split()))
t = 0
if b >= a:
	t = b // a
	c = b % a
	if c > 0:
		t += 1
	else:
		pass
else:
	t = 1
print(t)


(n, s) = input().split()
(n, s) = (int(n), int(s))
p = 0
for i in range(n, 0, -1):
	if s >= i and s != 0:
		p += s // i
		s = s % i
print(p)


def coins():
	coins = input().split()
	coins = [int(i) for i in coins]
	if coins[0] == 1:
		print(coins[1])
		return
	if coins[1] % coins[0] == 0:
		print(int(coins[1] / coins[0]))
		return
	else:
		print(int(coins[1] / coins[0]) + 1)
		return
coins()


import math
config = input()
config_splitted = config.split(' ')
max_value_coins = int(config_splitted[0])
total_value = int(config_splitted[1])
cnt = 0
i = max_value_coins
k = 0
while i > 0:
	k = total_value / i
	cnt = cnt + k
	total_value = total_value - k * i
	i = i - 1
print(math.ceil(cnt))


(c, s) = map(int, input().split())
count = 0
if c <= s:
	count += int(s / c)
	s -= c * count
while s > 0 and c > 1:
	c -= 1
	if c <= s:
		count += int(s / c)
		s -= c * count
print(count)


import math
(coins, number) = input().split(' ')
coins = int(coins)
number = int(number)
result = math.ceil(number / coins)
print(result)


(n, s) = list(map(int, input().split()))
n1 = (n + s - 1) // n
print(n1)


(n, s) = map(int, input().split())
final = s - n * (s // n)
if final > 0:
	print(s // n + 1)
else:
	print(s // n)


import math as mt
(n, s) = map(int, input().split())
print(mt.ceil(s / n))


(N, S) = input().split()
n = int(N)
s = int(S)
if s % n == 0:
	print(s // n)
else:
	print(s // n + 1)


a = list(map(int, input().split()))
print(a[1] // a[0] if a[1] % a[0] == 0 else a[1] // a[0] + 1)


from math import ceil
(n, k) = map(int, input().split())
print(ceil(k / n))


from fractions import gcd
import math
from itertools import permutations
from itertools import combinations
import calendar
from itertools import product

def readInts():
	return list(map(int, raw_input().strip().split()))

def readInt():
	return int(raw_input())

def readStrs():
	return raw_input().split()

def readStr():
	return raw_input()

def readarr(n):
	return [map(int, list(readStr())) for i in xrange(n)]

def readnumbertolist():
	a = [int(i) for i in list(raw_input())]
	return a

def strlistTostr(list1):
	return ''.join(list1)

def numlistTostr(list1):
	return ''.join((str(e) for e in list1))

def strTolist(str):
	return str.split()

def strlistTointlist(str):
	return map(int, str)

def slicenum(number, x):
	return int(str(number)[:x])

def precise(num):
	return '{0:.10f}'.format(num)

def rsorted(a):
	return sorted(a, reverse=True)

def binar(x):
	return '{0:031b}'.format(x)

def findpermute(word):
	perms = [''.join(p) for p in permutations(word)]
	return set(perms)

def findsubsets(S, m):
	return set(itertools.combinations(S, m))

def sort1(yy, index):
	return yy.sort(key=lambda x: x[index])

def reversepair(yy):
	return yy[::-1]

def checkint(x):
	return x.is_integer()

def sum_digits(n):
	s = 0
	while n:
		s += n % 10
		n //= 10
	return s

def vowel_count(str):
	count = 0
	vowel = set('aeiouAEIOU')
	for alphabet in str:
		if alphabet in vowel:
			count = count + 1
	return count

def leapyear(year):
	return calendar.isleap(year)

def primes_sieve(limit):
	limitn = limit + 1
	not_prime = set()
	primes = []
	for i in range(2, limitn):
		if i in not_prime:
			continue
		for f in range(i * 2, limitn, i):
			not_prime.add(f)
		primes.append(i)
	return primes

def distinctstr(s):
	t = ''.join(set(s))
	return t

def countdict(s):
	d = {}
	for i in range(len(s)):
		if s[i] not in d.keys():
			d[s[i]] = 1
		else:
			d[s[i]] += 1
	return d
import operator as op

def nck(n, k):
	k = min(n - k, k)
	result = 1
	for i in range(1, k + 1):
		result = result * (n - i + 1) / i
	return result

def matrixcheck(x, y):
	faadu = []
	directions = zip((0, 0, 1, -1), (1, -1, 0, 0))
	for (dx, dy) in directions:
		if R > x + dx >= 0 <= y + dy < C and A[x + dx][y + dy] == 0:
			faadu.append((x + dx, y + dy))
	return faadu

def stringcount(s):
	return [s.count(i) for i in 'abcdefghijklmnopqrstuvwxyz']

def bubbleSort(arr):
	n = len(arr)
	for i in range(n):
		for j in range(0, n - i - 1):
			if arr[j] > arr[j + 1]:
				(arr[j], arr[j + 1]) = (arr[j + 1], arr[j])

def isSubsetSum(st, n, sm):
	subset = [[True] * (sm + 1)] * (n + 1)
	for i in range(0, n + 1):
		subset[i][0] = True
	for i in range(1, sm + 1):
		subset[0][i] = False
	for i in range(1, n + 1):
		for j in range(1, sm + 1):
			if j < st[i - 1]:
				subset[i][j] = subset[i - 1][j]
			if j >= st[i - 1]:
				subset[i][j] = subset[i - 1][j] or subset[i - 1][j - st[i - 1]]
	return subset[n][sm]

def decimal_to_octal(dec):
	decimal = int(dec)
	return oct(decimal)

def decimal_to_binary(dec):
	decimal = int(dec)
	return bin(decimal)

def decimal_to_hexadecimal(dec):
	decimal = int(dec)
	return hex(decimal)

def solve():
	(n, s) = map(int, input().strip().split())
	ans = 0
	if s % n == 0:
		ans += s // n
	else:
		ans += s // n + 1
	print(ans)
solve()


(x, y) = map(int, input().split())
if y <= x:
	print('1')
elif y % x == 0:
	print(int(y / x))
else:
	print(int(y / x) + 1)


(n, m) = map(int, input().split())
print((m + n - 1) // n)


x = list(map(int, input().split()))
a = x[0]
b = x[1]
c = b % a
d = b // a
if c != 0:
	d = d + 1
elif c == 0:
	d = d
elif a > b:
	d = 1
print(d)


(a, b) = input().split()
(a, b) = (int(a), int(b))
k = 0
if b <= a:
	print(1)
elif b % a > 0:
	print(b // a + 1)
else:
	print(b // a)


(n, s) = map(int, input().split())
if s <= n:
	print(1)
else:
	i = n
	ans = 0
	f = 0
	while i > 0:
		s -= i
		ans += 1
		if s <= n:
			ans += 1
			f = 1
			break
	print(ans)


from sys import stdin

def myfunction(s):
	pass
(n, s) = list(map(int, stdin.readline().split()))
if s % n == 0:
	print(s // n)
else:
	print(s // n + 1)


(n, s) = input().split()
n = int(n)
s = int(s)
ctr = 0
while s > 0 and n >= 1:
	while n <= s:
		ctr += s // n
		s = s % n
	n -= 1
print(ctr)


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


import sys
(nominal, summa) = map(int, sys.stdin.readline().split(' '))

def findMinimalCoins(nominal, summa):
	coins = 0
	coins += summa // nominal + (1 if summa % nominal > 0 else 0)
	return coins
print(findMinimalCoins(nominal, summa))


(N, K) = list(map(int, input().split(' ')))
if K == 0:
	print(0)
elif N >= K:
	print(1)
else:
	S = 0
	S += K // N
	K %= N
	if K == 0:
		print(S)
	else:
		print(S + 1)


(k, n) = map(int, input().split())
ans = n // k
if n % k:
	ans += 1
else:
	pass
print(ans)


import sys
from collections import deque
import heapq
input = sys.stdin.readline
(n, s) = map(int, input().split())
if s <= n:
	print(1)
else:
	ans = s // n
	s = s % n
	if s:
		ans += 1
	print(ans)


import math
(n, S) = [int(elm) for elm in input().split(' ')]
print(math.ceil(S / n))


inp = input().split()
n = int(inp[0])
S = int(inp[1])
res = S // n + (S % n > 0)
print(res)


import math
s = input().split()
t = int(s[0])
x = int(s[1])
print(math.ceil(x / t))


(n, S) = [int(x) for x in input().split()]
from math import ceil
print(int(ceil(S / n)))


(n, s) = map(int, input().split())
q = 0
if s > n:
	if s % n > 0:
		q = 1
	q = q + s // n
else:
	q = 1
print(q)


a = input().split(' ')
g = int(a[0])
f = int(a[1])
if f % g == 0:
	print(f // g)
else:
	print(f // g + 1)


(n, m) = [int(x) for x in input().split()]
c = 0
for i in range(n, 0, -1):
	d = m // i
	if m - d * i >= 0 and d != 0:
		c += d
		m -= d * i
print(c)


(max_coin, aim) = map(int, input().split())
need_more = aim
coins_used = 0
while max_coin > 0:
	coins_used += need_more // max_coin
	need_more = need_more % max_coin
	max_coin -= 1
print(coins_used)


(n, s) = map(int, input().split())
if s % n == 0:
	m = int(s / n)
	print(m)
else:
	m = int(s / n) + 1
	print(m)


goal = [int(i) for i in input().split()]
print(int(goal[1] / goal[0]) + (goal[1] % goal[0] > 0))


(n, s) = map(int, input().split())
o = 0
if n >= s:
	o = 1
elif n == 1:
	o = s
elif n < s:
	o += s // n
	if s % n != 0:
		o += 1
print(o)


from math import *
(q, w) = map(int, input().split())
z = ceil(w / q)
print(z)


import math
(n, s) = [float(x) for x in input().split()]
print(math.ceil(s / n))


config = input()
values = config.split()
n = int(values[0])
S = int(values[1])
qtd = 0
while n > 0:
	if S >= n:
		S -= n
		qtd += 1
	else:
		n -= 1
print(qtd)


(n, S) = map(int, input().split())
i = 0
if S % n == 0:
	print(int(S / n))
else:
	print(int(S / n + 1))


import math
(n, s) = map(int, input().strip().split())
if s % n == 0:
	print(math.floor(s / n))
else:
	print(math.ceil(s / n))


def solve():
	(n, s) = map(int, input().strip().split())
	ans = 0
	if s % n == 0:
		ans += s // n
	else:
		ans += s // n + 1
	print(ans)
solve()


(m, n) = map(int, input().split())
if m > n:
	print(1)
elif n % m == 0:
	print(n // m)
else:
	print(n // m + 1)


b = list(map(int, input().split()))
k = b[1] % b[0]
if k == 0:
	print(b[1] // b[0])
else:
	print(b[1] // b[0] + 1)


def find_max(a, low, mid, high):
	leftsum = -1
	s = 0
	for i in range(mid, low, -1):
		s = s + a[i]
		if s > leftsum:
			leftsum = s
			maxleft = i
	rightsum = -1
	s = 0
	for j in range(mid + 1, high):
		s = s + a[j]
		if s > rightsum:
			rightsum = s
			maxright = j
	return (maxleft, maxright, leftsum + rightsum)

def find(a, low, high):
	if high == low:
		return (low, high, a[low])
	else:
		mid = (low + high) // 2
		(leftlow, lefthigh, leftsum) = find(a, low, mid)
		(rightlow, righthigh, rightsum) = find(a, mid, high)
		(crosslow, crosshigh, crossum) = find_max(a, low, mid, high)
		if leftsum >= rightsum and leftsum >= crossum:
			return (leftlow, lefthigh, leftsum)
		elif rightsum >= leftsum and rightsum >= crossum:
			return (rightlow, righthigh, rightsum)
		else:
			return (crosslow, crosshigh, crossum)
(n, s) = map(int, input().split(' '))
x = 0
for i in range(n, 0, -1):
	if n >= i:
		a = s // i
		s = s % i
		x += a
print(x)


import math

def coins():
	(n, s) = input().split()
	n = int(n)
	s = int(s)
	i = 0
	print(math.ceil(s / n))
coins()


def I():
	return map(int, input().split())
(n, s) = I()
print(s // n + (s % n != 0))


inline = input().split(' ')
n = int(inline[0])
S = int(inline[1])
count = 0
while S > 0:
	count += int(S / n)
	S %= n
	n -= 1
print(count)


import sys
import math
import bisect

def main():
	(a, b) = map(int, input().split())
	ans = math.ceil(b / a)
	print(ans)
main()


import math
(n, S) = list(map(int, input().split()))
print(math.ceil(S / n))


import sys
input = lambda : sys.stdin.readline().strip()
(n, s) = [int(x) for x in input().split()]
ans = 0
for i in reversed(range(1, n + 1)):
	ans += s // i
	s %= i
print(ans)


(n, s) = map(int, input().split())
k = 0
a = list(range(1, n + 1))
a.reverse()
g = []
p = []
for i in a:
	if s % i == 0:
		r = s / i
		g.append(r)
		break
	elif s % i > 0:
		t = s // i
		u = s - t
		p.append(t)
		break
if len(g) == 0:
	print(int(p[0] + 1))
elif len(p) == 0:
	print(int(g[0]))


(n, s) = map(int, input().split())
t = 0
if s <= n:
	t = 1
else:
	t = s // n
	if s % n > 0:
		t += 1
print(t)


MOD = 10 ** 9 + 7
I = lambda : list(map(int, input().split()))
(n, s) = I()
print(s // n + (s % n > 0))


(n, s) = [int(i) for i in input().split()]
ans = 0
while s > 0 and n > 0:
	ans += s // n
	s = s % n
	n -= 1
print(ans)


(n, s) = input().split()
(n, s) = (int(n), int(s))
k = s / n
if k > int(k):
	print(int(k) + 1)
else:
	print(int(k))


import sys
(n, s) = list(map(int, sys.stdin.readline().split(' ')))
print(s // n + 1 if s % n > 0 else s // n)


(a, b) = list(map(int, input().split()))
c = 0
for i in range(a, 1, -1):
	if b:
		c += b // i
		b %= i
c += b
print(c)


(n, s) = list(map(int, input().split()))
x = s % n
if x > 0:
	x = 1
print(s // n + x)


[n, S] = [int(i) for i in input().split()]
result = S // n
if S % n != 0:
	result += 1
print(result)


(a, b) = input().split()
(a, b) = (int(a), int(b))
c = 0
while a > 0:
	c += b // a
	b = b % a
	a -= 1
	if b == 0:
		break
print(c)


(n, s) = list(map(int, input().split(' ')))
if s <= n:
	sol = 1
else:
	sol = s // n
	if s % n:
		sol += 1
print(sol)


(n, s) = [int(x) for x in input().split()]
ans = 0
for coin in range(n, 0, -1):
	ans += s // coin
	s %= coin
print(ans)


def ii():
	return int(input())

def ss():
	return [x for x in input()]

def si():
	return [int(x) for x in input().split()]

def mi():
	return map(int, input().split())
(a, b) = mi()
print((b - 1) // a + 1)


import math
(n, c) = map(int, input().split())
print(math.ceil(c / n))


import math
(n, S) = map(int, input().split())
if S % n == 0:
	print(math.floor(S / n))
else:
	print(math.ceil(S / n))


(n, p) = map(int, input().split(' '))
print((p + n - 1) // n)


i = input()
(n, s) = tuple(map(int, i.split(' ')))
res = s // n
if s % n != 0:
	res += 1
print(res)


(n, s) = map(int, input().split())
ans = 0
while s > 0:
	maxcoin = min(s, n)
	ans += s // maxcoin
	s -= ans * maxcoin
print(ans)


s = input()
s = s.split(' ')
result = (int(s[0]) + int(s[1]) - 1) // int(s[0])
print(result)


import sys
import math
get_string = lambda : sys.stdin.readline().strip()
get_list = lambda : list(map(int, sys.stdin.readline().strip().split()))
get_intList_from_str = lambda : list(map(int, list(sys.stdin.readline().strip())))
get_charList_from_str = lambda : list(sys.stdin.readline().strip())
get_int = lambda : int(sys.stdin.readline().strip())
pt = lambda x: sys.stdout.write(str(x))
(n, s) = get_list()
if s % n != 0:
	count = s // n + 1
else:
	count = s // n
print(count)


import math
(x, y) = map(int, input().split())
print(math.ceil(y / x))


import math
(n, s) = list(map(int, input().split()))
print(math.ceil(s / n))


(n, s) = list(map(int, input().split()))
if s <= n:
	print(1)
elif s // n == s / n:
	print(s // n)
else:
	print(s // n + 1)


s = input().split()
(n, s) = (int(s[0]), int(s[1]))
t = s // n
res = t
if t * n != s:
	res += 1
print(res)


(n, k) = map(int, input().split())
c = 0
while k != 0:
	if k > n:
		c += k // n
		k = k % n
	else:
		c += 1
		k = 0
print(c)


m = 0
n = 0
c = 0
a = []
s = input()
x = s.split()
a = [int(y) for y in x]
while a[1] != 0:
	n = a[1] // a[0]
	c += n
	m = a[0] * n
	a[1] -= m
	a[0] -= 1
print(c)


def minimum_quantity(maximum_value, required_value):
	integer_result = required_value // maximum_value
	if required_value % maximum_value > 0:
		return integer_result + 1
	else:
		return integer_result

def main():
	text_input = input()
	split_text = text_input.split(' ')
	coin_maximum_value = int(split_text[0])
	required_value = int(split_text[1])
	print(minimum_quantity(coin_maximum_value, required_value))
	return
main()


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


import math
(n, m) = map(int, input().split())
a = math.modf(m / n)
if n > m:
	print(1)
elif a[0] > 0:
	print(m // n + 1)
else:
	print(m // n)


s = list(map(int, input().split()))
r = 0
if s[0] == 1:
	print(s[1])
elif s[1] % s[0] == 0:
	print(s[1] // s[0])
else:
	r = s[1] // s[0]
	print(r + 1)


(n, S) = list(map(int, input().split()))
count = 0
tmp = n
while S > 0:
	value = S // tmp
	if value > 0:
		S = S - tmp * value
		count = count + value
	else:
		tmp = tmp - 1
print(count)


x = input()
x = x.split()
y = int(x[1])
z = int(x[0])
print(y // z + (y % z != 0))


from math import ceil
(n, S) = map(int, input().split())
print(ceil(S / n))


(n, s) = map(int, input().split())
count = 0
while s != 0:
	count += s // n
	s = s % n
	n -= 1
print(count)


from sys import stdin, stdout
from math import sin, tan, cos, pi, atan2, sqrt, acos, atan, factorial
(n, s) = map(int, stdin.readline().split())
stdout.write(str((s + n - 1) // n))


from math import *
from collections import *

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

def inp_arr():
	return list(map(int, input().split()))
(n, s) = inp()
print(ceil(s / n))


(n, s) = map(int, input().split())
a = []
for i in range(n, 0, -1):
	a.append(i)
l = 0
c = 0
while s > 0 and l < n:
	if n >= s:
		s = 0
		l = l + 1
		c = c + 1
		break
	else:
		c = c + s // a[l]
		s = s % a[l]
print(c)


def read_ints():
	return list(map(int, input().split()))
(n, s) = read_ints()
if s % n != 0:
	ans = int(s / n) + 1
else:
	ans = int(s / n)
print(ans)


import math
from collections import *
import sys
from functools import reduce

def get_ints():
	return map(int, input().strip().split())

def get_list():
	return list(get_ints())

def get_string():
	return list(input().strip().split())

def printxsp(*args):
	return print(*args, end='')

def printsp(*args):
	return print(*args, end=' ')
DIRECTIONS = [[0, 1], [0, -1], [1, 0], [1, -1]]
NEIGHBOURS = [(i, j) for i in range(-1, 2) for j in range(-1, 2) if i != 0 or j != 0]
OrdUnicode_a = ord('a')
OrdUnicode_A = ord('A')
CAPS_ALPHABETS = {chr(i + OrdUnicode_A): i for i in range(26)}
SMOL_ALPHABETS = {chr(i + OrdUnicode_a): i for i in range(26)}
UGLYMOD = int(1000000000.0) + 7
SEXYMOD = 998244353
MAXN = int(100000.0) + 1
INFINITY = float('inf')
(n, k) = get_ints()
print((k + n - 1) // n)


(n, s) = map(int, input().split())
if s % n == 0:
	ans = s // n
else:
	ans = s // n + 1
print(ans)


import math
(n, s) = input().split()
(n, s) = [int(n), int(s)]
ans = math.ceil(s / n)
print(ans)


(n, s) = [int(x) for x in input().split()]
count = 0
while True:
	k = min(s, n)
	count += s // k
	s = s % k
	if s == 0:
		break
print(count)


temp = list(map(int, input().rstrip().split()))
n = temp[0]
S = temp[1]
d = S // n
rem = S % n
if rem == 0:
	print(d)
else:
	print(d + 1)


import math
(n, k) = [int(i) for i in input().split()]
ans = math.ceil(k / n)
print(ans)


(n, s) = map(int, input().split())
if not s % n:
	s -= 1
print(s // n + 1)


def coins(n, s):
	if s % n == 0:
		return s // n
	return s // n + 1
(n, s) = list(map(int, input().rstrip().split()))
print(coins(n, s))


(N, S) = map(int, input().split())
if S > N and S % N != 0:
	ans = S // N + 1
elif S > N and S % N == 0:
	ans = S // N
else:
	ans = 1
print(ans)


(n, S) = map(int, input().split())
res = 0
while S > 0:
	a = S // n
	res += a
	S -= n * a
	n = S % n
print(res)


(nb_coins, sums) = [int(x) for x in input().split()]
(ans, rem) = divmod(sums, nb_coins)
ans += rem > 0
print(ans)


s = input()
s = s.split()
(a, b) = (int(s[0]), int(s[1]))
if b <= a:
	print(1)
elif b % a == 0:
	print(b // a)
else:
	print(b // a + 1)


import math
import os
import random
import re
import sys
a = list(map(int, input().rstrip().split()))
(n, S) = (a[0], a[1])
c = 0
p = S
if S >= n:
	if S % n == 0:
		c = S // n
	else:
		c = S // n + 1
elif S % n == 0:
	c = S // n
else:
	c = S // n + 1
print(c)


(n, s) = map(int, input().split())
k = int(s / n)
l = s % n
if l == 0:
	print(k)
else:
	print(k + 1)


import sys
(n, s) = map(int, sys.stdin.readline().split())
count = 0
count += s // n
if s % n != 0:
	count += 1
print(count, sep=' ', end='\n', file=sys.stdout, flush=False)


i1 = list(map(int, input().split()))
if i1[0] >= i1[1]:
	print(1)
elif i1[1] % i1[0] == 0:
	print(i1[1] // i1[0])
else:
	print(i1[1] // i1[0] + 1)


(n, s) = [int(i) for i in input().split()]
r = s % n
nd = s // n
if r == 0:
	print(nd)
else:
	print(nd + 1)


import math
a = input().split()
ans = 0
if int(a[0]) >= int(a[1]):
	print(1)
else:
	(i, j) = (int(a[0]), int(a[1]))
	while i > 0:
		c = math.floor(j / i)
		j -= c * i
		ans += c
		i = j
	print(ans)


read = lambda : map(int, input().split())
(n, s) = read()
print((n + s - 1) // n)


x = list(map(int, input().split()))
n = x[0]
S = x[1]
p = S // n
if S % n != 0:
	p = p + 1
else:
	p = p + 0
print(p)


(n, s) = map(int, input().split())
count = 0
while s:
	(q, r) = divmod(s, n)
	s = r
	count += q
	n -= 1
print(count)


ns = list(map(int, input().split()))
coins = 0
if ns[0] <= ns[1]:
	if ns[1] % ns[0] == 0:
		print(ns[1] // ns[0])
	else:
		print(ns[1] // ns[0] + 1)
else:
	print(1)


(n, s) = map(int, input().split())
i = s // n
if s % n == 0:
	print(i)
else:
	print(i + 1)


ns = input().split()
n = int(ns[0])
s = int(ns[1])
coins = s // n
if s % n != 0:
	coins += 1
print(coins)


question = input()
question = question.split()
coin_max_value = int(question[0])
sum_needed = int(question[1])
coins_needed = int(sum_needed / coin_max_value)
if sum_needed % coin_max_value > 0:
	print(coins_needed + 1)
else:
	print(coins_needed)


inputs = input()
inputs = inputs.split()
for (i, input_) in enumerate(inputs):
	inputs[i] = int(input_)
max_coin = inputs[0]
sum_coins = inputs[1]
sum_tmp = 0
remainder = sum_coins - sum_tmp
count = 0
while sum_tmp < sum_coins:
	count += int(remainder / max_coin)
	remainder = remainder % max_coin
	sum_tmp = sum_coins - remainder
	max_coin -= 1
print(count)


(n, p) = list(map(int, input().rstrip().split()))
if p % n == 0:
	print(p // n)
else:
	print(p // n + 1)


l = list(map(int, input().split()))
if l[1] % l[0] == 0:
	print(l[1] // l[0])
else:
	print(l[1] // l[0] + 1)


import sys
import math
fileoperation = 0
if fileoperation:
	orig_stdout = sys.stdout
	orig_stdin = sys.stdin
	inputfile = open('W:/Competitive Programming/input.txt', 'r')
	outputfile = open('W:/Competitive Programming/output.txt', 'w')
	sys.stdin = inputfile
	sys.stdout = outputfile
mod = 1000000007

def nospace(l):
	ans = ''.join((str(i) for i in l))
	return ans
t = 1
for tt in range(t):
	(n, k) = map(int, sys.stdin.readline().split(' '))
	val = k // n
	if k % n:
		val += 1
	print(val)
if fileoperation:
	sys.stdout = orig_stdout
	sys.stdin = orig_stdin
	inputfile.close()
	outputfile.close()


import math
(n, S) = map(int, input().split())
r = math.ceil(S / n)
print(r)


(n, s) = map(int, input().split())
coinNum = 0
moneyTotal = 0
coinNum += s // n
moneyTotal += coinNum * n
while moneyTotal < s:
	if moneyTotal + n <= s:
		coinNum += 1
		moneyTotal += n
	else:
		n -= moneyTotal + n - s
print(coinNum)


(n, s) = list(map(int, input().split()))
extra = 0
if s % n:
	extra = 1
print(s // n + extra)


a = input().split()
r = int(a[1])
a = int(a[0])
u = 0
u += r // a
r = r % a
while r != 0:
	if r - a >= 0:
		r = r - a
		u += 1
	else:
		a -= 1
print(u)


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


import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')
(n, k) = map(int, input().split())
if n <= k:
	var = k // n
	rem = k % n
	print(var + 1 if rem > 0 else var)
else:
	print(1)


(n, S) = input().split(' ')
n = int(n)
S = int(S)
c = 0
c = c + S // n
d = S - n * c
if d > 0:
	c += 1
print(c)


(n, m) = map(int, input().split())
x = int(m // n)
y = m % n
if y == 0:
	print(x)
else:
	print(x + 1)


(m, n) = map(int, input().split())
res = int(n / m)
if n % m != 0:
	res += 1
print(res)


(c, s) = [int(i) for i in input().split()]
if s % c == 0:
	print(s // c)
else:
	print(s // c + 1)


(n, S) = map(int, input().split())
count = 0
if S % n > 0:
	count += 1
print(S // n + count)


import sys
from math import sqrt, floor, factorial
from collections import deque, Counter
inp = sys.stdin.readline
read = lambda : list(map(int, inp().strip().split()))

def solve():
	(n, s) = read()
	print(s // n + (1 if s % n > 0 else 0))
solve()


def main():
	(n, s) = input().split(' ')
	n = int(n)
	s = int(s)
	print(s // n + (s % n != 0))
main()


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


(N, S) = map(int, input().split())
print((S + N - 1) // N)


import math
(n, s) = map(int, input().split())
p = math.floor(s / n)
if math.floor(s / n) * n == s:
	print(p)
else:
	print(p + 1)


from bisect import bisect_right as br
from bisect import bisect_left as bl
from collections import defaultdict
import sys
import math
MAX = sys.maxsize
MAXN = 10 ** 6 + 10
MOD = 10 ** 9 + 7

def isprime(n):
	n = abs(int(n))
	if n < 2:
		return False
	if n == 2:
		return True
	if not n & 1:
		return False
	for x in range(3, int(n ** 0.5) + 1, 2):
		if n % x == 0:
			return False
	return True

def solve(a, n):
	x = pow(a, n, MOD) - 1
	return x * pow(a - 1, MOD)

def mhd(a, b, x, y):
	return abs(a - x) + abs(b - y)

def numIN():
	return map(int, sys.stdin.readline().strip().split())

def charIN():
	return sys.stdin.readline().strip().split()
(n, s) = numIN()
if s % n != 0:
	print(s // n + 1)
else:
	print(s // n)


(a, b) = map(int, input().split())
print(b // a + bool(b % a))


(n, m) = map(int, input().split())
c = 0
z = m / n
if z > m // n:
	print(m // n + 1)
else:
	print(m // n)


(n, s) = map(int, input().split())
k = 0
while s > 0:
	if s // n > 0:
		k += s // n
		s = s % n
	n -= 1
print(k)


ent1 = input().split()
m = int(ent1[0])
s = int(ent1[1])
if s % m == 0:
	print(int(s / m))
else:
	print(int(s / m) + 1)


(n, S) = [int(x) for x in input().split()]
l = 1 if S % min(S, n) != 0 else 0
print(S // min(S, n) + l)


(c, s) = map(int, input().split())
ans = 0
while s > 0 and c > 0:
	ans += s // c
	s -= c * (s // c)
	c -= 1
print(ans)


import math
temp = input()
temp = temp.split(' ')
coins = int(temp[0])
value = int(temp[1])
result = 0
total_value = 0
i = 0
result = math.ceil(value / coins)
print(result)


(n, s) = input().split()
n = int(n)
s = int(s)
coin = 0
while n != 0:
	coin = coin + s // n
	s %= n
	n = s
print(coin)


import math
(n, s) = list(map(int, input().split()))
count = 0
d = n
nums = []
while True:
	if s >= d:
		count += s // d
		nums.append((d, s // d))
		s = s % d
	else:
		d = min(d - 1, s)
	if s == 1:
		count += 1
		nums.append((1, 1))
		break
	if s == 0:
		break
print(count)


(t, k) = map(int, input().split())
c = k // t
if k % t > 0:
	c += 1
print(c)


(n, S) = map(int, input().split())
value = n
total = 0
result = 0
while value != 0:
	if total + value > S:
		value -= 1
		continue
	result += 1
	total += value
print(result)


import math
(n, k) = input().split()
(n, k) = (int(n), int(k))
print(int(math.ceil(k / n)))


import math
string = input()
n = int(string.split()[0])
s = int(string.split()[1])
print(math.ceil(s / n))


(n, s) = map(int, input().split())
a = s
c = a // n
r = pow(a, 1, n)
if r != 0:
	c = c + 1
print(c)


import sys
import math
sys.setrecursionlimit(100000)
input = sys.stdin.readline

def inp():
	return int(input())

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

def insr():
	s = input()
	return list(s[:len(s) - 1])

def invr():
	return map(int, input().split())
(n, m) = invr()
ans = (m - 1) // n + 1
print(ans)


(nString, SString) = input().split(' ')
(n, S) = (int(nString), int(SString))
r = 0
c = 0
while n > 0:
	c = int(S / n)
	r += c
	S -= n * c
	if S == 0:
		break
	n -= 1
print(r)


(n, S) = map(int, input().split())
coins = [i + 1 for i in range(n)]

def fun(S, num=0):
	if S == 0:
		return num
	elif S < 0:
		return -1
	if coins[-1] < S:
		return fun(S - S // coins[-1] * coins[-1], num + S // coins[-1])
	return fun(S - coins[S - 1], num + 1)
print(fun(S))


i = input()
li = list(i.split(' '))
li = [int(y) for y in li]
a = li[0]
b = li[1]
c = int(0)
if b % a == 0:
	c = b // a
else:
	c = b // a + 1
print(c)


(n, s) = map(int, input().split())
x = s // n
if s - n * x < n and s - n * x >= 1:
	print(x + 1)
else:
	print(x)


(n, x) = map(int, input().split())
print(str(int(x / n) if x % n == 0 else int(x / n) + 1))


X = list(map(int, input().split()))
sum = 0
while X[1] != 0 and X[0] != 0:
	sum += int(X[1] / X[0])
	X[1] = int(X[1] % X[0])
	X[0] -= 1
print(str(int(sum)))


import re, math, decimal, bisect

def read():
	return input().strip()

def iread():
	return int(input().strip())

def viread():
	return [int(_) for _ in input().strip().split()]
(n, s) = viread()
c = 0
while s > 0:
	if s // n == 0:
		n -= 1
		continue
	c += s // n
	s -= n * (s // n)
print(c)


(n, S) = list(map(int, input().split()))
i = 0
while S != 0:
	i += S // n
	S = S % n
	n -= 1
print(i)


line = input().split(' ')
number = int(line[0])
Sum = int(line[1])
count = 0
if number >= Sum:
	print(1)
else:
	res = Sum // number
	if Sum % number == 0:
		print(res)
	else:
		print(res + 1)


(n, S) = map(int, input().split())
if S <= n:
	res = 1
else:
	res = S // n
	if not S % n == 0:
		res += 1
print(res)


from math import *
from copy import *
from string import *
from random import *
from sys import stdin
from sys import maxsize
from operator import *
from itertools import *
from collections import Counter
import math

def bin1(l, r, k, t, b, val, ans):
	if l > r:
		return ans
	else:
		mid = (l + r) // 2
		v = k ** mid
		if v == val:
			return v
		elif v > val:
			ans = mid
			return bin1(mid + 1, r, k, t, b, val, ans)
		else:
			return bin1(l, mid - 1, k, t, b, val, ans)

def bin2(l, r, k, t, b, val, ans):
	if l > r:
		return ans
	else:
		mid = (l + r) // 2
		v = t * k ** mid + b * mid
		if v == val:
			return v
		elif v > val:
			ans = mid
			return bin2(l, mid - 1, k, t, b, val, ans)
		else:
			return bin2(mid + 1, r, k, t, b, val, ans)

def SieveOfEratosthenes(n):
	prime = [True for i in range(n + 1)]
	p = 2
	while p * p <= n:
		if prime[p] == True:
			for i in range(p * p, n + 1, p):
				prime[i] = False
		p += 1
	l = []
	for i in range(2, n + 1):
		if prime[i]:
			l.append(i)
	return l

def bin(l, r, ll, val):
	if l > r:
		return -1
	else:
		mid = (l + r) // 2
		if val >= ll[mid][0] and val <= ll[mid][1]:
			return mid
		elif val < ll[mid][0]:
			return bin(l, mid - 1, ll, val)
		else:
			return bin(mid + 1, r, ll, val)

def deci(n):
	s = ''
	while n != 0:
		if n % 2 == 0:
			n = n // 2
			s = '0' + s
		else:
			n = n // 2
			s = '1' + s
	return s

def diff(s1, s2):
	if len(s1) < len(s2):
		v = len(s1)
		while v != len(s2):
			s1 = '0' + s1
			v = v + 1
	else:
		v = len(s2)
		while v != len(s1):
			s2 = '0' + s2
			v = v + 1
	c = 0
	for i in range(len(s1)):
		if s1[i:i + 1] != s2[i:i + 1]:
			c = c + 1
	return c
from sys import stdin, stdout

def fac(a, b):
	v = a
	while a != b:
		v *= a - 1
		a = a - 1
	return v

def bino(l, r, n):
	if l > r:
		return -1
	else:
		mid = (l + r) // 2
		val1 = math.log(n / mid + 1, 2)
		val2 = int(val1)
		if val1 == val2:
			return val1
		elif val1 < 1.0:
			return bino(l, mid - 1, n)
		else:
			return bino(mid + 1, r, n)

def binary(l, r, ll, val, ans):
	if l > r:
		return ans
	else:
		mid = (l + r) // 2
		if ll[mid] == val:
			return ll[mid]
		elif ll[mid] < val:
			ans = ll[mid]
			return binary(mid + 1, r, ll, val, ans)
		else:
			return binary(l, mid - 1, ll, val, ans)

def check(n):
	v = 1
	while n != 0:
		if n % 10 == 0 or n % 10 == 1:
			n = n // 10
		else:
			v = 0
			break
	return v
(n, s) = map(int, input().split(' '))
if s > n:
	if s % n == 0:
		print(s // n)
	else:
		print(s // n + 1)
else:
	print(1)


from sys import stdin
from collections import deque
mod = 10 ** 9 + 7
import sys
from bisect import bisect_right
from bisect import bisect_left
from collections import defaultdict
from math import sqrt, factorial, gcd, log2, inf, ceil
import heapq
input = lambda : sys.stdin.readline().rstrip()
from sys import stdin, stdout
from heapq import heapify, heappush, heappop
(n, s) = map(int, input().split())
count = 0
while s != 0:
	count += s // n
	s -= n * (s // n)
	n -= 1
print(count)


arg = input().split(' ')
maxPiece = int(arg[0])
reachNumber = int(arg[1])
if reachNumber % maxPiece == 0:
	print(int(reachNumber / maxPiece))
else:
	print(int(reachNumber / maxPiece) + 1)


data = [int(i) for i in input().split()]
if data[1] % data[0] == 0:
	print(data[1] // data[0])
else:
	print(data[1] // data[0] + 1)


(n, s) = input().split()
n = int(n)
s = int(s)
k = 0
p = 0
if s % n == 0:
	print(s // n)
else:
	print(s // n + 1)


(n, S) = input().split()
n = int(n)
S = int(S)
print((S - 1) // n + 1)


(a, b) = map(int, input().split())
c = 1
while b > a:
	b -= a
	c += 1
print(c)


(n, m) = map(int, input().split())
s = int(n)
c = 0
for i in range(n, 0, -1):
	if m // i != 0:
		c += m // i
		m = m % i
	elif m % i == 0:
		c += m // i
		break
print(c)


str_in = input()
lst_in = str_in.split(' ')
n = int(lst_in[0])
S = int(lst_in[1])
if S % n != 0:
	print(S // n + 1)
else:
	print(int(S / n))


(n, s) = map(int, input().split())
count = 0
for i in range(n):
	count += s // (n - i)
	s -= s // (n - i) * (n - i)
print(count)


(n, s) = tuple(map(int, input().split()))
coins = s // n + (1 if s % n != 0 else 0)
print(str(coins))


(x, y) = [int(a) for a in input().split()]
z = y // x
if y % x > 0:
	z += 1
print(z)


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


from sys import stdin, stdout
import cProfile, math
from collections import Counter
from bisect import bisect_left, bisect, bisect_right
import itertools
from copy import deepcopy
from fractions import Fraction
import sys, threading
sys.setrecursionlimit(10 ** 6)
threading.stack_size(2 ** 27)
printHeap = str()
memory_constrained = False
P = 10 ** 9 + 7
import sys
sys.setrecursionlimit(10000000)

class Operation:

	def __init__(self, name, function, function_on_equal, neutral_value=0):
		self.name = name
		self.f = function
		self.f_on_equal = function_on_equal

def add_multiple(x, count):
	return x * count

def min_multiple(x, count):
	return x

def max_multiple(x, count):
	return x
sum_operation = Operation('sum', sum, add_multiple, 0)
min_operation = Operation('min', min, min_multiple, 1000000000.0)
max_operation = Operation('max', max, max_multiple, -1000000000.0)

class SegmentTree:

	def __init__(self, array, operations=[sum_operation, min_operation, max_operation]):
		self.array = array
		if type(operations) != list:
			raise TypeError('operations must be a list')
		self.operations = {}
		for op in operations:
			self.operations[op.name] = op
		self.root = SegmentTreeNode(0, len(array) - 1, self)

	def query(self, start, end, operation_name):
		if self.operations.get(operation_name) == None:
			raise Exception('This operation is not available')
		return self.root._query(start, end, self.operations[operation_name])

	def summary(self):
		return self.root.values

	def update(self, position, value):
		self.root._update(position, value)

	def update_range(self, start, end, value):
		self.root._update_range(start, end, value)

	def __repr__(self):
		return self.root.__repr__()

class SegmentTreeNode:

	def __init__(self, start, end, segment_tree):
		self.range = (start, end)
		self.parent_tree = segment_tree
		self.range_value = None
		self.values = {}
		self.left = None
		self.right = None
		if start == end:
			self._sync()
			return
		self.left = SegmentTreeNode(start, start + (end - start) // 2, segment_tree)
		self.right = SegmentTreeNode(start + (end - start) // 2 + 1, end, segment_tree)
		self._sync()

	def _query(self, start, end, operation):
		if end < self.range[0] or start > self.range[1]:
			return None
		if start <= self.range[0] and self.range[1] <= end:
			return self.values[operation.name]
		self._push()
		left_res = self.left._query(start, end, operation) if self.left else None
		right_res = self.right._query(start, end, operation) if self.right else None
		if left_res is None:
			return right_res
		if right_res is None:
			return left_res
		return operation.f([left_res, right_res])

	def _update(self, position, value):
		if position < self.range[0] or position > self.range[1]:
			return
		if position == self.range[0] and self.range[1] == position:
			self.parent_tree.array[position] = value
			self._sync()
			return
		self._push()
		self.left._update(position, value)
		self.right._update(position, value)
		self._sync()

	def _update_range(self, start, end, value):
		if end < self.range[0] or start > self.range[1]:
			return
		if start <= self.range[0] and self.range[1] <= end:
			self.range_value = value
			self._sync()
			return
		self._push()
		self.left._update_range(start, end, value)
		self.right._update_range(start, end, value)
		self._sync()

	def _sync(self):
		if self.range[0] == self.range[1]:
			for op in self.parent_tree.operations.values():
				current_value = self.parent_tree.array[self.range[0]]
				if self.range_value is not None:
					current_value = self.range_value
				self.values[op.name] = op.f([current_value])
		else:
			for op in self.parent_tree.operations.values():
				result = op.f([self.left.values[op.name], self.right.values[op.name]])
				if self.range_value is not None:
					bound_length = self.range[1] - self.range[0] + 1
					result = op.f_on_equal(self.range_value, bound_length)
				self.values[op.name] = result

	def _push(self):
		if self.range_value is None:
			return
		if self.left:
			self.left.range_value = self.range_value
			self.right.range_value = self.range_value
			self.left._sync()
			self.right._sync()
			self.range_value = None

	def __repr__(self):
		ans = '({}, {}): {}\n'.format(self.range[0], self.range[1], self.values)
		if self.left:
			ans += self.left.__repr__()
		if self.right:
			ans += self.right.__repr__()
		return ans

def display(string_to_print):
	stdout.write(str(string_to_print) + '\n')

def primeFactors(n):
	factors = dict()
	for i in range(2, math.ceil(math.sqrt(n)) + 1):
		while n % i == 0:
			if i in factors:
				factors[i] += 1
			else:
				factors[i] = 1
			n = n // i
	if n > 2:
		factors[n] = 1
	return factors

def isprime(n):
	if n < 4:
		return True
	if n % 2 == 0:
		return False
	if n % 3 == 0:
		return False
	i = 5
	w = 2
	while i * i <= n:
		if n % i == 0:
			return False
		i += w
		w = 6 - w
	return True

def test_print(*args):
	if testingMode:
		print(args)

def display_list(list1, sep=' '):
	stdout.write(sep.join(map(str, list1)) + '\n')

def get_int():
	return int(stdin.readline().strip())

def get_tuple():
	return map(int, stdin.readline().split())

def get_list():
	return list(map(int, stdin.readline().split()))
memory = dict()

def clear_cache():
	global memory
	memory = dict()

def cached_fn(fn, *args):
	global memory
	if args in memory:
		return memory[args]
	else:
		result = fn(*args)
		memory[args] = result
		return result
TestCases = False
testingMode = False
optimiseForReccursion = False

def main():
	(n, s) = get_tuple()
	res = math.floor(s / n)
	if s % n != 0:
		res = res + 1
	print(res)
if TestCases:
	for _ in range(get_int()):
		cProfile.run('main()') if testingMode else main()
else:
	(cProfile.run('main()') if testingMode else main()) if not optimiseForReccursion else threading.Thread(target=main).start()


[n, s] = list(map(int, input().split(' ')))
r = s // n + (s % n != 0)
print(r)


(n, s) = input().split()
n = int(n)
s = int(s)
k = s // n
q = s % n
if q != 0:
	count = k + 1
	print(count)
else:
	count = k
	print(count)


a = list(map(int, input().split()))
if a[1] in range(1, a[0]):
	print(1)
elif a[1] % a[0] == 0:
	print(a[1] // a[0])
else:
	print(a[1] // a[0] + 1)


import math
from collections import deque
import sys
sys.setrecursionlimit(10 ** 4)

def Divisors(n):
	l = []
	i = 2
	while i <= math.sqrt(n):
		if n % i == 0:
			if n // i == i:
				l.append(i)
			else:
				l.append(i)
				l.append(n // i)
		i = i + 1
	return l

def SieveOfEratosthenes(n):
	l = []
	prime = [True for i in range(n + 1)]
	p = 2
	while p * p <= n:
		if prime[p] == True:
			for i in range(p * p, n + 1, p):
				prime[i] = False
		p += 1
	for p in range(2, n + 1):
		if prime[p]:
			l.append(p)
	return l

def primeFactors(n):
	l = []
	while n % 2 == 0:
		l.append(2)
		n = n / 2
	for i in range(3, int(math.sqrt(n)) + 1, 2):
		while n % i == 0:
			l.append(i)
			n = n / i
	if n > 2:
		l.append(n)
	return l

def Factors(n):
	result = []
	for i in range(2, int(math.sqrt(n)) + 1):
		if n % i == 0:
			if i == n / i:
				result.append(i)
			else:
				result.append(i)
				result.append(n // i)
	result.append(1)
	result.append(n)
	return result

def maxSubArraySum(a):
	max_so_far = 0
	max_ending_here = 0
	size = len(a)
	for i in range(0, size):
		max_ending_here = max_ending_here + a[i]
		if max_so_far < abs(max_ending_here):
			max_so_far = max_ending_here
	return max_so_far

def longestsubarray(arr, n, k):
	current_count = 0
	max_count = 0
	for i in range(0, n, 1):
		if arr[i] % k != 0:
			current_count += 1
		else:
			current_count = 0
		max_count = max(current_count, max_count)
	return max_count

def main():
	(n, s) = list(map(int, input().split()))
	c = 0
	c = s // n
	if s % n != 0:
		c += 1
	print(c)
t = 1
for i in range(0, t):
	main()


from math import ceil

def main():
	(n, m) = [int(v) for v in input().split()]
	print(ceil(m / n))
main()


(n, k) = [int(_) for _ in input().split()]
if k <= n:
	print('1')
elif k % n == 0:
	print(k // n)
else:
	print(k // n + 1)


(n, s) = map(int, input().split())
p = s % n
if p == 0:
	print(s // n)
else:
	print(s // n + 1)


(n, s) = list(map(int, input().split()))
ans = s // n
if s % n != 0:
	ans += 1
print(ans)


(n, s) = (int(x) for x in input().split())
print(int(s / n + 0.9999999))


from sys import stdin, stdout
from math import *
from heapq import *

def main():
	(n, s) = [int(x) for x in stdin.readline().split()]
	res = floor((s + (n - 1)) / n)
	stdout.write(str(res))
	return 0
main()


cin = lambda : map(int, input().split())
(k, x) = cin()
print(x // k + (1, 0)[x % k == 0])


(n, s) = map(int, input().split())
l = []
for i in range(n, 0, -1):
	l.append(i)
ans = 0
for i in l:
	if ans < s:
		c = s // i
		ans += c * i
		if ans == s:
			break
		else:
			c += 1
			break
print(c)


(n, s) = map(int, input().split())
c = 0
r = s % n
q = s // n
if r == 0:
	print(q)
if r in range(1, n + 1):
	c = q + 1
	print(c)
else:
	for i in range(n, 1):
		if r % i == 0:
			c = +1
			break
			print(c)


l = list(map(int, input().split()))
counter = 0
total = 0
totalsum = l[1]
n = l[0]
while totalsum > 0:
	if totalsum >= n:
		counter += totalsum // n
	total = counter * n
	totalsum -= total
	n = totalsum % n
print(counter)


import math
from typing import Dict, List, Tuple

def input_lst() -> List[int]:
	return [int(x) for x in input().split()]

def print_out(res: List[int]):
	print(' '.join([str(x) for x in res]))

def get_primes(n: int) -> List[int]:
	max_n = n
	rng = list(range(max_n + 1))
	rng[0] = 1
	rng[1] = 1
	primes = []
	for i in range(2, max_n + 1):
		if rng[i] > 1:
			primes.append(i)
			for j in range(i + i, max_n + 1, i):
				rng[j] = 0
	return primes

def main():
	(n, s) = (int(x) for x in input().split())
	coin_count = 0
	for i in range(n, 0, -1):
		coin_count += s // i
		s = s % i
	print(coin_count)
main()


(n, S) = map(int, input().split())
if S % n != 0:
	print('%d' % (S // n + 1))
elif S % n == 0:
	print('%d' % (S / n))


(n, s) = map(int, input().split())
cnt = 0
num = s
total = 0
while n >= 1:
	m = s // n
	total = total + m * n
	cnt += m
	s -= m * n
	n -= 1
	if num == total:
		break
print(cnt)


(n, s) = [int(i) for i in input().split()]
d = (n + s - 1) // n
print(d)


(n, m) = map(int, input().split())
if m % n:
	print(int(m / n) + 1)
else:
	print(int(m / n))


inp = input()
(n, s) = [int(x) for x in inp.split(' ')]
if n >= s:
	res = 1
else:
	left = 0
	res = int(s / n)
	if s % n:
		res += 1
print(res)


(n, m) = [int(x) for x in input().split(' ')]
if m % n == 0:
	print(m // n)
else:
	print(m // n + 1)


l = list(map(int, input().split()))
x = l[0]
y = l[1]
r = 0
if y % x != 0:
	r = r + 1 + y // x
else:
	r = r + y // x
print(r)


t = 1
for i in range(t):
	(n, s) = list(map(int, input().strip().split()))
	op = 0
	while s != 0 and n > 0:
		op = op + int(s / n)
		s = s % n
		n = n - 1
	print(op)


def coin_count(a, b):
	if b % a == 0:
		return b // a
	else:
		return b // a + 1
(a, b) = map(int, input().split())
print(coin_count(a, b))


arr = list(map(int, input().split()))
if arr[1] % arr[0] == 0:
	print(arr[1] // arr[0])
elif arr[1] % arr[0] != 0:
	print(arr[1] // arr[0] + 1)


from math import ceil, log, floor, sqrt
import math
k = 1

def mod_expo(n, p, m):
	result = 1
	while p != 0:
		if p % 2 == 1:
			result = result * n % m
		p //= 2
		n = n * n % m
	return result

def is_prime(n):
	m = 2
	while m * m <= n:
		if n % m == 0:
			return False
		m += 1
	return True

def find_sum(n, a):
	a.insert(0, 0)
	for i in range(1, n + 1):
		prev = a[i] & a[i - 1]
		cur = a[i] | a[i - 1]
		a[i - 1] = prev
		a[i] = cur
	return sum((m * m for m in a))

def prin_abc(x, y, z):
	l = [x, y, z]
	l.sort()
	if l[1] < l[2]:
		print('NO')
		return
	a = b = l[0]
	c = l[2]
	print('YES')
	print(a, b, c)

def get_scores(n, vals):
	l = 0
	r = n - 1
	turn = 0
	sereja = 0
	dima = 0
	while l <= r:
		if vals[l] > vals[r]:
			cur = vals[l]
			l += 1
		else:
			cur = vals[r]
			r -= 1
		if turn == 0:
			sereja += cur
		else:
			dima += cur
		turn = not turn
	print(sereja, dima)

def count_lamps(n, m):
	return (n * m + 1) // 2

def find_holidays(n):
	cnt = 2 * (n // 7)
	rem = n % 7
	mx = mn = cnt
	if rem == 1:
		mx += 1
	elif rem > 1:
		mx += 2
	if rem == 6:
		mn += 1
	print(mn, mx)

def get_cnt(n, S):
	cnt = 0
	while S:
		cnt += S // n
		S -= S // n * n
		n = S
	return cnt
t = 1
while t:
	t = t - 1
	(k, g) = (0, 0)
	points = []
	(n, S) = map(int, input().split())
	print(get_cnt(n, S))


import sys
(max_number, summary) = map(int, sys.stdin.readline().split())
count = 0
for i in reversed(range(1, max_number + 1)):
	count += summary // i
	summary -= summary // i * i
	if summary == 0:
		break
print(count)


(n, s) = tuple(map(int, input().strip().split()))
count = 0
while s > 0:
	if s > n:
		s -= n
	else:
		s = 0
	count += 1
print(count)


(n, s) = map(int, input().split())
a = [n - i for i in range(n)]
j = 0
k = 0
while s > 0:
	x = s // a[j]
	s -= x * a[j]
	j += 1
	k += x
print(k)


(n, S) = (int(i) for i in input().split())
print(S // n + (S % n > 0))


string = input().split(' ')
n = int(string[0])
S = int(string[1])
current = n
coins = 0
while S > 0:
	coins += S // current
	S = S % current
	current -= 1
print(coins)


(n, S) = tuple(map(int, input().split()))
print((S + n - 1) // n)


import sys

def min_coins(n, total):
	coins_count = 0
	for i in range(n):
		coin = n - i
		coins_count += int(total / coin)
		total = total % coin
		if total == 0:
			break
	return coins_count
v = [int(x) for x in input().split(' ')]
print(min_coins(v[0], v[1]))


import math
data = [int(i) for i in input().split(' ')]
print(math.ceil(data[1] / data[0]))


(a, b) = [int(x) for x in input().split()]
s = 0
for i in range(a, 0, -1):
	s += b // i
	b %= i
print(s)


(i, j) = map(int, input().split())
if j % i == 0:
	k = j // i
	print(k)
else:
	k = j // i
	print(k + 1)


def solve(n, S):
	return S // n + (1 if S % n != 0 else 0)

def main():
	(n, S) = list(map(int, input().split()))
	print(solve(n, S))
main()


(n, s) = map(int, input().strip().split(' '))
ans = s // n
if ans * n != s:
	ans += 1
print(ans)


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


z = input
from math import ceil, gcd, log
(a, b) = list(map(int, input().split(' ')))
c = 0
for i in range(a, 0, -1):
	c += b // i
	b = b % i
print(c)


from sys import stdin
import math

def main():
	(n, s) = map(int, stdin.readline().split())
	print(math.ceil(s / n))
main()


def solve(n, s):
	if s <= n:
		return 1
	elif s % n == 0:
		return s // n
	return 1 + s // n

def main():
	inl = input().strip().split()
	(n, s) = (int(inl[0]), int(inl[1]))
	print(solve(n, s))
main()


import math
ll = list(map(int, input().split()))
a = ll[0]
b = ll[1]
c = b / a
print(math.ceil(c))


(n, s) = [int(i) for i in input().split()]
i = n
c = 0
while s > 0:
	x = s // i
	c += x
	s -= x * i
	i -= 1
print(c)


import math
import sys
DEBUG = False

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

def dprint(*value, sep=' ', end='\n'):
	if DEBUG:
		print(*value, sep=sep, end=end)

def main():
	(N, S) = [int(e) for e in inp().split()]
	print((S + N - 1) // N)
main()


(n, S) = map(int, input().split())
min_ = 0
for i in range(n, 0, -1):
	if S >= i:
		min_ += S // i
		S = S % i
print(min_)


import functools
(n, s) = map(int, input().split())
if s % n == 0:
	print(s // n)
	exit()
k = (s + n - 1) // n
print(k)


(n, s) = [int(i) for i in input().split()]
print(s // n + 1 if s % n else s // n)


(n, s) = [int(i) for i in input().split()]
m = 0
while s != 0:
	m += s // n
	s -= n * (s // n)
	n -= 1
print(m)


temp = input()
(n, num) = temp.split(' ')
(n, num) = (int(n), int(num))
min_coins = 0
lst = list(range(1, n + 1))
for i in lst[::-1]:
	while num - i >= 0:
		num = num - i
		min_coins += 1
print(min_coins)


(n, k) = map(int, input().split())
if k > n:
	count = 0
	i = n
	while k > 0:
		count += k // i
		k = k % i
		i -= 1
	print(count)
else:
	print(1)


def solve(y, z):
	coins = 0
	while z > 0:
		if z >= y:
			coins += z / y
			z %= y
		y -= 1
	return coins
(y, z) = [int(x) for x in input().split()]
print(int(solve(y, z)))


(n, s) = map(int, input().split())
if s % n == 0:
	print(s // n)
else:
	var = s // n
	print(var + 1)


class IO:

	def get(reader=str):
		return reader(input().strip())

	def gets(reader=str, delim=None):
		return [reader(x) for x in input().strip().split(delim)]

	def tostr(raw, writer=str, delim=' '):
		return delim.join((writer(x) for x in raw))
(n, s) = IO.gets(int)
ans = s // n + int(s % n != 0)
print(ans)


(n, m) = map(int, input().split())
i = n
ans = 0
while m > 0:
	ans += m // i
	m %= i
	i -= 1
print(ans)


(n, S) = map(int, input().split())
cnt = 0
while S:
	(q, S) = divmod(S, n)
	cnt += q
	n -= 1
print(cnt)


def inint():
	return int(input())

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

def main():
	(n, s) = inlist()
	ans = 0
	while s > 0 and n > 0:
		ans += s // n
		s = s % n
		n -= 1
	print(ans)
main()


def mainA():
	(n, s) = map(int, input().split())
	print((s + n - 1) // n)
mainA()


(a, b) = [int(x) for x in input().split()]
print((b + a - 1) // a)


t = input()
(n, s) = t.split()
if int(s) <= int(n):
	print(1)
else:
	remain = int(s) % int(n)
	if remain == 0:
		print(int(s) // int(n))
	else:
		print(int(s) // int(n) + 1)


(n, k) = map(int, input().split())
d = k // n
if k % n != 0:
	d += 1
print(d)


import sys

def rr():
	return sys.stdin.readline().rstrip()
rp = print

def print(*args, **kwargs):
	rp('DBG:# ', *args, **kwargs, file=sys.stderr)

def rri():
	return int(rr())

def rrl():
	return list(map(int, rr().split()))

def rrt():
	return tuple(map(int, rr().split()))

def rrle():
	return (line.rstrip() for line in sys.stdin.readlines())

def rrtl():
	return [tuple(map(int, l.split())) for l in rrle()]
from collections import defaultdict

def mus(d=lambda : 0):
	return defaultdict(lambda : defaultdict(d))

def dd0(d=lambda : 0):
	return defaultdict(d)

def ms(x, y, d=0):
	return [[0] * y for i in range(x)]

def ar(x, d=0):
	return [d] * x

def ppm(m, n=0, x=0, y=0):
	print('\n'.join(('\t'.join((str(m[j][i]) for j in range(y or n))) for i in range(x or n))))

def ppa(a, n):
	print('\t'.join(map(str, a[0:n])))

def ppl(a=0, x=[1]):
	x[0] = a or x[0] + 1
	print('-' + '- -' * 14 + '-# ' + str(x[0] - 2) + ' #-' + '- -' * 14 + '-')

def fltn(a):
	(i for sub in a for i in sub)

def yn(x):
	return 'YES' if x else 'NO'

def cpc(arr):
	return zip(arr, arr[1:])
from itertools import accumulate
from itertools import groupby
from itertools import permutations

def grp(x, key=None):
	return ((i, sum((1 for _ in g))) for (i, g) in groupby(x, key=key))
import math

def rnar():
	return (*rrl(), rrl())

def rn():
	return (*rrl(),)

def dpp(a, b=''):
	print('#| {} |#:^ {} ^:'.format(a, b))

def str_join(i, sep=' '):
	return sep.join(map(str, i))
MOD17 = 10 ** 9 + 7

def read():
	return (*rrl(),)

def solve(n, k):
	ans = math.ceil(k / n)
	return ans
test_count = 1
for _ in range(test_count):
	input_data = read()
	result = solve(*input_data)
	rp(result)


def binpow(n, k):
	if k <= 1:
		return n ** k
	if k % 2 == 0:
		a = binpow(n, k // 2)
		return a * a
	a = binpow(n, k - 1)
	return n * a

def log2(n):
	i = 0
	n -= 1
	while n > 1:
		n //= 2
		i += 1
	return i

def qw(n):
	if n == 1:
		return 0
	if n == 2:
		return 1
	m = log2(n)
	q = binpow(2, m)
	return qw(n - q) + 1 & 3
a = []

def ect(x, t):
	if t <= 0:
		return
	if x == 0:
		print(*a)
		return
	ect(x, t - 1)
	if x >= t:
		a.append(t)
		ect(x - t, t)
		a.pop(-1)

def ras(n):
	i = 1
	ans = 0
	while i * i <= n:
		if n % i == 0:
			ans += 2
		if i * i == n:
			ans -= 1
		i += 1
	return ans

def is_prime(n):
	i = 2
	while i * i <= n:
		if n % i == 0:
			return False
		i += 1
	return True
(n, k) = map(int, input().split())
print(k // n + int(k % n != 0))


import math
(n, sum) = [int(x) for x in input().split()]
print(math.ceil(sum / n))


(n, s) = map(int, input().split())
z = s // n
print(z + 1 if s % n != 0 else z)


import math

def solve(n, s):
	return s // n + (1 if s % n else 0)
from sys import stdin

def main():
	(n, s) = list(map(int, stdin.readline().split()))
	print(solve(n, s))
main()


(n, p) = map(int, input().split())
ans = 0
if p > n:
	ans += int(p / n)
	if p % n != 0:
		ans += 1
else:
	ans = 1
print(ans)


inp = input().split()
maxCoin = int(inp[0], 10)
totalVal = int(inp[1], 10)
numOfCoins = 0
while maxCoin != 0 and totalVal != 0:
	if maxCoin <= totalVal:
		numOfCoins += totalVal // maxCoin
		totalVal %= maxCoin
	maxCoin -= 1
print(numOfCoins)


import sys

def solve(io):
	N = io.read_int()
	S = io.read_int()
	io.println((S + N - 1) // N)

class IO:
	in_stream = None
	out_stream = None
	raw = ''
	buf = []
	pos = 0

	def __init__(self, input_stream, output_stream):
		self.in_stream = input_stream
		self.out_stream = output_stream

	def read_to_buffer(self):
		self.raw = self.in_stream.readline().rstrip('\n')
		self.buf = self.raw.split()
		self.pos = 0

	def read_string(self):
		while self.pos == len(self.buf):
			self.read_to_buffer()
		ans = self.buf[self.pos]
		self.pos += 1
		return ans

	def read_int(self):
		return int(self.read_string())

	def read_float(self):
		return float(self.read_string())

	def read_string_array(self, N, offset=0):
		arr = [None] * offset
		for _ in range(0, N):
			arr.append(self.read_string())
		return arr

	def read_int_array(self, N, offset=0):
		arr = [None] * offset
		for _ in range(0, N):
			arr.append(self.read_int())
		return arr

	def read_float_array(self, N, offset=0):
		arr = [None] * offset
		for _ in range(0, N):
			arr.append(self.read_float())
		return arr

	def read_line(self):
		while self.pos == len(self.buf):
			self.read_to_buffer()
		if self.pos > 0:
			raise ValueError('Cannot call read_line in the middle of a line.')
		return self.raw

	def print(self, s):
		self.out_stream.write(str(s))

	def println(self, s):
		self.print(s)
		self.print('\n')

	def println_array(self, arr, sep=' '):
		self.println(sep.join((str(x) for x in arr)))

	def flush_output(self):
		self.out_stream.flush()
pythonIO = IO(sys.stdin, sys.stdout)
solve(pythonIO)
pythonIO.flush_output()


import sys
from collections import defaultdict as dd
from collections import deque
from fractions import Fraction as f

def eprint(*args):
	print(*args, file=sys.stderr)
zz = 1
from math import *
import copy
if zz:
	input = sys.stdin.readline
else:
	sys.stdin = open('input.txt', 'r')
	sys.stdout = open('all.txt', 'w')

def li():
	return [int(x) for x in input().split()]

def fi():
	return int(input())

def si():
	return list(input().rstrip())

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

def bo(i):
	return ord(i) - ord('a')
from copy import *
from bisect import *
(n, s) = mi()
print(int(ceil(s / n)))