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

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

Solution (Python):
a,b,c = map(int,input().split(" "))
t = 0
count = 0
while True:
    t += a
    if t > c:
        print(count)
        exit()
    else:
        count += b
print(count)

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

cnt = 0
time_tmp = A
while( time_tmp < (T+0.5) ):
    cnt += 1
    time_tmp += A
print(cnt*B)

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

total=int(t/a)*b

print(total)

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

Solution (Python):


A, B, T = [int(e) for e in input().strip().split()]

ans = (T//A) * B

print(ans)

Solution (Python):
a, b, t = map(int, input().split())
count = 0
time = a
for i in range(1,21):
    if time <= (t+0.5):
        time = a*(i+1)
        count += b
    else:
        break
print(count)

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

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

Solution (Python):
list = input().split()
A = int(list[0])
B = int(list[1])
T = int(list[2])+0.5
now = 0
Biscuit = 0

while True:
    now += A
    if now <= T:
        Biscuit += B
    else:
        break

print(Biscuit)

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

Solution (Python):

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

Solution (Python):

import numpy as np
A, B, T = map(int, input().split())

x = int(np.floor((T + 0.5) / A))

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

Solution (Python):
a, b, c = (int(_) for _ in input().split())  

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

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

Solution (Python):
A, B, T = list(map(int, input().split()))
print(int((T + 0.5) / 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 = [int(x) for x in input().split()]

S = 0

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

print(S)

Solution (Python):


def biscuit():
    a, b, t = map(int, input().split())
    sheets = 0
    for i in range(a, t+1, a):
        sheets = sheets + b
    print(sheets)


if __name__ == "__main__":
    biscuit()

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


result = T//i*j
print (result)

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

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

cookie=int(((T+0.5)//A)*B)

print(cookie)

Solution (Python):
aa, bb, tt = map(int, input().split())
nn = int((tt+0.5)/aa)
print(bb*nn)

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

Solution (Python):

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

print(count)

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

Solution (Python):


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

x = b * (t // a)
print(x)

Solution (Python):
def main() -> None:
    A, B, T = map(int, input().split())
    print((T // A) * B)


if __name__ == '__main__':
    main()

Solution (Python):
a,b,t = [int(i) for i in 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, c = map(int, input().split())
print(math.floor(c / 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())

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(" "))
if A>T:
    print(0)
else:
    count = (T-T%A)/A
    ans = B * count
    print(int(ans))

Solution (Python):
def main():

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

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

    print(int(ans))


if __name__ == "__main__":
    main()

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

while True:
    time += A
    if time > T:
        break
    count += B
print(count)

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

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

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

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

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

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

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

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

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

Solution (Python):
A,B,T=(int(x) for x in input().split())
if (T+0.5 > A):
    sum=(int(T/A))*B
else:
    sum=0
print(sum)

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())
num=(T+0.5)//A
print(int(num*B))

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

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

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

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

Solution (Python):

A,B,T=(int(x) for x in input().split())


y=(T+0.5)/A

z=B*int(y)

print(z)

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

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

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

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

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

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

print(result)

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

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):
import sys
import math
input = sys.stdin.readline

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

Solution (Python):
from math import floor
import unittest


class BiscuitGenerator:
    def __init__(self, product_count, interval_sec):
        self.product_count = product_count
        self.interval_sec = interval_sec

    def product(self, second):
        return self.product_count * floor(second / self.interval_sec)


def parse_argument(input):
    args = [int(arg) for arg in input.split(" ")]
    return args


def main(input):
    args = parse_argument(input)
    generator = BiscuitGenerator(interval_sec=args[0], product_count=args[1])
    print(generator.product(args[2]))


if __name__ == "__main__":
    main(input())

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,c = map(int,input().split())
d = int(c/a)
print(d*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):
[print(int((t+0.5)//a)*b)for a,b,t in[[int(i)for i in input().split()]]]

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

print((t//a)*b)

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

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

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

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

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

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

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

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

Solution (Python):
data = input()
list = data.split(' ')
result = 0
for i in range(int(list[2])//int(list[0])):
  result += int(list[1])
print(result)

Solution (Python):
in_str = input()
str_num = in_str.split()
num = []
for i in range(3):
    num.append(int(str_num[i]))

bis = 0
i = 1

while True:
    if num[0] * i > num[2] + 0.5:
        break
    bis += num[1]
    i += 1

print(bis)

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

Solution (Python):
A, B, C = [int(i) for i in 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 = [int(x) for x in input().strip().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())
p = t // a
print(b*p)

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

Solution (Python):

from sys import stdin




s_in = lambda: stdin.readline()[:-1]  
d_in = lambda: int(stdin.readline())  
ds_in = lambda: list(map(int, stdin.readline().split()))  


A, B, T = ds_in()

print(B * (T//A))

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

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

T = float(data[2]) + 0.5
A = int(data[0])
B = int(data[1])

times = int(T // A)
print(times * 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 = 0
T += 0.5

while T > A:
    T -= 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(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())
n = int((t + 0.5) // a)
print(n * b)

Solution (Python):




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

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

print(count)

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

count  = int(t/a)

bis = count * b

print(bis)

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

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

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

print(B * (T // A))

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

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

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

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

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

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

print(ans)

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

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

for i in range (P+1):
    cookle = B*i

print(cookle)

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

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

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

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

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

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

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

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

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

Solution (Python):
from sys import exit

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

ans = 0

_A = A

while _A < T + 0.5:
    ans += B
    _A += A

print(ans)

Solution (Python):

[A,B,T] = list(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(((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 = [int(i) for i in input().split()]
print(t // a * b)

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

Solution (Python):
a, b, t = map(int, input().split())
cnt = 0
for i in range(1, 100):
    if a * i > t + 0.5:
        break
    cnt += b
print(cnt)

Solution (Python):


a,b,t=map(int,input().split(" "))
t+=0.5
ans=0
if(t>a):
    ans=(t-t%a)/a*b
print(round(ans))

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

print(B*(T//A))

Solution (Python):
import sys
import subprocess
import re
import datetime
import os


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

print(ans)

Solution (Python):

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


p = int((t+0.5)//a)

ans = p*b

print(ans)

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

Solution (Python):
input_str = input().split(" ")
input_int = list(map(int, input_str))
A = input_int[0]
B = input_int[1]
T = input_int[2]

bis_sum = 0
start = 0
end = A
while True:
    if start < T+0.5 and end > T+0.5:
        break
    start += A
    end += A
    bis_sum += B

print(bis_sum)

Solution (Python):
a, b, t = map(int, input().split())
cnt = 0
temp = a
while t+0.5 > temp:
    cnt += 1
    temp += a
print(b*cnt)

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

Solution (Python):

import sys


def solve(A: int, B: int, T: int):
    ret = (T // A) * B
    print(ret)
    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())
count=0
while T>=A:
	T=T-A
	count+=1
print(count*B)

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

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

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

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

print(B*(T//A))

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

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

i = 0
t += 0.5
while 1:
  t -= a
  if t < 0:
    break
  i += 1

i *= b
print(i)

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

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

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

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

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

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

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

count = int(c/a)

print(count*b)

Solution (Python):
A,B,T = map(int, input().strip().split(' '))
print((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())

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

Solution (Python):



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

print(int(T/A)*B)

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

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

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

Solution (Python):
from math import floor


inputData = input().split()

A = int(inputData[0])

B = int(inputData[1])

T = int(inputData[2])


prodCount = int(floor((float(T) + 0.5) // float(A)))
biscuitTotal = prodCount * B


print(biscuitTotal)

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

Solution (Python):
import sys
import math 
ni = lambda: int(ns())
na = lambda: list(map(int, input().split()))
ns = lambda: input()

A,B,T = na()

n = T//A

print(B*n)

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

print((t//a)*b)

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

ans = (t // a) * b if t // a >= 1 else 0
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):
import sys
a, b, t = map(int, sys.stdin.readline().split())
print((t//a) * b)

Solution (Python):


import sys
import copy

sys.setrecursionlimit(1000000)





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

Solution (Python):
from sys import stdin

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

print((T // A) * B)

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


if __name__ == "__main__":
    main()

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

Solution (Python):
import math

A, B, T = [int(s) for s in input().split(" ")]

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

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

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

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

count = T // A
bsc = B * count

print(bsc)

Solution (Python):


import sys
import math



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

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

Solution (Python):
a,b,t = map(int, (input()).split(" "))
n = t//a
print("{}".format(n*b,'d'))

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

while time <= T:
    bis += B
    time += A

print(bis)

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

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

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

Solution (Python):
a, b, t = map(int, input().split())
i = 1
num = 0
while i <= t:
    if i % a == 0:
        num += b
    i += 1

print(num)

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

Solution (Python):
if __name__ == '__main__':
    line = input()
    [A, B, T] = map(int, line.rstrip().split())

    print(T // A * B)

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

Solution (Python):


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

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

Solution (Python):
import sys 
A, B, T = list(map(int, sys.stdin.readline().strip().split()))
print(T // A * B)

Solution (Python):
a,b,t = map(int,input().split())
 
nums = range(1,21,1)
nums = list(map(lambda x: x * a, nums))
 
nums.append(t+0.5)
print(sorted(nums).index(t+0.5) * b)

Solution (Python):
s= 0
A,B,T=map(int,input().split())
for i in range(T//A):
  s+=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())
print(B * int(T / A))

Solution (Python):
def get_result(A, B, T):
    return (T//A)*B

A, B, T = [int(s) for s in input().split(" ")]
result = get_result(A, B, T)
print(result )

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

print(T//A * B)

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

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

Solution (Python):

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

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

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

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

Solution (Python):

s=raw_input().split()
a=int(s[0])
b=int(s[1])
t=int(s[2])

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

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

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

times = (T + 0.5) // A
result = int(B * times)

print(result)

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

c = c + 0.5

d = c // a

print(int(b * d))

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

times = (T + 0.5) // A
result = int(B * times)

print(result)

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

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

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):
A, B, T = [int(i) for i in input().split()]
print(T // A * B)

Solution (Python):
def biscuit_generator(A: int, B: int, T: int)->int:
    return (T//A) * B


if __name__ == "__main__":
    A, B, T = map(int, input().split())
    ans = biscuit_generator(A, B, T)
    print(ans)

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

def calc_biscuit(A, B, T):
  	return int((T+0.5) /A)*B
    
print(calc_biscuit(A, B, T))

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

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

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

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

N = (T_ + 0.5)//A_
X = int(N*B_)
print(X)

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

def ria(sep = ''):
    if sep == '' :
        return list(map(int, input().split())) 
    else: return list(map(int, input().split(sep)))
def rsa(sep = ''):
    if sep == '' :
        return input().split() 
    else: return input().split(sep)
def ri(): return int(input())
def rd(): return float(input())
def rs(): return input()




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

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

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

Solution (Python):

import bisect
import heapq
import math
import random
import sys
from collections import Counter, defaultdict, deque
from decimal import ROUND_CEILING, ROUND_HALF_UP, Decimal
from functools import lru_cache, reduce
from itertools import combinations, combinations_with_replacement, product, permutations
from operator import add, mul, sub

sys.setrecursionlimit(100000)


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


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


def read_float():
    return float(input())


def read_float_n():
    return list(map(float, input().split()))


def read_str():
    return input().strip()


def read_str_n():
    return list(map(str, input().split()))


def error_print(*args):
    print(*args, file=sys.stderr)


def mt(f):
    import time

    def wrap(*args, **kwargs):
        s = time.time()
        ret = f(*args, **kwargs)
        e = time.time()

        error_print(e - s, 'sec')
        return ret

    return wrap


@mt
def slv(A, B, T):
    return B * (T//A)


def main():
    A, B, T = read_int_n()
    print(slv(A, B, T))


if __name__ == '__main__':
    main()

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

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(max(t//a*b,0))

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

Solution (Python):
if __name__ == "__main__":
    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):
s = input()
a, b, t = s.split()
a = int(a)
b = int(b)
t = int(t)
n = int((t + 0.5) / a)
ans = n * b
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()))
print(int(t/a)*b)

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

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

Solution (Python):
a, b,T = list(map(int, input().split()))
result = 0

for i , t in enumerate(range(200)):
    if i == 0 :
        continue;
    if i * a > T :
        break;
    result += b;

print(result)

Solution (Python):
a, b, t = list(map(int, input().split()))
print(sum([b for _ in range(a, t+1, a)]))

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

p=time*b
print(p)

Solution (Python):
a,b,t = (int(i) for i in input().split())
d = a
c = 0
if a>t :
    print(0)
else:
    while d<=t + 0.5:
        c = c + b
        d = d + a
    print(c)

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

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

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

print(calc)

Solution (Python):

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

print("{}".format(d * b))

Solution (Python):
import sys
from collections import deque
import copy
import math
def get_read_func(fileobject):
    if fileobject == None :
        return raw_input
    else:
        return fileobject.readline



def main():
    if len(sys.argv) > 1:
        f = open(sys.argv[1])
    else:
        f = None
    read_func = get_read_func(f);
    input_raw = read_func().strip().split()
    [A, B, T] = [int(input_raw[0]), int(input_raw[1]), int(input_raw[2])]
    print (T/A) * B

if __name__ == '__main__':
    main()

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

for i in range(1,t+1):
    an = a * i
    
    if an > t + 0.5:
        break
    count += 1
    

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

Solution (Python):
input = input()
sp_input = input.split(" ")
A = int(sp_input[0])
B = int(sp_input[1])
T = int(sp_input[2]) + 0.5
a = A

ret = 0
i = B
while a <= T:
  ret += B
  a += A

print(ret)

Solution (Python):
i=list(map(int,input().split()))
a=i[2]+0.5
b=a//i[0]
c=b*i[1]
d=int(c)
print(d)

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

Solution (Python):
import math

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

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

Solution (Python):
C = list(map(float,input().split()))
c = C[0]
T = C[2]+0.5
Bis = 0
while(c<T):
      Bis += C[1]
      c += C[0]

print(int(Bis))