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 = list(map(int,input().split()))

bis = t + 0.5
sum = 0
while bis >= a:
    bis -= a
    sum += b
print(sum)

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((t+0.5)//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(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())
k = 1
total = 0
while k*a <= t + 0.5:
    total += b
    k += 1
print(total)

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

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


abc()

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())
print((t//a)*b)

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

print(ans)

Solution (Python):
n1, n2, n3 = [int(i) for i in input().split()]

s1 = n2 * (n3 // n1)
print(s1)

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

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

def main(A,B,T):
    sum = B*(math.floor(T/A))
    print(sum)
    return 0

main(A,B,T)

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

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

number = round(((T+0.5)//A)*B)

print(number)

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

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

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

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

Solution (Python):
a,b,t=map(int,input().split())
print(b*int(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(B*(T//A))

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

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

print(int((t-(t%a))/a*b))

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):
A, B, T = map(int, input().split())
print((T // A) * B)

Solution (Python):



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

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

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

kosuu = math.floor((t + 0.5) / a)
ans = b * kosuu
print(ans)

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

Solution (Python):

from sys import stdin


def main():
    A, B, T = [int(x) for x in stdin.readline().split()]

    print(T // A * B)


if __name__ == "__main__":
    main()

Solution (Python):
from sys import stdin


def main():
    A, B, T = [int(x) for x in stdin.readline().split()]

    print((T // A * B))


if __name__ == "__main__":
    main()

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

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

Solution (Python):
nums = [int(e) for e in input().split()]

a = nums[0]
b = nums[1]
t = nums[2]

ans = 0

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

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

A = int(A)
B = int(B)
T = int(T)

time = A
ans = 0

while T >= time :
    ans += B
    time += A

print (ans)

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

time = A
res = 0
while time <= T + 0.5:
    res += B
    time += A

print(res)

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())
ans = 0
t = int(A)
while t <= T+0.5:
  ans += B
  t += A
print(ans)

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

c=0
limit=0
while(limit<T+0.5):
    c+=B
    limit+=A
    

print(c-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
'''
allinputs = iter(input().splitlines())
input = lambda : next(allinputs)


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

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

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

print((T//A)*B)

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

i=1
sum=0
while i*a <= t+0.5:
    sum+=b
    i+=1
print(sum)

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


print(int(B* int((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())

time=t//a

print(time*b)

Solution (Python):

"""
Created on Thu May 30 18:00:51 2019

@author: またの
"""

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

C = int((T + 1/2)//A)
ans = B*C

print(ans)

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

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

print(sum)

Solution (Python):
import math

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

if isinstance(A,int) and isinstance(B,int) and isinstance(T,int) :
    num_biscuit=0
    if 1<=A<=20 and 1<=B<=20 and 1<=T<=20:
        for i in range(math.floor(T/A)):
            num_biscuit=num_biscuit+B
        print(num_biscuit)
    
    

else :
    print("ERROR")
    exit()

Solution (Python):
def solve(a, b, t):
    return t // a * b


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


main()

Solution (Python):

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

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

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

Solution (Python):
a, b, t = list(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())
X = T // A * B
print(X)

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

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

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

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

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

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

t = A
b = 0
while t <= T:
  b += B
  t += A
  
print(b)

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

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

print(ans)

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

print(T//A*B)

Solution (Python):
ABT = input().split()
A = int(ABT[0])
B = int(ABT[1])
T = int(ABT[2])
s = ((T + 0.5) // A) * B
print(int(s))

Solution (Python):
def add(A,B,T):
  C=T//A
  return C*B
  
a=list(map(int,input().split()))
print(add(a[0],a[1],a[2]))

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 numpy as np
import math
import copy

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

print(b * math.floor(((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(T // A * B)

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

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

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

print((T // A)*B)

Solution (Python):
import sys
input = sys.stdin.readline
import math
'''
allinputs = iter(input().splitlines())
input = lambda : next(allinputs)


a, b, t = map(int, input().split())
time = float(t) + 0.5
s = math.floor(time / a)
ans = s * b
print(ans)

Solution (Python):
A, B, T = map(int, input().split())
for x in range(1, 21):
    if (x*A < T+0.5) & ((x+1)*A > T+0.5):
        print(B*x)
        break
    elif x*A > T+0.5:
        print(0)
        break

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

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

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

Solution (Python):
A, B, T  =  (int(_) for _ in input().split())
ans = (T + 0.5) // A
ans = int(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())

if a > t:
    print(0)
else:
    n = 1
    while (a * n) <= t:
        n += 1
    print(b * (n-1))

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

Solution (Python):
a, b, t = (int(_) for _ in input().split())
c = a
sum = 0
i = 1
while a < t+0.5:
    sum += b
    i += 1
    a = i * c

print(sum)

Solution (Python):
import math

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

freq = math.floor(((T+0.5)/A))
print(B*freq)

Solution (Python):
A, B, T = map(int, raw_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 = list(map(int, input().split()))
    print(b * (t // a))

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

print(int(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())
ans =0
for i in range(A,T+1,A):
    ans += B
print(ans)

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

sum=(t+0.5)//a*b
list=[0,int(sum)]
print(max(list))

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 = input().split()
biscuit = 0
for i in range(1, int(T)+1):
    if(i % int(A) == 0):
        biscuit += int(B)
print(biscuit)

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(" "))
count=0
tt=0
while tt<=t+0.5:
  count=count+1
  tt=tt+a
print(b*(count-1))

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())
times = T//A
print(B*times)

Solution (Python):
A,B,T = [int(s) for s in input().split(' ')]
next_product = A
times = 2
biscuits = 0

while next_product <= T:
    biscuits += B
    next_product = A*times
    times += 1

print(biscuits)

Solution (Python):
inputABT = input().split()     


a = float(inputABT[0])
b = inputABT[1]
t = float(inputABT[2])


end =  t + 0.5    
second = 1    
biscuit = 0    

while second * int(a) < end:    
    second += 1
    biscuit += int(b)


print(biscuit)

Solution (Python):
inputABT = input().split()
a = float(inputABT[0])
b = inputABT[1]
t = float(inputABT[2])

end =  t + 0.5
n = 1
bisket = 0

while n * int(a) < end:
    n = n + 1

    bisket = bisket + int(b)


print(bisket)

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

t = T + 0.5
bisket = t // A * B

print(int(bisket))

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

total = 0

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

Solution (Python):
input1 = input().split()
a = input1[0]
b = input1[1]
t = input1[2]
a = float(a)
b = float(b)
t = float(t)
total = 0 
T = t + 0.5 

T -= a
while T > 0:
    total += b
    T -= a

total = int(total)

print(total)

Solution (Python):
Bisket = input().split()
A = Bisket[0]
B = Bisket[1]
T = Bisket[2]
a = int(A)
b = int(B)
t = int(T)

print(t//a*b)

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

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

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

if a > t+0.5 : 
	print("0")
else :
	n = (t+0.5)/a
	print(int(n)*b)

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

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

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

Solution (Python):
a, b, t = map(int,input().split())
i = 1
bisket = 0

while t+0.5 > i*a:
    bisket += b
    i += 1

print(bisket)

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

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):
import math

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

print(math.floor(t / a) * b)

Solution (Python):
li = input().split()
li = [int(s) for s in li]

print(li[1]*(li[2]//li[0]))

Solution (Python):


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

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):
import sys

def main():
    input = sys.stdin.readline
    A, B, T= map(int, input().split())
    
    print(T // A * B)
    
if __name__ == '__main__':
    main()

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

print(B * (T // A))

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

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

Solution (Python):
from sys import stdin

A, B, T = [int(x) for x in stdin.readline().rstrip().split()]
i = A
bis = 0
while(i<T+0.5):
	i = i + A
	bis = bis + B
print(bis)

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


time = 0
count = 0
while time < t + 0.5:
    if time % a == 0:
        count += b
    time += 1
print(count - b)

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

A = i[0]
B = i[1]
T = i[2]

timeElapsed = 0
limit = T + 0.5
biscuitCount = 0 

for i in range(1, T+1):
    if(A*i <= limit):
        biscuitCount+=1
    else:
        break

print(biscuitCount * B)

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

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

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

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

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

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

Solution (Python):
import math

a, b, c = input().split()
a, b, c = int(a), int(b), int(c)


d = math.floor(c/a) 
print(b*d)

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

Solution (Python):
import math

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

if __name__ == '__main__':
    main()

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

print(int(t / 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(b * int((t + 0.5) / a))

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

def biscuit_gen(A,B,T):
    total = 0
    num = int(T//A)
    return B*num

n = biscuit_gen(A,B,T)
print(n)

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

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

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

Solution (Python):
import math
inp = input()
inp = inp.split()
inp = list(map(int, inp))
a = inp[0]
b = inp[1]
t = inp[2]
ans = math.floor(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 = list(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):
import math

def sub():
    A, B, T = [int(e) for e in input().split(" ")]
    k = math.floor(math.floor(T) / A)
    print("{}".format(int(k) * B))

sub()

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

q=(t+0.5)/a

f=int(q)*b
print(int(f))

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

Solution (Python):


def problem():
    A, B, T = map(int, input().split())
    print(algorithm(A, B, T))


def algorithm(A: int, B: int, T: int):
    x = int((T + 0.5) / A)
    return x*B



problem()

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

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

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(T/A)*B)

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

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

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

a = abt[0]
b = abt[1]
t = abt[2]

t05 = t + 0.5
times = t05 // a

total = b * times

print(str(int(total)))

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 = float(T) + 0.5

print(int(t/A) * B)

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

Solution (Python):
from functools import reduce
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):
args = input()
args = args.split(' ')

a = int(args[0])
b = int(args[1])
t = int(args[2]) + 0.5 - a

r = 0

while t > 0:
    r += b
    t -= a

print(r)

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

print(T // A * B)

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

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

a = l[0]
b = l[1]
t = l[2]



seisan = 0

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

print(seisan)

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())
reward=0
time=0

for t in range(T):
    time += 1
    if time%A == 0:
        reward = reward + B
        
print(reward)

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

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

time = 0
biscuit = 0

time +=  a
while time < t + 0.5 :
    biscuit += b
    time += a

print(biscuit)

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

import sys


def solve(A: int, B: int, T: int):
    print(T // A * B)
    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):
S = input()



[A,B,T] = map(int,S.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(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(t//a*b))

Solution (Python):
n = input()
args = n.split()

a = int(args[0])
b = int(args[1])
t = int(args[2])

c = int(t / a)

print(c * 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 
cnt = 1 

while cnt * A <= T + 0.5:
    ans += B
    cnt += 1

print(ans)

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

Solution (Python):
A,B,T = map(int,input().split())
biscuit = 0
for i in range(1,T+1):
    if (biscuit//B+1)*A==i:
        biscuit = biscuit + B

print(biscuit)

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(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(T/A)*B)

Solution (Python):
A, B, T = (int(x) for x in input().split())
print(int(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(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())
x = int((t+0.5) // a)
print(x*b)

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

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

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

Biscuit()

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

Solution (Python):

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

print(int(((l[2] + 0.5) // l[0]) * l[1]))

Solution (Python):

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

print(B * (T // A))

Solution (Python):
import sys

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

A, B, T = LI()

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(b*int(t//a))

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

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

Solution (Python):
import sys

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

i = 0
while True:
    if (i*A > T+0.5):
        break
    else:
        i += 1

print(B*(i-1))

Solution (Python):


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

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):
first = input()
(sA, sB, sC) = first.split()
A = int(sA)
B = int(sB)
C = int(sC)
D = C//A
E = B*D
print(E)

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

Solution (Python):



'''
Result: All Correct
Score: 100
Code length: 91 Byte
Execution Time: 17 ms
Memory usage: 2940 KB
'''

hoge = input()
a, b, t = [int(x) for x in hoge.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(t//a*b)

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

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

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

t = int(t+0.5)

x = int(t/a)

print(x*b)

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

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

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

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

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

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

rest = t
biscuit = 0
plustime = 1

while rest >= a * plustime:
    biscuit = biscuit + b
    plustime += 1

print(biscuit)

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

count = int(t//a)
ans = count * b
print(ans)

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):
In=map(int,raw_input().split())

A=int(In[0])
B=int(In[1])
T=int(In[2])

count=0

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

print count

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

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

if __name__ == '__main__':
    main()

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=input().split()
A=int(A)
B=int(B)
T=int(T)
print(T//A*B)

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

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

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,c=map(int,input().split())
print(int((c//a)*b))

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

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

a = l[1] * int((l[2]+0.5)/l[0])
print(a)

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

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

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

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

Solution (Python):
import math

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

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

Solution (Python):
a, b , c = map(int,input ().split())
time = 0
bis = 0
while c > time:
  time += 1

  if time % a == 0:
    bis = b + bis
    
print(bis)

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())
 
count =  T // A * B
 
print(count)

Solution (Python):
A, B, T = map(int, input().split())
for i in range(200):
    if A * i < (T + 0.5):
        continue
    else:
        print(B * (i - 1))
        break

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

print((c//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):
import math
a,b,t = map(int, input().split())
print(math.floor( t/ a) * b)

Solution (Python):
from sys import stdin


def main():
    A, B, T = [int(x) for x in stdin.readline().rstrip().split()]
    print(T // A * B)


if __name__ == "__main__":
    main()

Solution (Python):
A, B, T = list(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 = input().split()

num_A = int(input_list[0])
num_B = int(input_list[1])
num_T = int(input_list[2])


output_answer = int((num_T + 0.5) // num_A * num_B)
print(output_answer)

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

shou = T // A

print(shou * B)

Solution (Python):
str = input().split()
A = int(str[0])
B = int(str[1])
T = int(str[2])

time = T + 0.5
biscuits = (time //   A) * B

print(int(biscuits))

Solution (Python):

"""
A - Biscuit Generator
https://atcoder.jp/contests/abc125/tasks/abc125_a

"""
import sys


def solve(A, B, T):
    gen = [t for t in range(1, T+1) if t % A == 0]
    return B * len(gen)


def main(args):
    A, B, T = map(int, input().split())
    ans = solve(A, B, T)
    print(ans)


if __name__ == '__main__':
    main(sys.argv[1:])

Solution (Python):
A, B, T = map(int, input().split())
ans = 0
for i in range(1, 22):
    if A * i <= T + 0.5:
        ans += B
    else:
        print(ans)
        break

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

print( B * ( T // A))

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

Solution (Python):
data = input().split()
A = int(data[0])
B = int(data[1])
T = int(data[2]) + 0.5
biscuit = 0
time = A
while time < T:
  biscuit += B
  time += A

print(biscuit)

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

Solution (Python):

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

t2 = t + 0.5

print(int(t2//a * b))

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

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

print((t//a)*b)

Solution (Python):
A,B,T=map(int,input().split())
S=0
n=0
while T+0.5>S:
  n+=1
  S=n*A
print((n-1)*B)

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

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

Solution (Python):

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

Solution (Python):
import math

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

maisu = math.floor(T/A) * B

print(maisu)

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

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

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

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