A biscuit making machine produces B biscuits at the following moments: A seconds, 2A seconds, 3A seconds and each subsequent multiple of A seconds after activation.
Find the total number of biscuits produced within T + 0.5 seconds after activation.

-----Constraints-----
 - All values in input are integers.
 - 1 \leq A, B, T \leq 20

-----Input-----
Input is given from Standard Input in the following format:
A B T

-----Output-----
Print the total number of biscuits produced within T + 0.5 seconds after activation.

-----Sample Input-----
3 5 7

-----Sample Output-----
10

 - Five biscuits will be produced three seconds after activation.
 - Another five biscuits will be produced six seconds after activation.
 - Thus, a total of ten biscuits will be produced within 7.5 seconds after activation.

Difficulty: EASY

Solutions:
(A, B, T) = list(map(int, input().split()))
T += 0.5
bis = int(T // A)
print(bis * B)


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


(a, b, t) = list(map(int, input().split()))
total = t // a * b
print(total)


(A, B, T) = map(int, input().split())
bis = T // A
print(bis * B)


a = list(map(int, input().split()))
print(a[2] // a[0] * a[1])


(a, b, c) = map(int, input().split())
buf = c // a
print(buf * b)


(A, B, T) = map(int, input().split())
F = T // A
print(F * B)


(a, b, t) = (int(x) for x in input().split())
print(t // a * b)


(a, b, t) = map(int, input().split())
cnt = 0
cnt = t // a * b
print(cnt)


(a, b, c) = list(map(int, input().split(' ')))
print(c // a * b)


(A, B, T) = map(int, input().split())
t = T // A
print(t * B)


(a, b, c) = map(int, input().split())
n = (c + 0.5) // a
print(int(n) * b)


(A, B, C) = [int(s) for s in input().split()]
print(C // A * B)


import sys
import numpy as np
(a, b, t) = map(int, input().split())
print(b * (t // a))


(t, mul, tl) = map(int, input().split())
print(tl // t * mul)


(a, b, c) = map(int, input().split())
n = c // a
print(b * n)


(A, B, T) = tuple(map(int, input().split()))
print(B * (T // A))


(A, B, T) = map(int, input().split())
N = T // A
print(B * N)


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


(a, b, c) = map(int, input().split(' '))
v = c // a
print(b * v)


(a, b, t) = map(int, input().split())
print(int(b * ((t + 0.5) // a)))


(A, B, T) = map(int, input().split())
a = T // A
print(a * B)


(A, B, C) = map(int, input().split())
print(round(C // A * B))


(A, B, T) = map(int, input().split())
num = (T + 0.5) // A
print(int(num * B))


[A, B, T] = list(map(int, input().split()))
print(T // A * B)


LI = lambda : list(map(int, input().split()))
(A, B, T) = LI()

def main():
	ans = T // A * B
	print(ans)

def __starting_point():
	main()
__starting_point()


(A, B, T) = map(int, input().split())
print('{}'.format(T // A * B))


def resolve():
	(a, b, t) = map(int, input().split())
	print(t // a * b)
resolve()


(A, B, T) = map(int, input().split())
T += 0.5
x = T // A
ans = x * B
print(int(ans))


(N, M, K) = map(int, input().split())
print(K // N * M)


(A, B, T) = map(int, input().split())
X = T // A
print(B * X)


(A, B, T) = map(int, input().split(' '))
ans = T // A * B
print(ans)


(A, B, T) = map(int, input().split())
i = T // A
print(B * i)


import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
MOD = 1000000007

def main():
	(A, B, T) = list(map(int, readline().split()))
	print(T // A * B)
	return

def __starting_point():
	main()
__starting_point()


(a, b, t) = [int(i) for i in input().split()]
print(t // a * b)


(A, B, T) = map(int, input().split())
C = T // A
print(C * B)


(A, B, T) = map(int, input().split())
d = T // A
print(d * B)


(a, b, t) = map(int, input().split())
ans = 0
t = t // a
print(t * b)


(a, b, t) = map(int, open(0).read().split())
print(t // a * b)


(a, b, t) = list(map(int, input().split()))
ans = (t + 0.5) // a * b
print(int(ans))


(A, B, T) = [int(x) for x in input().split()]
print(T // A * B)


(A, B, C) = list(map(int, input().split()))
print(C // A * B)


def main():
	(a, b, t) = list(map(int, input().split()))
	ans = t // a * b
	print(ans)

def __starting_point():
	main()
__starting_point()


(a, b, c) = map(int, input().strip().split())
print(c // a * b)


(A, B, T) = map(int, input().split())
time = (T + 0.5) // A
print(int(time * B))


(n, m, k) = map(int, input().split())
print(k // n * m)


(a, b, c) = map(int, input().split())
ans = c // a * b
print(ans)


(a, b, k) = list(map(int, input().split()))
n = k // a
print(b * n)


(A, B, C) = map(int, input().split())
print(int((C + 0.5) // A * B))


(A, B, T) = map(int, input().split())
print((1 + (T - A) // A) * B)


(A, B, T) = [int(i) for i in input().split()]
print(T // A * B)


def mapt(fn, *args):
	return tuple(map(fn, *args))

def Input():
	return mapt(int, input().split(' '))

def main():
	(a, b, k) = Input()
	ans = k // a * b
	print(ans)
main()


_ = list(map(int, input().split()))
print(_[2] // _[0] * _[1])


(a, b, t) = [int(s) for s in input().split()]
print(b * (t // a))


number = input().split(' ')
A = int(number[0])
B = int(number[1])
T = int(number[2])
time = T // A
print(B * time)


(a, b, t) = map(int, input().split())
print((t + 1 // 2) // a * b)


(A, B, T) = (int(X) for X in input().split())
print(T // A * B)


(A, B, T) = map(int, input().split())
x = T // A
print(B * x)


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


(A, B, T) = map(int, input().split())
k = T // A
print(k * B)