You are given a set of $2n+1$ integer points on a Cartesian plane. Points are numbered from $0$ to $2n$ inclusive. Let $P_i$ be the $i$-th point. The $x$-coordinate of the point $P_i$ equals $i$. The $y$-coordinate of the point $P_i$ equals zero (initially). Thus, initially $P_i=(i,0)$.

The given points are vertices of a plot of a piecewise function. The $j$-th piece of the function is the segment $P_{j}P_{j + 1}$.

In one move you can increase the $y$-coordinate of any point with odd $x$-coordinate (i.e. such points are $P_1, P_3, \dots, P_{2n-1}$) by $1$. Note that the corresponding segments also change.

For example, the following plot shows a function for $n=3$ (i.e. number of points is $2\cdot3+1=7$) in which we increased the $y$-coordinate of the point $P_1$ three times and $y$-coordinate of the point $P_5$ one time: [Image] 

Let the area of the plot be the area below this plot and above the coordinate axis OX. For example, the area of the plot on the picture above is 4 (the light blue area on the picture above is the area of the plot drawn on it).

Let the height of the plot be the maximum $y$-coordinate among all initial points in the plot (i.e. points $P_0, P_1, \dots, P_{2n}$). The height of the plot on the picture above is 3.

Your problem is to say which minimum possible height can have the plot consisting of $2n+1$ vertices and having an area equal to $k$. Note that it is unnecessary to minimize the number of moves.

It is easy to see that any answer which can be obtained by performing moves described above always exists and is an integer number not exceeding $10^{18}$.


-----Input-----

The first line of the input contains two integers $n$ and $k$ ($1 \le n, k \le 10^{18}$) — the number of vertices in a plot of a piecewise function and the area we need to obtain.


-----Output-----

Print one integer — the minimum possible height of a plot consisting of $2n+1$ vertices and with an area equals $k$. It is easy to see that any answer which can be obtained by performing moves described above always exists and is an integer number not exceeding $10^{18}$.


-----Examples-----
Input
4 3

Output
1

Input
4 12

Output
3

Input
999999999999999999 999999999999999986

Output
1



-----Note-----

One of the possible answers to the first example: [Image] 

The area of this plot is 3, the height of this plot is 1.

There is only one possible answer to the second example: $M M$ 

The area of this plot is 12, the height of this plot is 3.

Difficulty: EASY
Tags: Mathematics
Expected Time Complexity: O(1)

Starter code:

Solutions:
from sys import exit
(a, b) = map(int, input().split())
print((b - 1 + a) // a)


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


import sys
import math
get_string = lambda : sys.stdin.readline().strip()
get_int_list = lambda : list(map(int, sys.stdin.readline().strip().split()))
get_int = lambda : int(sys.stdin.readline())
(n, k) = get_int_list()
height_req = k // n + (0 if k % n == 0 else 1)
print(height_req)


from decimal import Decimal, getcontext
getcontext().prec = 1000
(n, k) = map(Decimal, input().split())
import math
print(math.ceil(k / n))


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


(n, k) = map(int, input().split())
(l, u) = (1, k)
while l < u:
	m = (l + u) // 2
	if n * m < k:
		l = m + 1
	if n * m > k:
		u = m
	if n * m == k:
		(l, u) = (m, m)
print(l)


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


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


from math import ceil
(n, k) = map(int, input().split())
ans = k // n + (k % n > 0)
print(ans)


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


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


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


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


import sys
from array import array

def readline():
	return sys.stdin.buffer.readline().decode('utf-8')
(n, k) = map(int, readline().split())
print((n + k - 1) // n)


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


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


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


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


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


(n, k) = map(int, input().split())
number = 2 * n + 1
l = 1
r = 10 ** 18
while r - l > 1:
	x = (r + l) // 2
	if n * x > k:
		r = x
	else:
		l = x
if l * n < k:
	print(r)
else:
	print(l)


(n, k) = list(map(int, input().split()))
h = k // n
if h * n < k:
	h += 1
print(h)


(n, k) = map(int, input().split())
(q, r) = divmod(k, n)
print(q + (r != 0))


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


from sys import stdin, stdout
import cProfile
printHeap = str()
test = False
memory_constrained = False

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

def test_print(output):
	if test:
		stdout.write(str(output) + '\n')

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

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

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

def main():
	(n, k) = get_tuple()
	display(k // n) if k % n == 0 else display(k // n + 1)
cProfile.run('main()') if test else main()


import math
(n, k) = list(map(int, input().split(' ')))
print(-(-k // n))


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


import math
values = input()
(n, k) = values.split()
n = int(n)
k = int(k)
if k <= n:
	print(1)
elif k % n == 0:
	print(k // n)
else:
	print(k // n + 1)


import os
from sys import stdin
from math import floor, ceil
max_val = int(10000000000000.0)
min_val = int(-10000000000000.0)

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

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

def read_str():
	return input()

def read_strs():
	return [x for x in stdin.readline().split()]

def read_str_list():
	return [x for x in stdin.readline().split().split()]
(a, b) = read_ints()
print((b - 1) // a + 1)


(n, k) = [int(s) for s in input().split(' ')]
print(k // n + bool(k % n))


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


import math
from decimal import Decimal
l1 = input().split()
l1 = [Decimal(i) for i in l1]
a = l1[0]
b = l1[1]
ans = math.ceil(b / a)
print(ans)


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


from math import ceil
from sys import stdin, stdout
(n, k) = [int(i) for i in stdin.readline().rstrip().split()]
stdout.write(str((n + k - 1) // n) + '\n')


x = input().split(sep=' ')
n = int(x[0])
k = int(x[1])
if k >= n:
	h0 = int(k / n)
	while h0 * n > k:
		h0 = h0 - 1
	while h0 * n < k:
		h0 = h0 + 1
	if h0 * n > k:
		h0 = h0 - 1
	if h0 * n == k:
		print(h0)
	if h0 * n > k:
		print(h0 - 1)
	if h0 * n < k:
		print(h0 + 1)
if k < n:
	print(1)


(n, k) = map(int, input().split())
h = 1
l = (2 * n + 1) // 2
a = k // l
if a * l >= k:
	print(a)
else:
	print(a + 1)


(n, k) = map(int, input().split())
q = 2 * n + 1
p = k // n
if k % n:
	print(p + 1)
else:
	print(p)


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


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


from math import ceil
(n, k) = [int(i) for i in input().split()]
o = (k + n - 1) // n
print(o)


arr = list(map(int, input().split()))
(n, k) = (arr[0], arr[1])
if k <= n:
	print(1)
elif k > n and k % n == 0:
	print(k // n)
else:
	print(k // n + 1)


from sys import stdin
(n, k) = map(int, stdin.readline().strip().split())
from math import ceil
x = k // n
if k % n != 0:
	x += 1
print(x)


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


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


(n, k) = map(int, input().split())
w = n
h = k // w
if h * w < k:
	h += 1
print(h)


(n, k) = map(int, input().split())
h = k // n
h += bool(k % n)
print(h)


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


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


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


I = lambda : map(int, input().split())
(n, k) = I()
if k <= n:
	exit(print(1))
elif k % n:
	print(k // n + 1)
else:
	print(k // n)


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


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


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


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


(n_points, area) = input().split()
n_points = int(n_points)
area = int(area)
minimum_height = area // n_points
if area % n_points > 0:
	minimum_height += 1
print(minimum_height)


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


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


import math
from collections import defaultdict as dd
import heapq
(n, k) = [int(i) for i in input().split(' ')]
if k % n == 0:
	ans = 0
else:
	ans = 1
print(ans + k // n)


USE_STDIO = False
if not USE_STDIO:
	try:
		import mypc
	except:
		pass

def main():
	(n, k) = map(int, input().split(' '))
	ans = (k + n - 1) // n
	print(ans)
main()


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


import decimal
(n, k) = [int(x) for x in input().split()]
a = decimal.Decimal(k) / decimal.Decimal(n)
if a % 1 == 0:
	print(int(a))
else:
	print(int(a) + 1)


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


import sys, math
(n, m) = map(int, sys.stdin.readline().split())
if n >= m:
	print(1)
else:
	print(m // n if m % n == 0 else m // n + 1)


from math import *
from decimal import *
(a, b) = map(int, input().split())
k = 2 * a
if 2 * b <= 2 * a:
	t = b
	print(1)
else:
	t = Decimal(2 * b) / Decimal(2 * a)
	r = t // 1
	if t > r:
		r = r + 1
	print(r)


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


(n, k) = input().split()
n = int(n)
k = int(k)
minimal = k // n + 1 * (k % n != 0)
print(minimal + 1 * (minimal == 0))


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


def main():
	(n, k) = map(int, input().split(' '))
	print(k // n + (1 if k % n != 0 else 0))
exit(main())


from math import ceil
Input = lambda : map(int, input().split())
(n, k) = Input()
if k < n:
	print(1)
	exit()
if k % n == 0:
	print(k // n)
else:
	print(k // n + 1)


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


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


def f():
	(n, k) = list(map(lambda x: int(x), input().split(' ')))
	print((k + n - 1) // n)
f()


import math
x = input().split()

def func(a, b):
	res = 0
	div = 1
	tmpb = b
	while a >= tmpb * 2:
		tmpb *= 2
		div *= 2
	while a >= b:
		a -= tmpb
		res += div
		while a < tmpb:
			tmpb //= 2
			div //= 2
	if a > 0:
		res += 1
	return '%d' % res
print(func(int(x[1]), int(x[0])))


(n, k) = map(int, input().split())
from math import ceil
m = k % n
b = 0 if m == 0 else 1
print(b + k // n)


import math
(n, k) = [int(i) for i in input().strip().split(' ')]
(q, r) = divmod(k, n)
print(q + (1 if r != 0 else 0))


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


from sys import stdin, stdout
input = lambda : stdin.readline()
write = stdout.write

def main():
	(N, K) = map(int, input().split())
	ans = (K + N - 1) // N
	print(ans)
main()


(n, k) = map(int, input().split())
l = 1
r = k
ans = k
while l <= r:
	mid = (r + l) // 2
	if mid * n >= k:
		ans = mid
		r = mid - 1
	else:
		l = mid + 1
print(ans)


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


m = input().split(' ')
n = int(m[0])
k = int(m[1])
a = divmod(k, n)
if a[1] > 0:
	print(int(a[0] + 1))
else:
	print(a[0])


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


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


(n, k) = map(int, input().split())
if n >= k:
	print(1)
else:
	(q, mod) = divmod(k, n)
	if mod == 0:
		print(q)
	else:
		print(q + 1)


(n, k) = map(int, input().split())
(lo, hi) = (1, 2 * 10 ** 18)
ans = -1
while lo <= hi:
	mid = lo + hi >> 1
	if mid * n >= k:
		ans = mid
		hi = mid - 1
	else:
		lo = mid + 1
print(ans)


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


from math import ceil as c
(n, k) = map(int, input().split())
if k <= n:
	print('1')
elif k % n != 0:
	print(k // n + 1)
else:
	print(k // n)


def main():
	(n, k) = input().split(' ')
	n = int(n)
	k = int(k)
	vertices = 2 * n + 1
	odd_vertices = vertices // 2
	if k <= odd_vertices:
		print(1)
	elif k % odd_vertices == 0:
		print(k // odd_vertices)
	else:
		print(k // odd_vertices + 1)
main()


from os import path
import sys, time
from math import ceil, floor, gcd, log, log2, factorial, sqrt
from collections import defaultdict, Counter, OrderedDict, deque
from itertools import combinations, accumulate
from bisect import *
from functools import reduce
from operator import mul
star = lambda x: print(' '.join(map(str, x)))
grid = lambda r: [lint() for i in range(r)]
INF = float('inf')
if path.exists('input.txt'):
	sys.stdin = open('input.txt', 'r')
	sys.stdout = open('output.txt', 'w')
import sys
from sys import stdin, stdout
from collections import *
from math import gcd, floor, ceil

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

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

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

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

def solve():
	(n, k) = invr()
	print((k + n - 1) // n)
t = 1
for _ in range(t):
	solve()


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


def height_fun(n, k):
	if k % n == 0:
		return k // n
	return k // n + 1
(N, K) = [int(i) for i in input().split()]
print(height_fun(N, K))


from math import ceil
from decimal import Decimal
(n, k) = [Decimal(a) for a in input().split()]
print(ceil(k / n))


s = input().split(' ')
n = int(s[0])
k = int(s[1])
low = 1
high = 1000000000000000000
mid = 0
ans = 1
while low <= high:
	mid = (low + high) // 2
	tot = mid * n
	if tot >= k:
		ans = mid
		high = mid - 1
	else:
		low = mid + 1
print(ans)


(n, k) = map(int, input().split())
(z, y) = divmod(k, n)
if y:
	z += 1
print(z)


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


import math
from decimal import *
x = [int(i) for i in input().split()]
if x[0] >= x[1]:
	print(1)
else:
	print(math.ceil(Decimal(x[1]) / Decimal(x[0])))


(n, k) = list(map(int, input().split()))
pp = 0
sam = int(k // n - 10)
while pp != 1:
	if sam * n >= k:
		pp = 1
	else:
		sam += 1
print(sam)


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


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


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


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


import math, string, itertools, fractions, heapq, collections, re, array, bisect, sys, copy, functools
import random
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 list(map(int, sys.stdin.readline().split()))

def LLI():
	return [list(map(int, l.split())) for l in sys.stdin.readlines()]

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

def LF():
	return [float(x) for x in sys.stdin.readline().split()]

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

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

def F():
	return float(sys.stdin.readline())

def S():
	return input()

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

def pe(s):
	return print(str(s), file=sys.stderr)

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


import sys
from collections import defaultdict as dd
from itertools import permutations as pp
from itertools import combinations as cc
from collections import Counter as ccd
from random import randint as rd
from bisect import bisect_left as bl
mod = 10 ** 9 + 7
(n, k) = [int(i) for i in input().split()]
ans = k // n
if k % n != 0:
	print(ans + 1)
else:
	print(ans)


def check(n, x, k):
	if n * x < k:
		return False
	else:
		return True
(n, k) = [int(__) for __ in input().strip().split()]
(start, end) = (1, k)
mid = (start + end) // 2
while start <= end:
	if check(n, mid, k):
		end = mid - 1
	else:
		start = mid + 1
	mid = (start + end) // 2
print(start)


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


Input = lambda : map(int, input().split())
(n, k) = Input()
print(k // n if k % n == 0 else k // n + 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(' '))
	ans = k // n
	if ans * n == k:
		print(ans)
	else:
		print(ans + 1)
if fileoperation:
	sys.stdout = orig_stdout
	sys.stdin = orig_stdin
	inputfile.close()
	outputfile.close()


import math
_in = input().split(' ')
n = int(_in[0])
k = int(_in[1])
answer = (n + k - 1) // n
print(int(answer))


systemIn = [int(i) for i in input().split()]
triangles = systemIn[0]
totalArea = systemIn[1]
if totalArea <= triangles:
	print(1)
elif totalArea % triangles == 0:
	print(totalArea // triangles)
else:
	print(totalArea // triangles + 1)


(n, k) = map(int, input().split())
v = 2 * n + 1
tri = n
if tri >= k:
	print(1)
else:
	print(k // n + (1 if k % n > 0 else 0))


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


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


inp = input()
(n, k) = inp.split()
(n, k) = (int(n), int(k))
if n == 0:
	max_h = 0
elif k % n == 0:
	max_h = k // n
else:
	max_h = k // n + 1
print(max_h)


(n, k) = [int(s) for s in input().split(' ')]
ans = 1 if n > k else k // n + bool(k % n)
print(ans, '\n')


from fractions import gcd
import math
ls = [int(i) for i in input().split()]
n = ls[0]
k = ls[1]
print(int((n + k - 1) // n))


(n, k) = list(map(int, input().split()))
(a, b, c) = (0, k, 0)
while a < b:
	c = (a + b) // 2
	if c * n < k:
		a = c + 1
	else:
		b = c
print(a)


def _1036A(n, k):
	return k // n + (1 if k % n != 0 else 0)
(n, k) = list(map(lambda x: int(x), input().split()))
print(_1036A(n, k))


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


def main():
	(n, k) = input().split()
	n = int(n)
	k = int(k)
	if k == 0:
		print(0)
	elif k <= n:
		print(1)
	else:
		print(k // n) if k % n == 0 else print(k // n + 1)
main()


import math
from decimal import *
getcontext().prec = 50
(a, b) = input().split()
(a, b) = (Decimal(a), Decimal(b))
d = b / a
print(math.ceil(d))


(n, k) = map(int, input().strip().split())
(lower, upper) = (-1, 1)
while upper * n < k:
	upper <<= 1
while lower < upper - 1:
	mid = lower + upper >> 1
	if mid * n == k:
		upper = mid
		break
	elif mid * n < k:
		lower = mid
	else:
		upper = mid
print(upper)


m = input().split()
xskr = [int(x) for x in m]
print((xskr[1] - 1) // xskr[0] + 1)


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


import sys
f = sys.stdin
out = sys.stdout
(n, k) = map(int, f.readline().rstrip('\r\n').split())
if k % n == 0:
	out.write(str(k // n) + '\n')
else:
	out.write(str(k // n + 1) + '\n')


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


import sys
import math
import bisect
import itertools
import random

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


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, **kwargs, file=sys.stderr)
	dprint('debug mode')
except ModuleNotFoundError:

	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, K) = getIntList()
r = K // N
if K % N != 0:
	r += 1
print(r)


a = [int(x) for x in input().split()]
n = a[0]
k = a[1]
print((n - 1 + k) // n)


import sys
from math import floor

def minHeight(n, k):
	minh = k // n
	if k % n != 0:
		minh += 1
	return minh
l = input().split()
n = int(l[0])
k = int(l[1])
print(minHeight(n, k))


from math import *
from string import *
from itertools import *
(N, A) = map(int, input().split())
res = 0
l = 1
r = 99999999999999999999
mid = -1
amt = 0
while l <= r:
	mid = (l + r) // 2
	amt = N * mid
	if amt == A:
		res = mid
		r = mid - 1
	elif amt < A:
		l = mid + 1
	else:
		res = mid
		r = mid - 1
print(res)


l = input().split()
n = int(l[0])
k = int(l[1])
a = 1
b = k
while a < b:
	c = (a + b) // 2
	if c * n >= k:
		b = c
	else:
		a = c + 1
print(a)


A = list(map(int, input().split()))
n = A[0]
s = A[1]
print(1 + (s - 1) // n)


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


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


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


def go():
	(n, k) = [int(i) for i in input().split(' ')]
	(a, b) = divmod(k, n)
	if b == 0:
		return a
	return a + 1
print(go())


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


import math
import decimal
(n, k) = map(decimal.Decimal, input().split())
print(math.ceil(k / n))


(num_triangles, area) = map(int, input().split())
solution = area // num_triangles
if area % num_triangles != 0:
	solution += 1
print(solution)


(n, k) = map(int, input().split())
l = 0
r = int(1e+18) + 111
while l < r - 1:
	mid = (l + r) // 2
	if mid * n >= k:
		r = mid
	else:
		l = mid
print(r)


from math import ceil
from decimal import *
(n, k) = list(map(int, input().split()))
getcontext().prec = 80
ans = ceil(Decimal(k) / Decimal(n))
if ans == 0:
	print(1)
else:
	print(ans)


input_str = input()
input_arr = input_str.split()
number = int(input_arr[0])
space = int(input_arr[1])
result = 1
if space >= number:
	d = space // number
	rest = space - d * number
	if rest > 0:
		rest = 1
	result = d + rest
print(result)


(n, k) = [int(x) for x in input().split(' ')]
import math
height = divmod(k, n)
print(height[0] + 1 if height[1] > 0 else height[0])


(n, k) = [int(n) for n in input().split()]
print(str(int(-(-k // n))))


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


def f(ll):
	(n, k) = ll
	return (k + n - 1) // n
l = list(map(int, input().split()))
print(f(l))


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


(n, k) = map(int, input().split())
up = 10 ** 18
down = 0
cur = 10 ** 18
r = 10 ** 18 + 1
while n * cur > k or r > n:
	if n * cur > k:
		up = cur
		cur = (cur + down) // 2
		r = k - n * cur
	else:
		down = cur
		cur = (cur + up) // 2
		r = k - n * cur
print((cur, cur + 1)[r != 0])


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


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


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


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


from math import ceil
(n, k) = [int(x) for x in input().split()]
a = k // n
b = k / n
if k // n == 0:
	print(1)
elif k % n != 0:
	print(a + 1)
else:
	print(k // n)


import math
nk = [int(x) for x in input().split()]
temp = nk[1] // nk[0]
if temp * nk[0] < nk[1]:
	temp += 1
print(temp)


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


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


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


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


(n, k) = map(int, input().split())
n = 2 * n + 1
if k == 0:
	print(0)
elif n // 2 >= k:
	print(1)
else:
	ans_s = k // (n // 2)
	ans_d = k % (n // 2)
	if ans_d > 0:
		print(ans_s + 1)
	else:
		print(ans_s)


TN = 1

def solution():
	(n, k) = map(int, input().split())
	print(-(-k // n))
while TN != 0:
	solution()
	TN -= 1


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


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


from math import ceil as c
(n, m) = map(int, input().split())
print(m // n) if m % n == 0 else print(m // n + 1)


from math import *

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


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


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


a = list(map(int, input().strip().split(' ')))
(N, K) = (a[0], a[1])
lw = 1
hg = 10 ** 20
while lw <= hg:
	mid = (lw + hg) // 2
	v = N * mid
	if v >= K:
		if mid == 1 or N * (mid - 1) < K:
			print(mid)
			break
	if v >= K:
		hg = mid - 1
	else:
		lw = mid + 1


import fractions
(n, k) = list(map(int, input().split()))
total_points = 2 * n + 1
result = 1
if k % n == 0:
	result = k // n
elif k > n:
	result = k // n + 1
print(result)


import sys, math
(n, k) = map(int, sys.stdin.readline().split())
if k == 0:
	print(0)
else:
	out = k // n
	if k % n != 0:
		out += 1
	print(out)


import math
(N, s) = [int(n) for n in input().split()]
temp = s // N
if temp * N < s:
	temp += 1
print(temp)


(n, k) = map(int, input().split(' '))
l = k // n + (k % n != 0) * 1
print(l)


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


(vertices, area) = [int(x) for x in input().split(' ')]
print(area // vertices + (area % vertices > 0 and 1 or 0))


import atexit
import io
import sys
buff = io.StringIO()
sys.stdout = buff

@atexit.register
def write_output():
	sys.__stdout__.write(buff.getvalue())

def main():
	(n, k) = map(int, input().split())
	if n >= k:
		print(1)
		return
	elif n == 1:
		print(k)
		return
	low = 0
	high = int(1e+20)
	while low <= high:
		mid = (low + high) // 2
		area = n * mid
		if area >= k:
			high = mid - 1
		else:
			low = mid + 1
	print(low)
main()


from collections import deque
from sys import stdin
lines = deque((line.strip() for line in stdin.readlines()))

def nextline():
	return lines.popleft()

def types(cast, sep=None):
	return tuple((cast(x) for x in strs(sep=sep)))

def ints(sep=None):
	return types(int, sep=sep)

def strs(sep=None):
	return tuple(nextline()) if sep == '' else tuple(nextline().split(sep=sep))

def main():
	(n, k) = ints()
	print((k + n - 1) // n)
main()


import math
(m, n) = map(int, input().split())
ans = n % m
ans1 = n // m
if ans >= 1:
	ans1 += 1
else:
	pass
print(ans1)


import atexit
import io
import sys
import math
inf = float('inf')
inf_neg = float('-inf')
range_5 = int(100000.0 + 1)
range_6 = int(1000000.0 + 1)
range_7 = int(10000000.0 + 1)
range_8 = int(100000000.0 + 1)
_INPUT_LINES = sys.stdin.read().splitlines()
input = iter(_INPUT_LINES).__next__
_OUTPUT_BUFFER = io.StringIO()
sys.stdout = _OUTPUT_BUFFER

@atexit.register
def write():
	sys.__stdout__.write(_OUTPUT_BUFFER.getvalue())

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


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


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


from math import ceil
from decimal import *
(n, k) = map(Decimal, input().split())
ans = int(k / n) if k % n == 0 else int(k / n) + 1
print(ans)


def main():
	[n, k] = map(int, input().split())
	a = k // n
	if a * n < k:
		a += 1
	print(a)
main()


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


import os
import sys, math
from io import BytesIO, IOBase

def main():
	t = 1
	for case in range(t):
		(n, k) = list(map(int, input().split()))
		if k % n == 0:
			print(k // n)
		else:
			print(k // n + 1)
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')
main()


import sys
for line in sys.stdin:
	(n, k) = map(int, line.split())
	print((k + n - 1) // n)


ent = input().split(' ')
n = int(ent[0])
k = int(ent[1])
print((k + n - 1) // n)


from math import ceil
(n, area) = map(int, input().split())
if n > area:
	print(1)
elif area % n == 0:
	print(ceil(area // n))
else:
	print(ceil(area // n) + 1)


entrada = input()
n = int(entrada.split()[0])
k = int(entrada.split()[1])
result = (k + n - 1) // n
print(result)


import math
(n1, k1) = input().split(' ')
n = int(n1)
k = int(k1)
s = k // n
m = k % n
if m == 0:
	print(s)
else:
	print(s + 1)


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


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


while True:
	try:
		if __name__ == '__main__':
			(n, k) = map(int, input().split())
			print((n + k - 1) // n)
	except EOFError:
		break


MOD = 10 ** 9 + 7
I = lambda : list(map(int, input().split()))
(n, k) = I()
from math import ceil
if n >= k:
	print(1)
elif k % n == 0:
	print(k // n)
else:
	print(k // n + 1)


def solve(x, y):
	if y % x == 0:
		return y // x
	else:
		return y // x + 1
if False:
	assert solve(4, 3) == 1
	assert solve(4, 12) == 3
	assert solve(999999999999999999, 999999999999999986) == 1
	assert solve(1000000000000000000, 1000000000000000000) == 1
	assert solve(999999999999999999, 1000000000000000000) == 2
else:
	(x, y) = map(int, input().split())
	print(solve(x, y))


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