To make a paper airplane, one has to use a rectangular piece of paper. From a sheet of standard size you can make $s$ airplanes.

A group of $k$ people decided to make $n$ airplanes each. They are going to buy several packs of paper, each of them containing $p$ sheets, and then distribute the sheets between the people. Each person should have enough sheets to make $n$ airplanes. How many packs should they buy?


-----Input-----

The only line contains four integers $k$, $n$, $s$, $p$ ($1 \le k, n, s, p \le 10^4$) — the number of people, the number of airplanes each should make, the number of airplanes that can be made using one sheet and the number of sheets in one pack, respectively.


-----Output-----

Print a single integer — the minimum number of packs they should buy.


-----Examples-----
Input
5 3 2 3

Output
4

Input
5 3 100 1

Output
5



-----Note-----

In the first sample they have to buy $4$ packs of paper: there will be $12$ sheets in total, and giving $2$ sheets to each person is enough to suit everyone's needs.

In the second sample they have to buy a pack for each person as they can't share sheets.

Source: codeforces | Difficulty: EASY
Tags: Mathematics


Solutions:
import math
(k, n, s, p) = map(int, input().split())
c = math.ceil(n / s)
req = k * c
while True:
	if req % p == 0:
		print(req // p)
		break
	else:
		req += 1


import math
(k, n, s, p) = map(int, input().split())
a = int(math.ceil(math.ceil(n / s) * k / p))
ans = a
print(int(ans))


import math
line = input().split(' ')
k = int(line[0])
n = int(line[1])
s = int(line[2])
p = int(line[3])
person = math.ceil(n / s)
total = k * person
print(math.ceil(total / p))


in1 = input().split(' ')
for i in range(0, len(in1)):
	in1[i] = int(in1[i])
k = in1[0]
n = in1[1]
s = in1[2]
p = in1[3]
lis = n // s
if n % s != 0:
	lis += 1
ans = lis * k // p
if lis * k % p != 0:
	ans += 1
print(ans)


(k, n, s, p) = map(int, input().split())
l = (n + s - 1) // s
l *= k
ans = (l + p - 1) // p
print(ans)


(k, n, s, p) = map(int, input().strip().split())
x = (n + s - 1) // s
y = (k * x + p - 1) // p
print(y)


import math
(k, n, s, p) = map(int, input().split())
each = math.ceil(n / s)
total = k * each
ans = math.ceil(total / p)
print(int(ans))


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


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


import math
while True:
	try:
		(k, n, s, p) = map(float, input().strip().split())
		ans = math.ceil(math.ceil(n / s) * k / p)
		print('%.0f' % ans)
	except:
		break


(people_nr, planes_per_person, planes_per_sheet, sheets_per_pack) = (int(x) for x in input().split())
sheets_per_person = (planes_per_person + planes_per_sheet - 1) // planes_per_sheet
sheets_per_group = (people_nr * sheets_per_person + sheets_per_pack - 1) // sheets_per_pack
print(sheets_per_group)


import math
n = list(map(int, input().split()))
m = math.ceil(n[1] / n[2])
m = math.ceil(m * n[0] / n[3])
print(m)


import sys
import math
import bisect
import itertools

def main():
	(k, n, s, p) = map(int, input().split())
	ans = math.ceil(k * math.ceil(n / s) / p)
	print(ans)
main()


import math
(k, n, s, p) = input().split(' ')
k = int(k)
n = int(n)
s = int(s)
p = int(p)
count = 1
total = 0
sheets = s
while n > sheets:
	count += 1
	sheets = s * count
total = count / p
total = math.ceil(total * k)
print(int(total))


import math
(k, n, s, p) = map(float, input().split())
num = math.ceil(n / s)
num *= k
ans = math.ceil(num / p)
print(ans)


(k, n, s, p) = map(int, input().split())
person = (n - 1) // s + 1
al = person * k
pack = (al - 1) // p + 1
print(pack)


import math
(people, planesPerPerson, planesPerSheet, sheetsPerPack) = (int(i) for i in input().split())
sheetsPerPerson = math.ceil(planesPerPerson / planesPerSheet)
totalPacks = sheetsPerPerson * people / sheetsPerPack
print(math.ceil(totalPacks))


import math
(k, n, s, p) = map(int, input().split())

def paper_planes(k, n, s, p):
	min_packs = math.ceil(n / s) * (k / p)
	if n / s < 0:
		min_packs = k
		print(min_packs)
	else:
		min_packs = math.ceil(min_packs)
		print(min_packs)
paper_planes(k, n, s, p)


import math
(k, n, s, p) = input().split()
papers_for_person = math.ceil(int(n) / int(s))
all_papers = int(k) * papers_for_person
print(math.ceil(all_papers / int(p)))


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


(k, n, s, p) = map(int, input().split(' '))
sheet = (n + s - 1) // s * k
pack = (sheet + p - 1) // p
print(pack)


from math import ceil as c
(k, n, s, p) = map(int, input().split())
print(c(k * c(n / s) / p))


from math import ceil
(k, n, s, p) = map(int, input().split())
l = ceil(n / s)
t = int(ceil(k * l / p))
print(t)


(k, n, s, p) = (int(i) for i in input().split())
l = 0
r = 10 ** 10
m = 0
while r - l > 1:
	m = (l + r) // 2
	if m * p // k * s >= n:
		r = m
	else:
		l = m
print(r)


import math
(people, plane_rate, planes_per_sheet, sheets_in_pack) = [int(x) for x in input().strip().split(' ')]
sheets_per_person = math.ceil(plane_rate / planes_per_sheet)
sheets = people * sheets_per_person
print(math.ceil(sheets / sheets_in_pack))


import math
[k, n, s, p] = input().split(' ')
k = int(k)
n = int(n)
s = int(s)
p = int(p)
sheets_need = k * math.ceil(n / s)
result = math.ceil(sheets_need / p)
if result * p < k:
	result = k
print(result)


(k, n, s, p) = map(int, input().split())
t = (n + s - 1) // s
sheets = k * t
print((sheets + p - 1) // p)


import sys
import math
(k, n, s, p) = input().strip().split(' ')
(k, n, s, p) = [int(k), int(n), int(s), int(p)]
nsp = math.ceil(n / s)
ns = nsp * k
print(math.ceil(ns / p))


(k, n, s, p) = map(int, input().split())
ns = (n + s - 1) // s * k
ans = (ns + p - 1) // p
print(ans)


import math
x = list(map(int, input().split()))
(num_p, n_planes_per_person, n_planes_per_sheet, n_sheet_per_packs) = (x[0], x[1], x[2], x[3])
num_paper_needed_each = math.ceil(n_planes_per_person / n_planes_per_sheet)
num_paper_needed = num_paper_needed_each * num_p
num_pack_needed = math.ceil(num_paper_needed / n_sheet_per_packs)
print(num_pack_needed)


import math
(k, n, s, p) = [float(e) for e in input().split()]
print(math.ceil(k * math.ceil(n / s) / p))


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


import math
(people, planesperperson, planespersheet, sheetsperpack) = [int(i) for i in input().split(' ')]
sheetsperperson = math.ceil(planesperperson / planespersheet)
sheetstotal = sheetsperperson * people
packstotal = math.ceil(sheetstotal / sheetsperpack)
print(packstotal)


import math
i = input().split(' ')
k = eval(i[0])
n = eval(i[1])
s = eval(i[2])
p = eval(i[3])
ans = math.ceil(math.ceil(n / s) * k / p)
print(ans)


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


from math import *
(a, b, c, d) = map(int, input().split())
x = ceil(b / c)
y = a * x
z = ceil(y / d)
print(z)


(k, n, s, p) = (int(i) for i in input().split())
L = k * (n // s + int(bool(n % s)))
print(L // p + int(bool(L % p)))


import math
(k, n, s, p) = map(int, input().split())
num_paper_each = math.ceil(n / s)
print(math.ceil(k * num_paper_each / p))


(k, n, s, p) = map(int, input().split())
print(-(-(-(-n // s) * k) // p))


(k, n, s, p) = list(map(int, input().split()))
sheets_per_person = int(n / s)
if n % s:
	sheets_per_person += 1
total_sheets = k * sheets_per_person
packs = int(total_sheets / p)
if total_sheets % p:
	packs += 1
print(packs)


l = input().split()
k = int(l[0])
n = int(l[1])
s = int(l[2])
p = int(l[3])
print((((n - 1) // s + 1) * k - 1) // p + 1)


(a, b, c, d) = [int(x) for x in input().split()]
if b % c == 0:
	ans = b // c
else:
	ans = b // c + 1
ans *= a
if ans % d == 0:
	print(ans // d)
else:
	print(ans // d + 1)


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


(k, n, s, p) = map(int, input().split())
sheets_per_person = (n + s - 1) // s
sheets_total = sheets_per_person * k
packages = (sheets_total + p - 1) // p
print(packages)


from math import ceil
(k, n, s, p) = [int(c) for c in input().split()]
res = ceil(int(ceil(n / s)) * k / p)
print(res)


[k, n, s, p] = map(int, input().strip().split())

def ceil(a, b):
	return -(-a // b)
print(ceil(k * ceil(n, s), p))


import math
r = input().split()
k = int(r[0])
n = int(r[1])
s = int(r[2])
p = int(r[3])
x = math.ceil(n / s)
m = k * x
print(math.ceil(m / p))


l = [int(x) for x in input().split()]
k = l[0]
n = l[1]
s = l[2]
p = l[3]
x = (n + s - 1) // s
print((k * x + p - 1) // p)


import math
a = list(map(int, input().split()))
k = a[0]
n = a[1]
s = a[2]
p = a[3]
b = math.ceil(math.ceil(n / s) * k / p)
print(b)


(k, n, s, p) = [int(x) for x in input().split()]
tmp = n // s
if n % s != 0:
	tmp += 1
tmp *= k
ans = tmp // p
if tmp % p != 0:
	ans += 1
print(ans)


(k, n, s, p) = list(map(int, input().split(' ')))
leaves = n // s
if n % s != 0:
	leaves += 1
leaves_all = leaves * k
if leaves_all % p == 0:
	print(leaves_all // p)
else:
	print(leaves_all // p + 1)


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


alph = 'abcdefghijklmnopqrstuvwxyz'
import math
(k, n, s, p) = map(int, input().split())
print(math.ceil(k * math.ceil(n / s) / p))


import math as m
(k, n, s, p) = map(int, input().split())
print(m.ceil(m.ceil(n / s) * k / p))


(k, n, s, p) = map(int, input().split())
one_person_make = n
paper_one_person_need = (one_person_make + s - 1) // s
paper_all_persons_need = paper_one_person_need * k
packs_all_persons_need = (paper_all_persons_need + p - 1) // p
print(packs_all_persons_need)


from sys import stdin
from math import ceil

def main():
	(k, n, s, p) = [int(x) for x in stdin.readline().rstrip().split()]
	a = ceil(n / s)
	b = a * k
	res = ceil(b / p)
	print(res)
main()


def solution(l1):
	(k, n, s, p) = (l1[0], l1[1], l1[2], l1[3])
	each = int(n / s) + 1 * (n % s != 0)
	total = each * k
	ans = int(total / p) + 1 * (total % p != 0)
	return ans

def answer():
	l1 = [int(x) for x in input().split()]
	print(solution(l1))
answer()


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


(k, n, s, p) = [int(a) for a in input().split()]
if n % s == 0 and n / s * k % p == 0:
	print(int(n / s * k / p))
elif n % s == 0 and n / s * k % p != 0:
	print(int(n / s * k // p + 1))
elif n % s != 0 and (n // s + 1) * k % p == 0:
	print(int((n // s + 1) * k / p))
else:
	print(int((n // s + 1) * k // p + 1))


import re
readin = input()
lists = re.split('[ ]', readin)
lists = list(map(int, lists))
ans = 0
if lists[1] % lists[2] == 0:
	ans = int(lists[1] / lists[2])
else:
	ans = int(lists[1] / lists[2]) + 1
ans *= lists[0]
if ans % lists[3] == 0:
	ans = int(ans / lists[3])
else:
	ans = int(ans / lists[3]) + 1
print(ans)


import math
(k, n, s, p) = [int(x) for x in input().split()]
x = 1
while n > s * x:
	x += 1
z = math.ceil(x * k / p)
print(z)


def main():
	(K, N, S, P) = map(int, input().split())
	sheet = -(-N // S) * K
	pack = -(-sheet // P)
	print(pack)
main()


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


list1 = input()
list2 = list1.split()
k = int(list2[0])
n = int(list2[1])
s = int(list2[2])
p = int(list2[3])
count = 1
if n > s:
	while n > s:
		count = count + 1
		n = n - s
k = k * count
if k % p != 0:
	print(int(k / p) + 1)
else:
	print(int(k / p))


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 main():
	(k, n, s, p) = (int(x) for x in input().split())
	lists_needed_for_each = n // s
	lists_needed_for_each += 0 if n % s == 0 else 1
	x = lists_needed_for_each * k // p
	x += 0 if lists_needed_for_each * k % p == 0 else 1
	print(x)
main()


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


from math import ceil
b = list(map(int, input().split()))
she = ceil(b[1] / b[2])
p = ceil(she * b[0] / b[3])
print(p)


(k, n, s, p) = [int(x) for x in input().split()]
each = n // s
if n % s != 0:
	each += 1
total = k * each
ans = total // p
if total % p != 0:
	ans += 1
print(ans)


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


(k, n, s, p) = map(int, input().split())
spp = (n + -n % s) // s
ts = spp * k
ppp = (ts + -ts % p) // p
print(ppp)


import math
a = [int(x) for x in input().split()]
x = math.ceil(a[1] / a[2])
y = math.ceil(x * a[0] / a[3])
print(int(y))


import math
(k, n, s, p) = [int(x) for x in input().strip().split(' ')]
nospp = math.ceil(n / s)
ts = k * nospp
print(math.ceil(ts / p))


R = lambda : map(int, input().split())
(k, n, s, p) = R()
num = 0
num = int((int((n - 1) / s + 1) * k - 1) / p + 1)
print(num)


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


import sys

def packs(k, n, s, p):
	x = (n + s - 1) // s
	return (k * x + p - 1) // p
(k, n, s, p) = map(int, sys.stdin.readline().strip().split())
print(packs(k, n, s, p))


import sys
input = sys.stdin.readline
from math import *

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

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

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

def invr():
	return map(int, input().split())
(k, n, s, p) = invr()
a = ceil(n / s)
a = a * k
print(ceil(a / p))


import math as m
(k, n, s, p) = map(int, input().split())
tot = n * k
tota = m.ceil(tot / s)
tote = m.ceil(tota / k) * k
print(m.ceil(tote / p))


(k, n, s, p) = map(int, input().split())
c = lambda x, y: x // y + int(x % y > 0)
a = c(n, s)
b = c(k * a, p)
print(b)


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


from math import ceil
(k, n, s, p) = list(map(int, input().split()))
a = ceil(n / s)
b = ceil(k * a / p)
print(b)


(k, n, s, p) = map(int, input().split())
sheets_per_person = (n + s - 1) // s
sheets = k * sheets_per_person
print((sheets + p - 1) // p)


import math
(k, n, s, p) = list(map(int, input().split()))
ps = math.ceil(n / s)
ts = k * ps
print(math.ceil(ts / p))


import math
(k, n, s, p) = map(int, input().split())
for_1 = math.ceil(n / float(s))
res = math.ceil(for_1 * k / float(p))
print(res)


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


import math
(k, n, s, p) = map(int, input().split(' '))
perpers = math.ceil(n / s)
tot = perpers * k
totalpacks = math.ceil(tot / p)
print(totalpacks)


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


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


a = [int(i) for i in input().split(' ')]
to_one = a[1] // a[2] + 1 * (a[1] % a[2] != 0)
print(a[0] * to_one // a[3] + 1 * (a[0] * to_one % a[3] != 0))


from math import *
(k, n, s, p) = map(int, input().split())
q = k * ceil(n / s)
w = ceil(q / p)
print(w)


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


from math import ceil
X = list(map(int, input().split()))
Math = ceil(X[1] / X[2])
Math = ceil(Math * X[0])
print(ceil(Math / X[3]))


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


import math
s = input()
s = s.split(' ')
l = []
for i in s:
	l.append(int(i))
(k, n, s, p) = (l[0], l[1], l[2], l[3])
x = math.ceil(math.ceil(n / s) * k / p)
print(x)


(k, n, s, p) = map(int, input().split())
sheets_per_person = (n + s - 1) // s
total_sheets = (k * sheets_per_person + p - 1) // p
print(total_sheets)


from math import ceil
(k, n, s, p) = [int(r) for r in input().split()]
total_sheets = k * ceil(n / s)
print(ceil(total_sheets / p))


import math as m
(k, n, s, p) = input().split()
(k, n, s, p) = (int(k), int(n), int(s), int(p))
a = m.ceil(n / s)
a = a * k
q = m.ceil(a / p)
print(q)


(k, n, s, p) = [int(x) for x in input().split()]
lists = n // s + (0 if n % s == 0 else 1)
needed = k * lists
print(needed // p + (0 if needed % p == 0 else 1))


(k, n, s, p) = map(int, input().split())
sheets = (n + s - 1) // s
total = k * sheets
ans = (total + p - 1) // p
print(ans)


(k, n, s, p) = map(int, input().split())
perperson = (n + s - 1) // s
sheets = k * perperson
print((sheets + p - 1) // p)


(k, n, s, p) = map(int, input().split())
papers_for1 = (n + s - 1) // s
box = (k * papers_for1 + p - 1) // p
print(box)


(k, n, s, p) = map(int, input().split())
ans = (n + s - 1) // s
ans1 = (ans * k + p - 1) // p
print(ans1)


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


import math
(k, n, s, p) = map(int, input().split())
numberSheetNedds = math.ceil(n * 1.0 / (s * 1.0))
numberPackNeed = math.ceil(numberSheetNedds * k * 1.0 / (p * 1.0))
print(int(numberPackNeed))


import math
q = input().split(' ')
k = int(q[0])
n = int(q[1])
s = int(q[2])
p = int(q[3])
c = 1
if n > s:
	while n > s:
		c += 1
		n = n - s
k = k * c
print(math.ceil(k / p))


import itertools

def main():
	(k, n, s, p) = [int(v) for v in input().split()]
	r = n // s if n % s == 0 else n // s + 1
	v = r * k // p if r * k % p == 0 else r * k // p + 1
	print(v)
main()


import math
(k, n, s, p) = map(int, input().split(' '))
sheetPerPerson = math.ceil(n / s)
totalNumberOfSheetRequired = sheetPerPerson * k
stacksRequired = math.ceil(totalNumberOfSheetRequired / p)
print(stacksRequired)


(k, n, s, p) = map(int, input().split())
pr = int(n / s + 0.9)
if pr > 0:
	pr *= k
else:
	pr = k
pc = int(pr / p + 0.9)
if pc < 1:
	pc = 1
print(pc)


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


(k, n, s, p) = map(int, input().split())
import math
i = int(math.ceil(n / s))
all_list = k * i
print(int(math.ceil(all_list / p)))


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


inputs_list = list(map(int, input().split()))
k = inputs_list[0]
n = inputs_list[1]
s = inputs_list[2]
p = inputs_list[3]

def sheets(n, s):
	if float(n / s) > int(n / s):
		return int(n / s) + 1
	else:
		return int(n / s)
sheets_req = k * sheets(n, s)
if sheets_req % p == 0:
	print(int(sheets_req / p))
else:
	print(int(sheets_req / p) + 1)


from math import ceil

def solve(k, n, s, p):
	sheets_needed = k * ceil(n / s)
	return ceil(sheets_needed / p)

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


I = lambda : int(input())
IL = lambda : list(map(int, input().split()))
(k, n, s, p) = IL()
ns = k * (n // s + bool(n % s))
print(ns // p + bool(ns % p))


(a, b, c, d) = map(int, input().split())
if b % c == 0:
	k = b // c
else:
	k = b // c + 1
l = a * k
if l % d == 0:
	p = l // d
else:
	p = l // d + 1
print(p)


import math
(k, n, s, p) = map(int, input().split())
sheets = math.ceil(n / s)
packs = math.ceil(k * sheets / p)
print(packs)


import math

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


(k, n, s, p) = map(int, input().strip().split())
if n % s == 0:
	t = n // s
elif n % s != 0:
	t = 1 + n // s
kk = t * k
if kk % p == 0:
	f = kk // p
elif kk % p != 0:
	f = 1 + kk // p
print(f)


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


string = input().split(' ')
k = int(string[0])
n = int(string[1])
s = int(string[2])
p = int(string[3])
if n % s == 0:
	listi = n // s
else:
	listi = n // s + 1
nS = listi * k
if nS % p == 0:
	nS = nS // p
else:
	nS = nS // p + 1
print(nS)


(k, n, s, p) = list(map(int, input().split()))
(l, r) = (0, k * n + 1)
while l < r:
	m = (l + r) // 2
	if m * p // k * s < n:
		l = m + 1
	else:
		r = m
print(l)


a = input()
a = a.split(' ')
for i in range(len(a)):
	a[i] = int(a[i])
if a[1] % a[2] == 0:
	b = a[1] / a[2]
else:
	b = a[1] // a[2] + 1
c = b * a[0]
if c % a[3] == 0:
	d = c // a[3]
else:
	d = c // a[3] + 1
print(int(d))


from math import ceil

def main():
	(k, n, s, p) = [int(x) for x in input().split()]
	ans = ceil(ceil(n / s) * k / p)
	print(ans)
main()


import sys

def ceil_div(a, b):
	q = int(a / b)
	if a % b != 0:
		q += 1
	return q
for line in sys.stdin:
	line = line.strip()
	if len(line) > 0:
		(k, n, s, p) = map(int, line.split(' '))
		num_sheets_per_person = ceil_div(n, s)
		total_num_sheets = num_sheets_per_person * k
		num_packs = ceil_div(total_num_sheets, p)
		print(num_packs)


from math import ceil
(k, n, s, p) = map(int, input().split())
air = ceil(n / s)
total = k * air
ans = ceil(total / p)
print(ans)


import math
inp = input('')
tup = inp.split()
k = int(tup[0])
n = int(tup[1])
s = int(tup[2])
p = int(tup[3])
assert 1 <= k <= 10000
assert 1 <= n <= 10000
assert 1 <= s <= 10000
assert 1 <= p <= 10000
a = s
b = p
step = math.ceil(n / s)
totsheets = step * k
packs = math.ceil(totsheets / p)
print(packs)


(n, m, s, k) = list(map(int, input().split()))
for mnoj in range(1, 10001):
	if s * mnoj >= m:
		pl = mnoj
		break
amount = pl * n
add = amount % k
if add == 0:
	print(amount // k)
else:
	add = k - add
	amount += add
	print(amount // k)


from sys import stdin, stdout
from math import factorial
from math import log10
(k, n, s, p) = map(int, stdin.readline().split())
(l, r) = (0, 10 ** 9)
while r - l > 1:
	m = l + r >> 1
	v = m * p // k
	if v * s >= n:
		r = m
	else:
		l = m
stdout.write(str(r))


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


from math import ceil
(k, n, s, p) = map(int, input().split())
Aa = ceil(n / s)
y = Aa * k
print(ceil(y / p))


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


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


inp = input().split()
k = int(inp[0])
n = int(inp[1])
s = int(inp[2])
p = int(inp[3])
from math import ceil
S = ceil(n / s)
print(ceil(k * S / p))


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


(k, n, s, p) = map(int, input().split())
d = int((n + s - 1) / s)
f = int((d * k + p - 1) / p)
print(f)


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


import sys, math

def calPack(ppl, make, airPreSheet, sheetPrePack):
	sheetNeeded = math.ceil(make / airPreSheet)
	return math.ceil(sheetNeeded * ppl / sheetPrePack)

def main():
	li = [int(x) for x in sys.stdin.readline().split()]
	ppl = li[0]
	make = li[1]
	airPreSheet = li[2]
	sheetPrePack = li[3]
	print(calPack(ppl, make, airPreSheet, sheetPrePack))
main()


import math
inp = input().split(' ')
k = int(inp[0])
n = int(inp[1])
s = int(inp[2])
p = int(inp[3])
perPerson = int(math.ceil(n / s))
needed = perPerson * k
toBuy = int(math.ceil(needed / p))
print(toBuy)


from math import ceil

def a965(k, n, s, p):
	a = ceil(n / s) * k / p
	return ceil(a)
(k, n, s, p) = map(int, input().split())
print(a965(k, n, s, p))


import sys
import math
array = input().split(' ')
for (i, val) in enumerate(array):
	array[i] = int(val)
numPeople = array[0]
numQuota = array[1]
numPlanespace = array[2]
numPackSheets = array[3]
sheetPerPerson = math.ceil(numQuota / numPlanespace)
sheetsTotal = sheetPerPerson * numPeople
outputPacks = math.ceil(sheetsTotal / numPackSheets)
print(outputPacks)


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


a = list(map(int, input().split()))
b = a[1] // a[2]
if a[1] % a[2] != 0:
	b += 1
d = b * a[0]
e = d // a[3]
if d % a[3] != 0:
	e += 1
print(e)


s = input()
in1 = s.split(' ')
k = int(in1[0])
n = int(in1[1])
s = int(in1[2])
p = int(in1[3])
import math
print(math.ceil(k * math.ceil(n / s) / p))


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


import math
(k, n, s, p) = map(int, input().split())
m = math.ceil(n / s)
l = k * m
ans = math.ceil(l / p)
print(ans)


x = list(map(int, input().split()))
need = 1
n = 1
import math
if x[1] > x[2]:
	need = math.ceil(x[1] / x[2])
if x[0] >= x[3]:
	n = math.ceil(need * x[0] / x[3])
print(n)


import sys
import math
get_string = lambda : sys.stdin.readline().strip()
get_int_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_char_list = lambda : sys.stdin.readline().strip().split()
get_int = lambda : int(sys.stdin.readline())
pt = lambda x: sys.stdout.write(str(x))
(k, n, s, p) = get_int_list()
sheet_per_person = math.ceil(n / s)
total_sheet_req = sheet_per_person * k
total_packet_req = math.ceil(total_sheet_req / p)
print(total_packet_req)


S = input().split(' ')
(k, n, s, p) = (int(S[0]), int(S[1]), int(S[2]), int(S[3]))
FT = (n + s - 1) // s
FT *= k
P = (FT + p - 1) // p
print(P)


import math
(k, n, s, p) = map(int, input().split())
v1 = math.ceil(n / s)
v2 = math.ceil(v1 * k)
ans = math.ceil(v2 / p)
print(int(ans))


(k, n, s, p) = list(map(int, input().split()))
x = (n + s - 1) // s
y = k * x
z = (y + p - 1) // p
print(z)


import math, itertools, fractions, heapq, collections, bisect, sys, 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 I():
	return int(sys.stdin.readline())

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

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

def S():
	return input()

def main():
	(a, b, c, d) = LI()
	x = (b + c - 1) // c
	y = x * a
	return (y + d - 1) // d
print(main())


line = input()
temp = line.split(' ')
k = int(temp[0])
n = int(temp[1])
s = int(temp[2])
p = int(temp[3])
sheetperperson = int(n / s)
if sheetperperson != n / s:
	sheetperperson = int(n / s) + 1
res = int(sheetperperson * k / p)
if res == sheetperperson * k / p:
	print(res)
else:
	print(res + 1)


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


entrada = list(map(int, input().split()))
folhaPessoa = entrada[1] / entrada[2]
if folhaPessoa % 1 != 0:
	folhaPessoa = int(folhaPessoa + 1)
qntFolhas = folhaPessoa * entrada[0]
qntPacotes = qntFolhas / entrada[3]
if qntPacotes % 1 != 0:
	qntPacotes = int(qntPacotes + 1)
print('%d' % qntPacotes)


def paperPlane(a):
	(k, n, s, p) = (a[0], a[1], a[2], a[3])
	if n % s != 0:
		pr = n // s + 1
	else:
		pr = n // s
	pps = k * pr
	if pps % p != 0:
		return pps // p + 1
	else:
		return pps // p
arr = list(map(int, input().split()))
print(paperPlane(arr))


import math
first_string = input()
k_n_s_p = list(first_string.split(' '))
k = int(k_n_s_p[0])
n = int(k_n_s_p[1])
s = int(k_n_s_p[2])
p = int(k_n_s_p[3])
if s / n == 0:
	paper_per_one = n / s
else:
	paper_per_one = n / s
	paper_per_one = math.ceil(paper_per_one)
	all_paper = paper_per_one * k
	all_packs = all_paper / p
	all_packs = math.ceil(all_packs)
	print(all_packs)


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


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

def f(m):
	return k * ((n + s - 1) // s) <= p * m
(ok, ng) = (10 ** 9, 0)
while ok - ng > 1:
	m = (ok + ng) // 2
	if f(m):
		ok = m
	else:
		ng = m
print(ok)


(k, n, s, p) = input().split()[:4]
(k, n, s, p) = (int(k), int(n), int(s), int(p))
tmp = n / s
if not tmp.is_integer():
	tmp = int(tmp) + 1
else:
	tmp = int(tmp)
tmp *= k
res = tmp / p
if not res.is_integer():
	res = int(res) + 1
else:
	res = int(res)
print(res)


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


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


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


from math import ceil
(k, n, s, p) = map(int, input().split())
num_each_needs = ceil(n / s)
tot_num = k * num_each_needs
print(ceil(tot_num / p))


(k, n, s, r) = map(int, input().split())
print(-(-n // s * k // r))


import math
(people, airplaneEach, noOfAirplaneSheet, SheetPerPack) = map(int, input().split())
SheetRequired = math.ceil(airplaneEach / noOfAirplaneSheet)
total_sheet = SheetRequired * people
print(math.ceil(total_sheet / SheetPerPack))


from math import *
R = lambda : map(int, input().split())
(k, n, s, p) = R()
m = ceil(n / s)
l = ceil(k * m)
b = ceil(l / p)
print(b)


from math import ceil
(n, k, s, p) = map(int, input().split())
d = ceil(k / s)
pages = n * d
print(ceil(pages / p))


import sys
import os
import math
import re
(k, n, s, p) = map(int, input().split())
sheets = math.ceil(n / s)
totalPap = sheets * k
packs = math.ceil(totalPap / p)
print(packs)


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


import math
(people, planes, number, paper) = map(int, input().split())
print(math.ceil(people * math.ceil(planes / number) / paper))


from math import ceil
(k, n, s, p) = input().split()
(k, n, s, p) = (int(k), int(n), int(s), int(p))
output = ceil(ceil(n / s) * k / p)
print(output)


import math
ent = input()
(a, b, c, d) = ent.split()
print(math.ceil(int(a) * math.ceil(int(b) / float(c)) / float(d)))


from math import ceil
args = [int(x) for x in input().split(' ')]
k = args[0]
n = args[1]
s = args[2]
p = args[3]
print(ceil(ceil(n / s) * k / p))


(k, n, s, p) = input().split()
k = int(k)
n = int(n)
s = int(s)
p = int(p)

def upDivide(num, div):
	if num / div == num // div:
		return num // div
	else:
		return num // div + 1
q = upDivide(n, s)
w = q * k
print(upDivide(w, p))


import math
n = [int(x) for x in input().split()]
print(math.ceil(n[0] * math.ceil(n[1] / n[2]) / n[3]))


ss = [int(n) for n in input().split()]
k = ss[0]
n = ss[1]
s = ss[2]
p = ss[3]
if n % s == 0:
	up = n // s
else:
	up = n // s + 1
ts = k * up
if ts % p == 0:
	print(ts // p)
else:
	print(ts // p + 1)


import math
(k, n, s, p) = list(map(int, input().split()))
np = math.ceil(n / s)
nop = np * k
print(math.ceil(nop / p))


import math
x = list(map(int, input().split()))
print(math.ceil(x[0] * math.ceil(x[1] / x[2]) / x[3]))


import math
line = input()
(k, n, s, p) = [int(el) for el in line.split(' ')]
print(math.ceil(math.ceil(n / s) * k / p))


(k, n, s, p) = map(int, input().split())
if s >= n:
	if k % p != 0:
		print(k // p + 1)
	else:
		print(k // p)
	exit()
if n % s != 0:
	x = n // s + 1
else:
	x = n // s
if x * k % p != 0:
	print(x * k // p + 1)
else:
	print(x * k // p)


from math import ceil
a = list(map(int, input().split()))
print(ceil(ceil(a[1] / a[2]) * a[0] / a[3]))


import math
f = lambda : map(int, input().split())
(k, n, s, p) = f()
print(math.ceil(k * math.ceil(n / s) / p))


import math as mt
(k, n, s, p) = list(map(int, input().split()))
nt = k * n
h = mt.ceil(nt / s)
hp = mt.ceil(h / k)
hr = hp * k
x = mt.ceil(hr / p)
print(x)


from math import ceil
(k, n, s, p) = list(map(int, input().split()))
p_per_person = ceil(n / s)
n_s = k * p_per_person
ans = ceil(n_s / p)
print(ans)


from math import ceil
lst = input().split(' ')
k = int(lst[0])
n = int(lst[1])
s = int(lst[2])
p = int(lst[3])
print(ceil(k * ceil(n / s) / p))


(kala, wala, iota, pot) = map(int, input().split())
if int(wala % iota) == 0:
	n = int(wala / iota)
else:
	n = int(wala / iota) + 1
lamp = kala * n / pot
jug = kala * n % pot
if jug == 0:
	print(int(lamp))
else:
	print(int(lamp) + 1)


[k, n, s, p] = [int(x) for x in input().split(' ')]
ndivs = n // s + (0 if n % s == 0 else 1)
packs = k * ndivs // p + (0 if k * ndivs % p == 0 else 1)
print(packs)


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


def problem():
	(k, n, s, p) = map(int, input().split(' '))
	r = k
	if n > s:
		if n % s:
			r *= n // s + 1
		else:
			r *= n // s
	else:
		r *= 1
	if r > p:
		if r % p:
			solution = r // p + 1
		else:
			solution = r // p
	else:
		solution = 1
	return solution
solution = problem()
print(solution)


def do():
	import math
	(k, n, s, p) = map(int, input().split())
	needpaper = math.ceil(n / s)
	needtotal = needpaper * k
	print(math.ceil(needtotal / p))
do()

def resolve():
	from pprint import pprint
	q = int(input())
	for _ in range(q):
		s = input()
		n = int(input())
		(n, k) = map(int, input().split())
		dat = list(map(int, input().split()))
	dat = [1, 2, 3]
	print(' '.join(list(map(str, res))))
	pass
	import math
	math.ceil(1.2)
	math.floor(1.2)
	round(1.2, 3)


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


a = list(map(int, input().split()))
pp = (a[1] - 1) // a[2] + 1
ts = pp * a[0]
tp = (ts - 1) // a[3] + 1
print(tp)


import math
(people, eachPlaneCnt, planePerSheet, sheetPerPack) = map(int, input().split())
eachNeed = math.ceil(eachPlaneCnt / planePerSheet)
Needed = people * eachNeed
print(math.ceil(Needed / sheetPerPack))


from math import *
a = input()
l = a.split()
k = int(l[0])
n = int(l[1])
s = int(l[2])
p = int(l[3])
result = ceil(ceil(n / s) * k / p)
print(result)


(z, zz) = (input, lambda : list(map(int, z().split())))
(szz, dgraphs, mod) = (lambda : sorted(zz()), {}, 10 ** 9 + 7)
from string import *
from collections import *
from queue import *
from sys import *
from collections import *
from math import *
from heapq import *
from itertools import *
from bisect import *
from collections import Counter as cc
from math import factorial as f

def lcd(xnum1, xnum2):
	return xnum1 * xnum2 // gcd(xnum1, xnum2)

def prime(x):
	p = ceil(x ** 0.5) + 1
	for i in range(2, p):
		if x % i == 0 and x != 2:
			return 0
	return 1

def dfs(u, visit, graph):
	visit[u] = True
	for i in graph[u]:
		if not visit[i]:
			dfs(i, visit, graph)
(k, n, s, p) = zz()
tp = ceil(n / s)
tpp = tp * k
print(ceil(tpp / p))


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


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

def main():
	(k, n, s, p) = read_nums()
	num_needed_sheets = n // s if n % s == 0 else n // s + 1
	if k * num_needed_sheets % p == 0:
		print(k * num_needed_sheets // p)
	else:
		print(k * num_needed_sheets // p + 1)
main()


import math
(k, n, s, p) = [int(x) for x in input().split()]
c = 1
if n > s:
	while n > s:
		c += 1
		n = n - s
k *= c
print(math.ceil(k / p))


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


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


def parser():
	while 1:
		data = list(input().split(' '))
		for number in data:
			if len(number) > 0:
				yield number
input_parser = parser()

def get_word():
	global input_parser
	return next(input_parser)

def get_number():
	data = get_word()
	try:
		return int(data)
	except ValueError:
		return float(data)
k = get_number()
n = get_number()
s = get_number()
p = get_number()
per = n // s + (n % s != 0)
per *= k
print(per // p + (per % p != 0), end='')


import math
(k, n, s, p) = [float(i) for i in input().split()]
area = k * n
need = math.ceil(n / s)
total = need * k
print(math.ceil(total / float(p)))


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


import math
(k, n, s, p) = [int(i) for i in input().split()]
sheet_one_person = math.ceil(n / s)
total_package = math.ceil(k * sheet_one_person / p)
print(total_package)


import math
(k, n, p, s) = list(map(int, input().split()))
r = math.ceil(n / p) * k
R = math.ceil(r / s)
print(R)


(k, n, s, p) = [int(i) for i in input().split(' ')]
sheets_per_person = n // s + (1 if n % s != 0 else 0)
total_sheets = sheets_per_person * k
print(total_sheets // p + (1 if total_sheets % p != 0 else 0))


import math
(k, n, s, p) = input().split()
k = int(k)
n = int(n)
s = int(s)
p = int(p)
border = math.ceil(n / s)
x = math.ceil(border * k / p)
print(x)


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


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


(k, n, s, p) = map(int, input().split())
a = (n + s - 1) // s
b = k * a
print((b + p - 1) // p)


(k, n, s, p) = map(int, input().split())
cont = 0
for i in range(k):
	aux = s
	while aux < n:
		aux += s
	cont += aux
if cont % (p * s) == 0:
	print(int(cont / (p * s)))
else:
	print(int(cont / (p * s) + 1))


import math
c = 0
d = 0
x = input()
p = x.split()
k = int(p[0])
n = int(p[1])
s = int(p[2])
p = int(p[3])
spp = math.ceil(n / s)
ts = spp * k
ans = math.ceil(ts / p)
print(ans)


A = [int(x) for x in input().split(' ')]
print(-(A[0] * (-A[1] // A[2]) // A[3]))


T_ON = 0
DEBUG_ON = 1
MOD = 998244353

def solve():
	(k, n, s, p) = read_ints()
	print(math.ceil(math.ceil(n / s) * k / p))

def main():
	T = read_int() if T_ON else 1
	for i in range(T):
		solve()

def debug(*xargs):
	if DEBUG_ON:
		print(*xargs)
from collections import *
import math
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')

def read_int():
	return int(input())

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

def print_nums(nums):
	print(' '.join(map(str, nums)))

def YES():
	print('YES')

def Yes():
	print('Yes')

def NO():
	print('NO')

def No():
	print('No')

def First():
	print('First')

def Second():
	print('Second')

def fib(n):
	(a, b) = (0, 1)
	for _ in range(n):
		(a, b) = (b, a + b)
	return a

def fib_ns(n):
	assert n >= 1
	f = [0 for _ in range(n + 1)]
	f[0] = 0
	f[1] = 1
	for i in range(2, n + 1):
		f[i] = f[i - 1] + f[i - 2]
	return f

def gcd(a, b):
	if a == 0:
		return b
	return gcd(b % a, a)

def xgcd(a, b):
	(x0, x1, y0, y1) = (0, 1, 1, 0)
	while a != 0:
		((q, a), b) = (divmod(b, a), a)
		(y0, y1) = (y1, y0 - q * y1)
		(x0, x1) = (x1, x0 - q * x1)
	return (b, x0, y0)

def lcm(a, b):
	d = gcd(a, b)
	return a * b // d

def is_even(x):
	return x % 2 == 0

def is_odd(x):
	return x % 2 == 1

def modinv(a, m):
	(g, x, _) = xgcd(a, m)
	if g != 1:
		raise Exception('gcd(a, m) != 1')
	return x % m

def mod_add(x, y):
	x += y
	while x >= MOD:
		x -= MOD
	while x < 0:
		x += MOD
	return x

def mod_mul(x, y):
	return x * y % MOD

def mod_pow(x, y):
	if y == 0:
		return 1
	if y % 2:
		return mod_mul(x, mod_pow(x, y - 1))
	p = mod_pow(x, y // 2)
	return mod_mul(p, p)

def mod_inv(y):
	return mod_pow(y, MOD - 2)

def mod_div(x, y):
	return mod_mul(x, mod_inv(y))

def is_prime(n):
	if n == 1:
		return False
	for i in range(2, int(n ** 0.5) + 1):
		if n % i:
			return False
	return True

def gen_primes(n):
	P = [True for _ in range(n + 1)]
	P[0] = P[1] = False
	for i in range(int(n ** 0.5) + 1):
		if P[i]:
			for j in range(2 * i, n + 1, i):
				P[j] = False
	return P
main()


from math import ceil
qwerty = [int(i) for i in input().split()]
k = qwerty[0]
n = qwerty[1]
s = qwerty[2]
p = qwerty[3]
t = n / s
y = ceil(t)
l = y * k
f = l / p
print(ceil(f))


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


m = list(map(int, input().split()))[:4]
if m[1] % m[2] == 0:
	d = m[1] // m[2]
else:
	d = m[1] // m[2] + 1
g = m[0] * d
if g % m[3] == 0:
	f = g // m[3]
else:
	f = g // m[3] + 1
print(f)


from math import ceil
(k, n, s, p) = list(map(int, input().strip().split(' ')))
print(ceil(ceil(n / s) * k / p))


(a1, a2, a3, a4) = map(int, input().split())
if a2 % a3 > 0:
	t = a2 // a3
	t += 1
else:
	t = a2 // a3
if a1 * t % a4 > 0:
	l = a1 * t // a4
	l += 1
else:
	l = a1 * t // a4
print(l)


inputs = input()
inlst = list(map(int, inputs.split(' ')))
sheetsperperson = inlst[1] // inlst[2]
if inlst[1] % inlst[2] > 0:
	sheetsperperson += 1
sheetsperppl = sheetsperperson * inlst[0]
packs = sheetsperppl // inlst[3]
if sheetsperppl % inlst[3] > 0:
	packs += 1
print(packs)


from math import *
R = lambda : map(int, input().split())
(k, n, s, p) = R()
print(ceil(k * ceil(n / s) / p))


from math import *
y = 1
(k, n, s, p) = map(int, input().split())
if n % s != 0:
	x = n // s + 1
else:
	x = n // s
x *= k
if x % p != 0:
	z = x // p + 1
else:
	z = x // p
print(z)


(k, n, s, p) = map(int, input().split())
sheetsperperson = (n + s - 1) // s
sheets = k * sheetsperperson
print((sheets + p - 1) // p)


print((lambda k, n, s, p: ((n + s - 1) // s * k + p - 1) // p)(*map(int, input().split())))


from math import ceil as l
(a, b, c, d) = map(int, input().split())
m = l(b / c) * a
k = l(m / d)
print(k)


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


import math
s = input().split()
print(int(math.ceil(int(s[0]) * math.ceil(int(s[1]) / int(s[2])) / int(s[3]))))


from sys import stdin, stdout
import math

def main(k, n, s, p):
	res = math.ceil(math.ceil(n / s) * k / p)
	stdout.write(str(res))
main(*map(float, stdin.readline().rstrip().split()))


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

def li():
	return list(inp())
(k, n, s, p) = inp()
print((k * ((n + s - 1) // s) + p - 1) // p)


import math
in_put = str(input(''))
in_put = in_put.split(' ')
list = [0, 0, 0, 0]
list[0] = int(in_put[0])
list[1] = int(in_put[1])
list[2] = int(in_put[2])
list[3] = int(in_put[3])
k = float(list[0])
n = float(list[1])
s = float(list[2])
p = float(list[3])
result = math.ceil(math.ceil(n / s) * k / p)
print(result, end='')


from math import *
(k, n, s, p) = map(int, input().split())
i = ceil(n / s)
j = ceil(k * i / p)
print(j)


(no_people, no_air_each, no_of_air_sheet, no_of_sheet_pack) = list(map(int, input().strip().split()))
import math
total_sheets = no_people * math.ceil(no_air_each / no_of_air_sheet)
ans = math.ceil(total_sheets / no_of_sheet_pack)
print(ans)


a = list(input().split(' '))
(k, n, s, p) = (int(a[0]), int(a[1]), int(a[2]), int(a[3]))
res = 0
res = n // s + int(bool(n % s))
res *= k
res = res // p + int(bool(res % p))
print(res)


(k, n, s, p) = list(map(int, input().strip().split()))
total = k * n
mmin = 1
while mmin * p // k * s < n:
	mmin += 1
print(mmin)


(k, n, s, p) = map(int, input().split())
if k * n // s == 0:
	print(k)
else:
	if n % s > 0:
		f = n // s + 1
	else:
		f = n // s
	h = k * f
	g = h // p
	g1 = h % p
	if g1 > 0:
		print(g + 1)
	else:
		print(g)


(k, n, s, p) = map(int, input().split())
min_pk = 0
if s > n:
	if k % p != 0:
		min_pk = int(k / p) + 1
	else:
		min_pk = k / p
else:
	sh_rq = 0
	if n % s != 0:
		sh_rq = int(n / s) + 1
	else:
		sh_rq = n / s
	tt_sh = sh_rq * k
	if tt_sh % p != 0:
		min_pk = int(tt_sh / p) + 1
	else:
		min_pk = tt_sh / p
print(int(min_pk))


(k, n, s, p) = map(int, input().split())
if n % s != 0:
	c = n // s + 1
else:
	c = n // s
d = c * k
if d % p != 0:
	e = d // p + 1
else:
	e = d // p
print(e)


from math import *
(k, n, s, p) = map(int, input().strip().split(' '))
sheet = ceil(n / s)
total = sheet * k
page = int(ceil(total / p))
print(page)


import math
(a, b, c, d) = input().split()
n = math.ceil(int(b) / int(c))
l = n * int(a)
ans = math.ceil(l / int(d))
print(ans)


import math
(k, n, s, p) = [int(i) for i in input().split()]
S = math.ceil(n / s) * k
q = math.ceil(S / p)
print(q)


lst1 = input()
lst2 = lst1.split()
k = int(lst2[0])
n = int(lst2[1])
s = int(lst2[2])
p = int(lst2[3])
c = 1
if n > s:
	while n > s:
		c = c + 1
		n = n - s
k *= c
print('\n')
if k % p != 0:
	print(int(k / p + 1))
else:
	print(int(k / p))


import math
x = 1
(k, n, s, p) = map(int, input().split())
print(math.ceil(k * math.ceil(n / s) / p))


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


from math import ceil
x = [int(i) for i in input().split()]
k = x[0]
n = x[1]
s = x[2]
p = x[3]
q = ceil(n / s)
ta = k * q
print(ceil(ta / p))


(k, n, s, p) = map(int, input().split())
l = -1
r = 10 ** 18
for i in range(1, 100000):
	if i * s >= n:
		number = i
		break
while r - l > 1:
	m = (r + l) // 2
	if m * p // k >= number:
		r = m
	else:
		l = m
print(r)


from math import *
(k, n, s, p) = [int(x) for x in input().split()]
val = ceil(n / s)
pack = k * val / p
print(int(ceil(pack)))


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


def main():
	(k, n, s, p) = map(int, input().split())
	sheets = (n + s - 1) // s
	packs = (sheets * k + p - 1) // p
	print(packs)
main()


(k, n, s, p) = [int(w) for w in input().split()]
needs = 1 + (n - 1) // s
sum = needs * k
buy = 1 + (sum - 1) // p
print(buy)


import math
B = list(map(int, input().split(' ')))
k = B[0]
n = B[1]
s = B[2]
p = B[3]
f1 = math.ceil(n / s)
s1 = math.ceil(f1 * k / p)
print(s1)


import math
x = [int(i) for i in input().split()]
k = x[0]
n = x[1]
s = x[2]
p = x[3]
sheets_person = math.ceil(n / s)
packs_total = math.ceil(k * sheets_person / p)
print(packs_total)


s = list(map(int, input().split()))
(k, n, s, p) = (s[0], s[1], s[2], s[3])
a = n // s
if s * a != n:
	a += 1
t = a * k // p
if p * t != a * k:
	t += 1
print(t)


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


from math import *
from cmath import *
from itertools import *
from decimal import *
from fractions import *
from sys import *
from types import CodeType, new_class
(k, n, s, p) = map(int, input().split())
print(k * (n // s + (n % s != 0)) // p + (k * (n // s + (n % s != 0)) % p != 0))


from math import ceil
(n, k, s, p) = [int(i) for i in input().split()]
sheet = 0
rem = 0
if k >= s:
	if k % s == 0:
		sheet = k // s
		rem = k % s
	else:
		sheet = k // s + 1
		rem = k % s
else:
	sheet = 1
sheet *= n
if sheet % p == 0:
	print(sheet // p)
else:
	print(ceil(sheet / p))


from math import ceil as c
l = [int(i) for i in input().split()]
k = l[0]
n = l[1]
s = l[2]
p = l[3]
print(c(c(n / s) * k / p))


(k, n, s, p) = map(int, input().split())
air = k * n
fp = n // s
if n % s != 0:
	fp += 1
eh = fp * k
q = eh // p
if eh % p != 0:
	q += 1
print(q)


import math
s = input()
l = s.split()
k = int(l[0])
n = int(l[1])
s = int(l[2])
p = int(l[3])
ans = math.ceil(math.ceil(n / s) * k / p)
print(ans)


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


(k, n, s, p) = map(int, input().split())
n2 = n / s
if n2 != int(n2):
	n2 = int(n2) + 1
else:
	n2 = int(n2)
n2 = n2 * k / p
if n2 != int(n2):
	print(int(n2) + 1)
else:
	print(int(n2))


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


import math
line = input().split()
K = int(line[0])
N = int(line[1])
S = int(line[2])
P = int(line[3])
print(math.ceil(K * math.ceil(N / S) / P))


import math
(k, n, s, p) = list(map(int, input().split()))
t = math.ceil(n / s) * k
ans = math.ceil(t / p)
print(ans)


(k, n, s, p) = map(int, input().split())
t = n // s + bool(n % s)
print(k * t // p + bool(k * t % p))


def test_0():
	import math
	(k, n, s, p) = list(map(int, input().split(' ')))
	aa = math.ceil(k * math.ceil(n / s) / p)
	print(aa)
test_0()


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


(k, n, s, p) = list(map(int, input().split()))
f = n // s + (n % s != 0)
a = f * k // p + (f * k % p != 0)
print(a)


import sys

def divide(a, b):
	return a // b + (a % b != 0)

def main():
	(k, n, s, p) = [int(x) for x in input().split()]
	sheet_per_person = divide(n, s)
	res = divide(sheet_per_person * k, p)
	print(res)
main()


import math as m
(k, n, s, p) = [int(x) for x in input().split()]
ans = int(m.ceil(m.ceil(n / s) * k / p))
print(ans)


from math import ceil
(k, n, s, p) = map(int, input().split())
lo = 1
hi = 1000000000000
cm = int(ceil(n / s))
while lo <= hi:
	ans = (lo + hi) // 2
	if ans * p // k >= cm and (ans - 1) * p // k < cm:
		print(ans)
		exit(0)
	elif ans * p // k >= cm:
		hi = ans - 1
	else:
		lo = ans + 1


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


from sys import stdin
from math import ceil
(k, n, a, p) = map(int, stdin.readline().strip().split())
com = k * ceil(n / a)
ans = ceil(com / p)
print(ans)


import math
(x, y, z, t) = [int(i) for i in input().split()]
a = 0
while a < y:
	a += z
a = a / z
s = math.ceil(x * a / t)
print(s)


from math import ceil
(person, plane, persheet, perpack) = [int(x) for x in input().split()]
each_person_need = ceil(1 / persheet * plane)
pack_needed = ceil(1 / perpack * (each_person_need * person))
print(pack_needed)


import math

def read():
	return list(map(int, input().split()))
(k, n, s, p) = read()
print(math.ceil(math.ceil(n / s) * k / p))


(k, n, s, p) = map(int, input().split())
blanks_count = 0
if s < n:
	if n % s == 0:
		blanks_count = n // s
	else:
		blanks_count = n // s + 1
else:
	blanks_count = 1
paperBlanks_needed = blanks_count * k
if p > paperBlanks_needed:
	print(1)
elif paperBlanks_needed % p == 0:
	print(paperBlanks_needed // p)
else:
	print(paperBlanks_needed // p + 1)


import math
strr = input()
nums = strr.split()
k = int(nums[0])
n = int(nums[1])
s = int(nums[2])
p = int(nums[3])
paper = math.ceil(float(n) / s)
sheets = paper * k
result = math.ceil(float(sheets) / p)
print(result)


import sys
import math
(k, n, s, p) = list(map(int, sys.stdin.readline().strip().split(' ')))
print(math.ceil(k * math.ceil(n / s) / p))


T = input().split(' ')
k = int(T[0])
n = int(T[1])
s = int(T[2])
p = int(T[3])
xd = n // s
if n % s != 0:
	xd += 1
xf = xd * k
sol = xf // p
if xf % p != 0:
	sol += 1
print(sol)


import math

def main():
	(k, n, s, p) = map(int, input().split())
	print(math.ceil(math.ceil(n / s) * k / p))
main()


n = input().split()
k = int(n[0])
s = int(n[2])
p = int(n[3])
n = int(n[1])
if n % s == 0:
	result = n // s
else:
	result = n // s + 1
result = result * k
if result % p == 0:
	result = result // p
else:
	result = result // p + 1
print(result)


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


import sys

def main():
	(k, n, s, p) = map(int, sys.stdin.readline().split())
	spp = n // s if not n % s else n // s + 1
	tmp = spp * k // p
	tmp = tmp if not spp * k % p else tmp + 1
	print(tmp)
main()


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


(k, n, s, p) = [int(x) for x in input().split()]
one = n // s + (n % s != 0)
print(k * one // p + (k * one % p != 0))


def func(pack):
	sheets_available = pack * p
	sheets_person = sheets_available // k
	airplane_person = sheets_person * s
	return airplane_person >= n
(k, n, s, p) = map(int, input().split())
(ans, mid) = (None, None)
(low, up) = (0, 10000000000000000)
while low <= up:
	mid = (low + up) // 2
	if func(mid):
		(ans, up) = (mid, mid - 1)
	else:
		low = mid + 1
print(ans)