Problem:
 Score : 100 points    Problem Statement 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 1 3 5 7      Sample Output 1 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.        Sample Input 2 3 2 9      Sample Output 2 6       Sample Input 3 20 20 19      Sample Output 3 0

Solution (Python):
a,b,t,=map(int,input().split())
T=t//a

print(int(T*b))

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

print(b*(t//a))

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

Solution (Python):
a, b, t = [int(i) for i in input().split()]
print(int((t + 0.5) / a) * b)

Solution (Python):


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

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

Solution (Python):
a,b,t = list(map(int,input().split()))
time = a
ans = 0
while time <= t+0.5:
    ans += b
    time += a
print(ans)

Solution (Python):
a, b, t = map(int, input().split());
biscut = 0;
for i in range(int(t+0.5)):
    if (i+1) % a == 0:
        biscut += b;

print(biscut)

Solution (Python):
a, b, t = map(int, input().split(' '))
ans = int((t + 0.5) // a * b)
print(ans)

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

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

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

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

Solution (Python):
a, b, t = list(map(int, input().split()))
t += .5

n = t // a
print(int(b * n))

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

Solution (Python):
import math
a,b,t = map(int,input().split())
i = a
count = 0
while t+0.5 >= i:
    count += b
    i += a
    

print(count)

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

print(int((t+0.5)//a*b))

Solution (Python):
import sys
A, B, T = map(int,sys.stdin.readline().split())

print((T//A)*B)

Solution (Python):
A, B, T = map(int, input().split())
t = A
count = 0
while t <= T + 0.5:
    count += B
    t += A
print(count)

Solution (Python):
def main():
    a,b,t = [int(x) for x in input().split()]
    print(int((t+0.5)//a*b))


if __name__ == '__main__':
    main()

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

byou = T//A
total = byou * B
print(total)

Solution (Python):

import math

def main():
    A,B,T= map(int, input().split())
    print(math.floor(T/A) * B)

if __name__ == "__main__":
    main()

Solution (Python):

import math

def main():
    A,B,T= map(int, input().split())
    print(math.floor(T/A) * B)

if __name__ == "__main__":
    main()

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

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

Solution (Python):

import math

def main():
    A,B,T= map(int, input().split())
    print(math.floor(T/A) * B)

if __name__ == "__main__":
    main()

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

print(t//a*b)

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

Solution (Python):

import math

def main():
    A,B,T= map(int, input().split())
    print(math.floor(T/A) * B)

if __name__ == "__main__":
    main()

Solution (Python):
A,B,C=map(int,input().split())
print((C//A)*B)

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

Solution (Python):
A, B, T = map(int, input().split())
print(B*(int(T/A)))

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

x = 1

while T / (A * x) >= 1 :
    x += 1
print((x-1)* B)

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

Solution (Python):
A, B, T = map(int, input().split())
print(B * (T//A))

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

print(int(B*(T//A)))

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

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

if __name__ == '__main__':
    solve()

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

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

to = 0
aa = a
while aa <= t+0.5:
	to += b
	aa += a

print(to)

Solution (Python):
A, B, T = map(int, input().split())
print(round((T+ 0.5) // A * B))

Solution (Python):
ABT = input().split()
gen = int(ABT[0])
onetime = int(ABT[1])
Time = int(ABT[2])
cookie = 0

for i in range(1,Time+1):
    if (i % gen)  == 0:
        cookie += onetime

print(cookie)

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

Solution (Python):
A, B, T = map(int, input().strip().split())

total = 0
for i in range(A, T + 1, A):
    total += B
print(total)

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

Solution (Python):
a,b,t=(int(x) for x in input().split())
c=0
for i in range(1,t+1):
  if i%a==0:
    c+=b
print(c)

Solution (Python):
a,b,t = list(map(int,input().strip().split()))
s = int(0)
n = int(t/a)
for k in range(n):
    s += b
print(s)

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

Solution (Python):






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





time = A
sum = 0

while time <= T+0.5:
    sum = sum + B
    time = time + A
    
print(sum)

Solution (Python):
A,B,T = map(int,input().split())
print(B*(T//A))

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

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

print( int((T+0.5)//A * B))

Solution (Python):
a,b,t = map(int,input().split())
if (t+0.5)/a < 1:
  print(0)
else:
  print(int((t+0.5)/a)*b)

Solution (Python):
def slove():
    import sys
    input = sys.stdin.readline
    a, b, t = list(map(int, input().rstrip('\n').split()))
    total = 0
    for i in range(1, t + 1):
        if i % a == 0:
            total += b
    print(total)


if __name__ == '__main__':
    slove()

Solution (Python):
A, B, T = map(int, input().split())
i = 1
ans = 0
while (i * A) <= (T + 0.5):
    ans += B
    i += 1
print(ans)

Solution (Python):
from sys import stdin

a,b,t = [int(x) for x in stdin.readline().rstrip().split()]

print(b*(t//a))

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

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

Solution (Python):
A,B,T=map(int,input().split())
ans=0

for i in range(int(T+0.5)//A):
    ans+=B

print(ans)

Solution (Python):

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

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

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

print(B * (T // A))

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

print(t // a * b)

Solution (Python):
a, b, t = map(int, input().split())
print(int((((t + 0.5) - ((t + 0.5) % a)) / a) * b))

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

Solution (Python):
A , B , T = map(int,input().split())
print(T // A * B)

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

print(T//A*B)

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

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

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

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

s = 0
i = 0 - A[1]

while s < A[2]+0.5:
    s = s + A[0]
    i = i + A[1]
    
print(i)

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

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

Solution (Python):
A, B, T = map(int, input().split())
print((T//A)*B)

Solution (Python):
A, B, T = map(int, input().split())
print((T//A)*B)

Solution (Python):
INPUT = list(map(int,input().split()))
A = int(INPUT[0])
B = int(INPUT[1])
T = int(INPUT[2])
print('{:.0f}'.format((T+0.5)//A*B))

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

Solution (Python):
A,B,T = map(int,input().split())
time = A
count = 0
while time <= T+0.5 :
	time += A
	count += 1

print(B*count)

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

Solution (Python):
'''A - Biscuit Generator
https://atcoder.jp/contests/abc125/tasks/abc125_a

>>> main(3,5,7)
10
>>> main(3,2,9)
6
>>> main(20,20,19)
0'''


def main(a: int, b: int, t: int):
    print(t//a * b)


if __name__ == "__main__":
    a, b, t = map(int, input().split(' '))
    main(a, b, t)

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

Solution (Python):
A,B,T=map(int,input().split())
print(B*(T//A))

Solution (Python):
import math
A, B ,T = map(int, input().split())
print( math.floor((T + 0.5)/A)*B )

Solution (Python):
A, B, T = tuple(map(int, input().split()))
print(int(B * ((T + 0.5) // A)))

Solution (Python):
a,b,t = (int(x) for x in input().split())
print(int((t + 0.5)//a * b))

Solution (Python):
import math
A,B,T = map(int,input().split())
a =  T / A
print((math.floor(a))*B)

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

Solution (Python):
A, B, T  = map(int, input().split())
print(B * (T // A))

Solution (Python):
A=[int(i) for i in input().split()] 
n=A[2]//A[0]*A[1]
print(n)

Solution (Python):

import math


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


if __name__ == "__main__":
    main()

Solution (Python):
A, B, T = [int(v) for v in input().split()]
print((T // A) * B)

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

Solution (Python):
A,B,T = map(int,input().split())
print((T//A)*B)

Solution (Python):
A,B,T = map(int, input().split())
print((T//A)*B)

Solution (Python):
ip = input()
A, B, T = ip.split(" ")

N = int(T) // int(A)

if N < 1:
	print(0)
else: print(N * int(B))

Solution (Python):
def slove():
    import sys
    input = sys.stdin.readline
    a, b, t = list(map(int, input().rstrip('\n').split()))
    print(t // a * b)


if __name__ == '__main__':
    slove()

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

r = (t+0.5)//a
print(int(r*b))

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

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

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

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

Solution (Python):
a,b,t=map(int,input().split())
print(0 if a>t else (t//a)*b)

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

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

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

print(int(((t + 0.5)//a) * b))

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

Solution (Python):
a, b, t = map(int, raw_input().split())
ans = (t/a) * b
print (ans)

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

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

Solution (Python):
A,B,T=map(int,input().split())
print((T//A)*B)

Solution (Python):
A,B,T = map(int,input().split(" "))

print(int(((T+0.5)//A)*B))

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

Solution (Python):
import sys
from io import StringIO
import unittest

class TestClass(unittest.TestCase):
    def assertIO(self, input, output):
        stdout, stdin = sys.stdout, sys.stdin
        sys.stdout, sys.stdin = StringIO(), StringIO(input)
        resolve()
        sys.stdout.seek(0)
        out = sys.stdout.read()[:-1]
        sys.stdout, sys.stdin = stdout, stdin
        self.assertEqual(out, output)
    def test_入力例_1(self):
        input = """3 5 7"""
        output = """10"""
        self.assertIO(input, output)
    def test_入力例_2(self):
        input = """3 2 9"""
        output = """6"""
        self.assertIO(input, output)
    def test_入力例_3(self):
        input = """20 20 19"""
        output = """0"""
        self.assertIO(input, output)

def  resolve():
    (A,B,T)=(int(i) for i in  input().split())
    print(int(T/A)*B)
if __name__ == "__main__":
    resolve()

Solution (Python):
A, B, T = (int(i) for i in input().split())

count = 0
for i in range(0, int(T/A)):
    count += B

print(count)

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

print(int((T+0.5)//A*B))

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

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

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

print(t // a * b)

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

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

Solution (Python):
a,b,t=map(int,input().split())
i=0
Bc=0
while i<=(t+0.5):
    Bc+=b
    i+=a
print(Bc-b)

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

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

cnt = T//A
print(cnt * B)

Solution (Python):
a, b, t = map(int, input().split())
counter = 0
for _ in range(t//a):
    counter += b
print(counter)

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

count = 0

for i in range(1,21,1):
  if t >= i * a :
    count += 1
  else:
    break
    
print( count * b )

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

print(int((t+0.5))//a*b)

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

Solution (Python):
a, b, t = map(int, input().split())
ans = 0
for i in range(1, t + 1):
  if int(i % a) == 0:
    ans += b
print(ans)

Solution (Python):
A, B, T = map(int, input().split())
ans = 0 
i = 0
while ans >= 0:
    i += 1
    if A*i > T + 0.5:
        break
    else:
        ans += B
print(ans)

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

print(T // A * B)

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

Solution (Python):
A, B, T = map(int, input().split(" "))
print(int((T + 0.5) // A * B))

Solution (Python):
A,B,T= map(int, input().split())
print(T//A * B)

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

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

Solution (Python):

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

Solution (Python):
import math
a, b, t = map(int, input().split())
t += 0.5
print(math.floor((t//a)*b))

Solution (Python):
A, B, T = map(int,input().split())
print( T // A * B )

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

print(int((T+0.5)//A)*B)

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

print(int((T+0.5) // A * B))

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

Solution (Python):
A,B,T=map(int,input().split())
c=int(T/A)
print(c*B)

Solution (Python):
A,B,T=map(int,input().split())
biscuits=B*int((T+0.5)/A)
print(biscuits)

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

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

Solution (Python):
A, B, T = map(int,input().split(' '))

print(int(T/A)*B)

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

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

Solution (Python):
A,B,T = [int(x) for x in input().split()]

print((T//A)*B)

Solution (Python):

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

Solution (Python):
import math

A,B,T = map(int, input().split())

print(int(B * ((T+0.5) // A)))

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

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

Solution (Python):
A,B,T=map(int,input().split())
print(T//A*B)

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

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

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

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

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

t = (T+0.5)//A
print(int(B*t))

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

Solution (Python):
A,B,T = map(int,input().split())
print(round(((T + 0.5) // A) * B))

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

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

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

Solution (Python):
def main():
    a,b,t=map(int,input().split(' '))
    print(int((t+0.5)//a*b))

if __name__ == '__main__':
    main()

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

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

print( (t)//a*b )

Solution (Python):

import sys
sys.setrecursionlimit(10 ** 7)


def solve(A: int, B: int, T: int):
    ans, t = 0, 0
    while True:
        t += A
        if t > T + 0.5:
            break
        ans += B
    print(ans)
    return




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


if __name__ == '__main__':
    main()

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

Solution (Python):

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

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

Solution (Python):
a,b,t = list(map(int, input().split()))
cnt = (t//a) * b
print(cnt)

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

Solution (Python):
import sys
def input():
    return sys.stdin.readline()[:-1]


a,b,t = map(int,input().split(' '))
cnt = 0
t += 0.5
T = 0

while True:
    T   += a
    if T>t:
        break
    cnt += b
print(cnt)

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

Solution (Python):
A, B, T = map(int, input().split())
init = A
biscuits = 0
while A < T+0.5:
    biscuits += B
    A += init 
print(biscuits)

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

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

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

ans = int(((T + 0.5) // A) * B)
print(ans)

Solution (Python):
A,B,T=map(int,input().split())
m=(T+0.5)//A
print(int(m*B))

Solution (Python):
import math
A,B,T = map(int,input().split())
print(math.ceil((T+0.5)//A*B))

Solution (Python):
from collections import Counter,defaultdict
import sys,bisect,math,itertools,string,queue
mod = 10**9+7
def inp(): return int(sys.stdin.readline())
def inpl(): return list(map(int, sys.stdin.readline().split()))
def inpl_str(): return list(sys.stdin.readline().split())

a,b,t = inpl()
print(t//a*b)

Solution (Python):
A,B,T = map(int,input().split())
print((T//A)*B)

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

Solution (Python):
A = list(map(int, input().split()))
print( (A[2] //A[0])*A[1])

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

Solution (Python):
A,B,T=map(int,input().split());print(T//A*B)

Solution (Python):
A,B,T=map(int,input().split())
print(T//A*B)

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

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

Solution (Python):
s=list(input().split())
a=int(s[0])
b=int(s[1])
c=int(s[2])

d=int(c/a)
print(b*d)

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

Solution (Python):
A,B,T=map(int,input().split())
print(T//A*B)

Solution (Python):
a,b,t = [int(i) for i in input().split()]

time = a
num = 0
while time < t+0.5:
    num += b
    time += a
print(num)

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

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

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

print((t // a) * b)

Solution (Python):
if __name__ == '__main__':
    A, B, T = map(int, input().split())
    print(int((T+0.5)//A*B))

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

Solution (Python):
a,b,t = map(int,input().split(" "))
ans = 0
while (t >= a):
    t -= a
    ans += b
print(ans)

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

Solution (Python):
a,b,t = map(int,input().split(" "))

ans = 0
while (t >= a):
    t -= a
    ans += b
print(ans)

Solution (Python):
A,B,T = map(int, input().split())
biscuit = int(T/A)*B
print(biscuit)

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

ans=0
for i in range(1,t+1):
  if i%a==0:
    ans+=b
print(ans)

Solution (Python):
def main():
    a, b, t = map(int, input().split())

    ans = 0
    cnt = a
    while cnt <= t:
        ans += b
        cnt += a
    print(ans)

if __name__ == '__main__':
    main()

Solution (Python):
def main():
    a, b, t = map(int, input().split())

    ans = 0
    for _ in range(a, t + 1, a):
        ans += b
    print(ans)

if __name__ == '__main__':
    main()

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

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

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

print(int((t+0.5)//a*b))

Solution (Python):
import sys
input = sys.stdin.readline
A, B, T = map(int, input().split())
ans = 0
for i in range(1,T+1):
	if i % A == 0:
		ans += B
print(ans)

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

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

Solution (Python):
A, B, T = list(map(int, input().split()))
sum = 0
time = A
while time <= T + 0.5:
    sum += B
    time += A
print(sum)

Solution (Python):
a,b,t=map(int,input().split())
ans=0
t_=1
i=1
while 1:
  if t+0.5<t_:
    print(ans)
    break
  if t_%a==0:
    ans+=b
  i+=1
  t_+=1

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

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

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

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

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

print(int(B*((T+0.5)//A)))

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

ct = a
bis = 0

while t + 0.5 >= ct:
    bis += b
    ct += a

print(bis)

Solution (Python):


A, B, T = map(int, input().split())


total = 0
for t in range(1, T+1):
    if t % A == 0:
        total += B


print(total)

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

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

past_time = a
ans = 0
while past_time <= t:
    ans += b
    past_time += a

print(ans)

Solution (Python):
def main():
    A, B, T = map(int, input().split())

    cnt = 0
    for i in range(1, 100):
        if T + 0.5 >= A * i:
            cnt += 1
        else:
            print(cnt*B)
            exit()

main()

Solution (Python):
A, B, T = list(map(int, input().split()))
print(B*(T//A))

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

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

Solution (Python):
a,b,t = map(int,input().split())
for i in range(25):
  if i*a <= t+0.5 < (i+1)*a:
    get = b*i
    print(get)
    break

Solution (Python):
a,b,t = map(int,input().split())
bisket = 0
for i in range(1,t+1):
    if i % a == 0:
        bisket += b
print(bisket)

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

ans = 0

for i in range(T):
  if (i+1) % A == 0:
    ans += B
    

print(ans)

Solution (Python):
A, B, T = map(int, input().split())
print(T // A * B)

Solution (Python):
A, B, T = map(int, input().split())
print(int(T/A)*B)

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

Solution (Python):
A,B,T=map(int,input().split())
print(B*(T//A))

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

t_ans = t+0.5
i = 1
count = 0
while t_ans > a*i:
    count += b
    i += 1
    
print(count)

Solution (Python):
A, B, T = map(int, input().split())
current_time = T + 0.5

q = current_time // A

print(int(B * q))

Solution (Python):
a, b, t = map(int, input().split())
bis = 0
for i in range(a,t+1,a):
  bis += b
print(bis)

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

num_prd = T//A
answer = num_prd*B

print(answer)

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

num_prd = T//A
answer = num_prd*B

if num_prd >= 1 :
	print(answer)
else :
	print(0)

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

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

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

Solution (Python):
A, B, T = map(int,input().split())
print((T//A)*B)

Solution (Python):
A,B,T=map(int, input().split())
print((T//A)*B)

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

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

Solution (Python):
source = input().split()
A, B, T = int(source[0]), int(source[1]), int(source[2])
j = 1
biscuit = 0
current = A
while float(current) <= T + 0.5:
    biscuit += B
    j += 1
    current = A * j
print(biscuit)

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

def main():
    A,B,T = map(int, input().split())
    n = 0
    for _ in range(A,T+1,A):
        n += B
    print(n)

if __name__ == '__main__':
    main()

Solution (Python):
def func():
    A, B, T = map(int, input().split())
    ans = (T+0.5) // A * B
    print(int(ans))


if __name__ == '__main__':
    func()

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

print(t // a * b)

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

print (B * int((T + 0.5) // A))

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

print(int(B*(T//A)))

Solution (Python):
a, b, t = map(int, input().split())
time = 0
cnt = 0
while time + a < (t + 0.5):
    cnt += b
    time += a
print(cnt)

Solution (Python):
def MAP(): return map(int,input().split())

A,B,T = MAP()
print(T//A*B)

Solution (Python):
a, b, t = map(int, input().split())
time = 0
cnt = 0
while time + a < (t + 0.5):
    cnt += b
    time += a
print(cnt)

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

ans = 0
for i in range(A, T + 1, A):
    ans += B

print(ans)

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

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

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

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

Solution (Python):
a, b, t = map(int, input().split())
ans = 0
time = 0
while time + a < t+1:
    ans += b
    time += a
print(ans)

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

Solution (Python):


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

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

Solution (Python):

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

Solution (Python):
A,B,T = list(map(int,input().split()))
print(T//A*B)

Solution (Python):
A, B, T = map(int, input().split())
print(B * (T // A))

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

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

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

print(int((t + 0.5) // a) * b)

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

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

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


num = (T + 0.5) // A
print(int(num * B))

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

print((t//a)*b)

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

Solution (Python):

A, B, T = map(int,input().split())
ans = 0
for i in range(1, T+1):
    if i % A == 0:
        ans = ans + B
    else:
        pass

print(ans)

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

limit = t+0.5
time = a
c = 0
while limit >= time:
  time += a
  c += b
print(c)

Solution (Python):
A,B,T = list(map(int,input().split()))
print(T//A*B)

Solution (Python):
A = list(map(int,input().split()))
print(int((A[2]-A[2]%A[0])/A[0]*A[1]))

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

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

print(T // A * B)

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

print(B * (math.floor(T/A)))

Solution (Python):

"""
Created on Fri Aug 23 13:52:59 2019

@author: gaomi
"""

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

Solution (Python):
A,B,T=map(int,input().split())
print(T//A*B)

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

Solution (Python):
A,B,T = map(int, input().split())
 
print(B * (T//A))

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

sys.setrecursionlimit(1000000)

def main(): 

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



if __name__ == "__main__":
    main()

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

Solution (Python):
def resolve():
    A,B,T = map(int,input().split())
    ans = 0

    while(1):
        T -= A
        if T < 0 :
            break
        ans += B
    print(ans)
resolve()

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

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

Solution (Python):
a, b, t = map(int, input().split())
time = 0
bsc = 0
while 0 == 0:
    time += a
    if time < t + 0.5:
        bsc += b
    else:
        break
print(bsc)

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

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

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

Solution (Python):
import math

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

kai = math.floor(t/a)

print(kai*b)

Solution (Python):
A,B,T = map(int,input().split())
time = 0
bisket = 0

for i in range(1,100000):
    time += A
    if time > T+0.5:
        break
    bisket += B
        
    
print(bisket)

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

Solution (Python):
A, B, T = map(int, input().split())
res = 0
for _ in range(T // A):
  res += B
print(res)

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

mplier = C // A
print(mplier * B)

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

Solution (Python):
a, b, t = map(int, input().split())
if 1 <= a <= 20 and 1 <= b <= 20 and 1 <= t <= 20:
    made = (t + 0.5) // a
    print(int(made * b))
else:
    print('Invalid value')

Solution (Python):


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

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