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=list(map(int,input().split()))
b=0
c=1
while(c*a[0]<(a[2]+0.5)):
  b=b+a[1]
  c=c+1
  
print(b)

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


if __name__ == "__main__":
    val = [int(x) for x in input().split(" ")]
    print(calculate(val[0], val[1], val[2]))

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

V=(C//A)*B

print(int(V))

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

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

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

Solution (Python):
src = raw_input()

sp = src.split(" ")

A = int(sp[0])
B = int(sp[1])
T = int(sp[2])
cnt = int(int(T + 0.5) / A )

out = B * cnt
print(out)

Solution (Python):






(a, b, t) = [ int(v) for v in input().split() ]
if t > 20: raise("limit over")
biscuit = int(((t + 0.5) // a) * b)
print(biscuit)

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

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

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

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

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

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

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

Solution (Python):
minit, value, time = map(int, input().split())
print((time//minit)*value)

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

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

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


import sys
input = sys.stdin.readline

def io_generator():
	return input()



def main(io):
	a,b,t= map(int, io().split())
	return (t // a)*b



if __name__ == "__main__":
	io= lambda : io_generator()
	print (main(io))

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

Solution (Python):
import math
s = input().split()

A=int(s[0])
B=int(s[1])
C=int(s[2])

tmp=C/A
answer = math.floor(tmp) *B
print(answer)

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

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

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

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

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

Solution (Python):
abt = input()
abt = list(map(int, abt.split(" ")))
output = (abt[2] + 0.5 ) //  abt[0] * abt[1]
print(int(output))

Solution (Python):
abt = input()
abt = list(map(int, abt.split(" ")))
output = (abt[2] + 0.5 ) //  abt[0] * abt[1]
print(int(output))

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

Solution (Python):
A,B,T = map(int,input().split())
a =T//A
number = 0
for i in range(a):
  b=1
  s = a-b
  if s >=0:
    number+=1
  b+=1
print(number*B)

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

Solution (Python):
[A, B, T] = map(int, raw_input().split())
biscuits = 0
time = 0
while time < (T + 0.5 - A):
  biscuits = biscuits + B
  time = time + A
print biscuits

Solution (Python):
biscuit_data = list(map(int,input().split()))
biscuit_data[2] += 0.5
biscuit_num = 0
while(biscuit_data[2]-biscuit_data[0]>0):
    biscuit_num += biscuit_data[1]
    biscuit_data[2] -= biscuit_data[0]

print(biscuit_num)

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

Solution (Python):
'''input
20 20 19
'''

a, b, t=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())

N = 1
for i in range(100):
    if N * A > T + 0.5:
        N -= 1
        break

    N += 1

ret = N * B
print(ret)

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

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

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

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

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

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

Solution (Python):

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

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):
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):
interval, volume, endtime = (map(int, input().split()))
makes = int(endtime / interval)

print(makes * volume)

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

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

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

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

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

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

print(T//A  * B)

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

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

count = T // A
 
 

ans = count * B

if ans == 0:
    print("0")
else:
    print(ans)

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

answer =  (T // A) * B

print(answer)

Solution (Python):
tmp = raw_input().split()
A = int(tmp[0])
B = int(tmp[1])
T = int(tmp[2])
print(int(((T+0.5)//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())

times = t // a

print(b * times)

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, int(T/A) + 1):
    ans += 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(" "))

n=(T//A)

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

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

time = A
cookies = 0

mult = 1

while time < T+0.5:
    
    cookies += B
    
    mult += 1
    time = mult*A

print(cookies)

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

Solution (Python):

def get_next_ints(delim=" "):
    return tuple([int(float(x)) for x in input().split(delim)])

def main():
    a, b, t = get_next_ints()
    
    n = t // a
    print(n * b)
    
if __name__ == '__main__':
    main()

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

Solution (Python):
l = raw_input().split()
a = int(l[0])
b = int(l[1])
t = int(l[2])
i = 1
sum = 0

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

print(sum)

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

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

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

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

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

i=1
while i*A<T+0.5:
    i+=1

S = B*(i-1)
print(S)

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

print(T // A * B)

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

Solution (Python):
a=input().split()
t=int(a[2])+0.5
print(int(t//int(a[0])*int(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 = [int(i) for i in input().split()]

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

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

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

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())
cookie = 0
time = a
while time <= t + 0.5:
    cookie += b
    time += a
print(cookie)

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

while a * g <= t:
  c += b
  g += 1

print(c)

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

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

Solution (Python):
from sys import stdin

def calc(data):
    sum = 0
    current_time = int(data[0])
    counter = 1
    while current_time < int(data[2]) + 0.5:
        sum += int(data[1])
        counter += 1
        current_time = int(data[0]) * counter
    return sum

if __name__ == '__main__':
    input = stdin.readline().rstrip()
    input_array = input.split(" ")
    print calc(input_array)

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

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

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

Solution (Python):


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

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

count = 0
bisket = 0

while True:

    count += 1
    if A*count > T+0.5:
        break
    else:
        bisket += B


print(bisket)

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

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

answer = (i[2] // i[0]) * i[1]
print(answer)

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

Solution (Python):
import importlib
import_module = lambda name:importlib.import_module(name)

input = import_module('sys').stdin.readline
input_int = lambda:int(input())
input_ints = lambda:map(int,input().split())
input_ints_list = lambda:list(input_ints())
input_str = lambda:input()
input_strs = lambda:input().split()
input_lines = lambda n,f:[f() for _ in range(n)]

gcd_base = lambda a,b:import_module('fractions').gcd(a,b) 
gcd = lambda a:import_module('functools').reduce(gcd_base,a) 
lcm_base = lambda a,b:(a*b)//import_module('fractions').gcd(a,b) 
lcm = lambda a:import_module('functools').reduce(lcm_base,a,1) 

permutations = lambda a,n:import_module('itertools').permutations(a,n) 
combinations = lambda a,n:import_module('itertools').combinations(a,n) 
product = lambda a,b:import_module('itertools').product(a,b) 

init_array_1dim = lambda v,n:[v]*n
init_array_2dim = lambda v,n,m:[init_array_1dim for _ in range(m)]


ceil = lambda a:import_module('math').ceil(a) 
floor = lambda a:import_module('math').floor(a) 


convert_list_to_queue = lambda a:import_module('collections').deque(a)
pop_q = lambda a:a.popleft()
push_q = lambda a,e:a.appendleft(e)
push_q_list = lambda a,l:a.extendleft(l) 


def init_head(a):import_module('heapq').heapify(a)
def heap_push(a,v):import_module('heapq').heappush(a,v)
heap_pop = lambda a:import_module('heapq').heappop(a) 


bisect_left = lambda a,x:import_module('bisect').bisect_left(a,x)
bisect_right = lambda a,x:import_module('bisect').bisect_left(a,x)
insert_left = lambda a,x:import_module('bisect').insert_left(a,bisect_left(a,x))
insert_right = lambda a,x:import_module('bisect').insert_right(a,bisect_right(a,x))


cumsum = lambda a:import_module('numpy').cumsum(import_module('numpy').array(a)) 
cumprod = lambda a:import_module('numpy').cumprod(import_module('numpy').array(a)) 
cumgcd = lambda a:import_module('numpy').frompyfunc(gcd, 2, 1).accumulate(a, dtype=import_module('numpy').object).astype(import_module('numpy').int) 

class UnionFind(object):
    def __init__(self, n):
        self.par = [i for i in range(n)]
        self.rank = [0 for _ in range(n)]
        self.size = [1 for _ in range(n)]

    def find(self, x):
        if self.par[x] == x:
            return x
        else:
            self.par[x] = self.find(self.par[x])
            return self.par[x]

    def union(self, x, y):
        x = self.find(x)
        y = self.find(y)
        if x != y:
            if self.rank[x] < self.rank[y]:
                x, y = y, x
            if self.rank[x] == self.rank[y]:
                self.rank[x] += 1
            self.par[y] = x
            self.size[x] += self.size[y]

    def is_same(self, x, y):
        return self.find(x) == self.find(y)

    def get_size(self, x):
        x = self.find(x)
        return self.size[x]


def dfs_graph(v,n,graph,visited):
    if all(visited):return 1 
    ans = 0
    for i in range(n):
        if not graph[v][i]:continue 
        if visited[i]:continue 
        visited[i] = True
        ans += dfs_graph(i,n,graph,visited)
        visited[i] = False
    return ans


def warshall_floyd(n,graph):
    d = init_array_2dim(float("inf"),n,n)
    
    for i in range(n):
        d[i][i] = 0
        for j in range(n):
            if graph[i][j]:d[i][j] = 1
    
    for k in range(n):
        for i in range(n):
            for j in range(n):
                d[i][j] = min(d[i][j],d[i][k] + d[k][j])
    return d


def init_graph(n,a,directed=False):
    visited = init_array_1dim(False,n)
    graph = init_array_2dim(False,n,n)
    for e in a:
        graph[e[0]-1][e[1]-1] = True
        if not directed:graph[e[1]-1][e[0]-1] = True 
    return visited,graph

def two_pointers(s,threshold,ope='sum'):
    l,r = 0,0
    base = 0 
    if ope == 'sum':base = 0
    if ope == 'prd':base = 1
    diff = 0
    while r < len(s):
        val = 0
        if ope == 'sum':val = base+s[r]
        if ope == 'prd':val = base*s[r]
        if val <= threshold:
            if ope == 'sum':base += s[r]
            if ope == 'prd':base *= s[r]
            diff = max(diff, r-l+1)
            r += 1
        elif l == r:
            r += 1
            l += 1
        else:
            if ope == 'sum':base -= s[l]
            if ope == 'prd':base //= s[l]
            l += 1
    return diff

def solution():
    
    A,B,T = input_ints()
    print((T//A)*B)
	
if __name__ == '__main__':
    solution()

Solution (Python):


data = input().split(" ")
during = int(data[0])
makes = int(data[1])
times = int(data[2])

work = times // during * makes

print(work)

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):
loop, kosu, time = map(int, input().split(" "))
print(kosu * (time//loop))

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

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

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

t=1
b=0
while t<T+0.5:

    if(t%A==0):
        b = b + B
    
    t = t + 1

print(b)

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

Solution (Python):
def count_sum_generated_biscuit():
  generation_interval_sec,\
  biscuit_per_generation,\
  initial_target_sec = [int(x) for x in input().split()]
  
  target_sec = initial_target_sec + 0.5
  sum_generated_biscuit\
  = (target_sec // generation_interval_sec) * biscuit_per_generation
  
  return int(sum_generated_biscuit)
  
if __name__ == '__main__':
  print(count_sum_generated_biscuit())

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

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

Solution (Python):
a,b,t=map(int,input().split())
i=1
while i*a<t+0.5:
  i+=1
print((i-1)*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()))

time = T + 0.5

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

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

Solution (Python):

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

biscuit = 0

for i in range(A * 10, T*10 + 5, A * 10):
    biscuit += B

print(biscuit)

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

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

Solution (Python):
import sys
a, b, t = map(int, sys.stdin.readline().split())
total = 0
a_i = a
for i in range(1, t + 1, 1):
  if a_i <= i:
    total += b
    a_i = a_i + a
print(total)

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

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

Solution (Python):
ABC = input().rstrip().split(" ")
A = int(ABC[0])
B = int(ABC[1])
C = int(ABC[2])
count = (C+0.5)//A
print(int(count*B))

Solution (Python):
def main():
    l = input().split()
    a, b, t = int(l[0]), int(l[1]), int(l[2])
    
    t = t + 0.5
    print(int(t/float(a))*b)

if __name__=="__main__":
    main()

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

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

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

tmp = t // a
ans = tmp * b

print(ans)

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

if T < A:
    pass
    
else:
    for i in range(A, T, A):
        
        biscuit += B

print(biscuit)

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=(int(i) for i in input().split())
print(b*int((t+0.5)/a))

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

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

i = 1

while i * a <= t:
	i += 1

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

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

print((t//a)*b)

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

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

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

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

Solution (Python):
import math


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


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

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

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 = map(int,input().split())
ans = 0
for i in range(1,100):
    if(i*a > t+0.5):
        break
    ans += b
print(ans)

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

Solution (Python):
import sys

a,b,t = input().split()
A = int(a)
B = int(b)
T = int(t)

cnt = 0

i = A
while i < T + 0.5:
    cnt += B
    i += A

print(cnt)

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

print(int(T/A)*B)

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

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

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

bis = 0
i = 0
time = 0
while True:
    i +=1
    time += A
    if T+0.5>time:
        bis += B
    else:
        break
print(bis)

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

Solution (Python):
A, B, T = [int(s) if s.isdigit() else s for s in input().split()]
print(int(((T + 0.5) // 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())
num = int((T + 0.5) / A) * B
print(num)

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

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

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

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

k = t // a
if k >= 0:
  print(k * b)
elif a>t:
  print(0)

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

print(t // a * b)

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

Solution (Python):
import math

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

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

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

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

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

Solution (Python):


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

n = 0

while a*n <= t+0.5:
    n += 1

print(b*(n-1))

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

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

count = T//A

print(count*B)

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

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

Solution (Python):
def solve():
    A, B, T = [int(_) for _ in raw_input().split()]
    ret = int((T + 0.5) / A) * B
    print str(ret)

if __name__ == '__main__':
    solve()

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

time = float(T) + 0.5
i = 1
bisk = 0

while A*i < time:
    bisk = bisk + B
    i = i+1

print(bisk)

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

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

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

Solution (Python):
A, B, T = list(map(int, input().split()))
print(sum(B for i in range(A, T+1, A)))

Solution (Python):
inputs = list(map(int, input().split()))
 
A = inputs[0]
B = inputs[1]
T = inputs[2]
 
Q = int(T / A)

X = Q* 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):
a, b, t = [int(x) for x in input().split(" ")]

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

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

Solution (Python):
def input_nums():
    return [ int(i) for i in input().split(" ") ]
nums = input_nums()
A = nums[0]
B = nums[1]
T = nums[2]

biscut = 0
cnt = 1
for t in range(T):
	if (cnt==A):
		biscut += B
		cnt=1
	else:
		cnt+=1
print(biscut)

Solution (Python):
str=input().split(' ')
a,b,t=eval(str[0]),eval(str[1]),eval(str[2])
ans=0
a1=a
while a<=t+0.5:
  ans+=b
  a+=a1
print(ans)

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

print(b*(x//a))

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

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

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

print(total)

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

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()) 
j = 0
for i in range(21):
  if T >= i * A:
    j = i
ans = 0
ans = j * B
print(ans)

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

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

Solution (Python):
span, num, period = map(float, input().split(' '))
print(int(((period + 0.5) // span) * num))

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

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

Solution (Python):
import math
val = input().split()
A = int(val[0])
B = int(val[1])
T = int(val[2])+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(t//a * b)

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

for i in range(1, 21):
    if a * i < t + 0.5:
        count += b

print(count)

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

Solution (Python):

  
import sys

def validate(input):
    if input < 0 or input > 20:
        return False
    return True

def biscuitGen(input_a, input_b, input_t):
    biscuits = 0
    if validate(input_a) and validate(input_b) and validate(input_t):
        biscuits = int(input_t / input_a) * input_b
    return biscuits

if __name__=='__main__':
    '''
    print how many biscuit will be generated 
    A: Seconds to generate biscuit
    B: Number of biscuit pieces to generate once
    T: Limit of the seconds to generate biscuit
    1 <= A,B,T <= 20
    '''
    biscuit = 0
    inarray = list(map(int,input().split()))
    if len(inarray) != 3:
        print("Please input 3 numbers")
        sys.exit()
    biscuit = biscuitGen(inarray[0], inarray[1], inarray[2])
    print(biscuit)

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

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

n = T // A

sum = 0
for i in range(n):
  sum = sum + B
  
print(sum)

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

Solution (Python):

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

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

all_val = b*((t+0.5)//a)

print(int(all_val))

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

d = a
e = 0

while d <= c:
  e += b
  d += a
  
print(e)

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)