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

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

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

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

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

cnt=0
bcnt=0

for i in range(1,30):
    cnt=i*A
    if cnt > T:
        break
    else:
        bcnt+=B

print(bcnt)

Solution (Python):
import os, sys, re, math

a,b,t = [s for s in input().split(' ')]
A = int(a)
B = int(b)
T = int(t) + 0.5
t = A
ret = 0
while  t < T:
  ret += B
  t += A

print(ret)

Solution (Python):
import math

abt = input().split()

count = math.floor(int(abt[2]) / int(abt[0])) * int(abt[1])
print(count)

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

Solution (Python):
A,B,T = [ int(e) for e in input().split()]
bis = 0;
i=1;

while (A*i) <= (T + 0.5):
    bis+=B;
    i+=1;

print(bis)

Solution (Python):
import numpy as np


N = input()

A, B, T = np.array(list(map(int,N.split( ))))

T = T + 0.5
S = 0
n = 1
A1 = A
while A1<T:
  n = n + 1
  A1 = n * A
  S = S + B
print (S)

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

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

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

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

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

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

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

while i * A <= T:
  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())


cnt=1
sum=0
for i in range(T):

  if (i+1) % A*cnt == 0:
    sum=sum+B
    cnt=cnt+1

    
print(sum)

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

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

a,b,t=spaceinput()

print((t//a)*b)

Solution (Python):
import queue
 
(N,M,R) = (int(i) for i in input().split(" "))
 
 
print(int(R/N)*M)

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

ans = (i[2] // i[0]) * i[1]

print(ans)

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

tmp = int((T + 0.5) / A)

ans = B * tmp

print(ans)

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

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

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

main()

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

x=t//a

print(x*b)

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

Solution (Python):
import re
import sys
from fractions import gcd
from functools import reduce
from itertools import product

import numpy as np

sys.setrecursionlimit(200000)


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


def ii(t: type = int):
    return t(input())


def il(t: type = int):
    return list(map(t, input().split()))


def imi(N: int, t: type = int):
    return [ii(t) for _ in range(N)]


def iml(N: int, t: type = int):
    return [il(t) for _ in range(N)]


def solve():
    A, B, T = il()
    ans = (T + 0.5) // A * B
    return int(ans)


if __name__ == "__main__":
    print(solve())

Solution (Python):

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

N=(T+0.5)//A

print(int(N*B))

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

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

Solution (Python):

t_unit,bis_unit,fin_time=map(int,input().split())
time=0
count=-bis_unit
fin_time=fin_time+0.5
while time <= fin_time:
    time+=t_unit
    count+=bis_unit

print(count)

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

Solution (Python):
from sys import stdin

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

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

print(biscuits)

exit(0)

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

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

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

Solution (Python):

import math

def read_input():
    a, b, t = map(int, input().split())
    return a, b, t

if __name__ == '__main__':
    a, b, t = read_input()

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

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

while True:
    kake += 1
    if A * kake > T:
        break  
print(B * (kake - 1))

Solution (Python):
mi = lambda: map(int, input().split())

A, B, T = mi()

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

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

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

i = 1
count = 0
while A*i <= (T+0.5):
  count += B
  i += 1
  
print(count)

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())
cnt = 0
for i in range(1,100):
    if a*i <= t+0.5:
        cnt = cnt + 1
    else:
        break
sum = b * cnt
print(sum)

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

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

Solution (Python):



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

count = 0
num_bisket = 0
while True:
    count += A
    if count > T:
        break
    
    num_bisket += B
    

print(num_bisket)

Solution (Python):
q = input()
p = q.split()
a = int(p[0])
b = int(p[1])
t = int(p[2])
c = (t+0.5)//a
print(int(c*b))

Solution (Python):
str = input().split(' ')

def sum(a, b, x):
  sum = (x // a) * b
  return sum

a = int(str[0])
b = int(str[1])
x = int(str[2])

print(sum(a,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(B * (T//A))

Solution (Python):
a, b, t = list(map(int, input().split(" ")))
count = 0
while True:
    count += 1
    time = count * a
    if time >= t + 0.5:
        break
print((count - 1) * b)

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

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

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

i = int((T + 0.5) // A)

print(int(B * i))

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

T_time=T+0.5
x=int(T_time/A)

print(B*x)

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

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

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

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

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

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

Solution (Python):
a,b,t=map(int,input().split())
x=0
num=0
c=a
for i in range(21):
    x=c
    c=a*(i+2)
    
    if(x>t):
        break
    num+=b

print(num)

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

print(int(T/A)*B)

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

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

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(s)for s in input().split()]
print(b*(t//a))

Solution (Python):

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

print((T//A)*B)

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


if __name__ == '__main__':
    main()

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

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

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

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

print(int(int(nums[2]) / int(nums[0])) * int(nums[1]))

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

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

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

total = 0

mul = 1
while mul * a <= t+0.5:
    total += b
    mul += 1

print(total)

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

print(B*(T//A))

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

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

Solution (Python):
import math
a, b, t = map(int, input().split())
if a > t:
    print(0)
else:
    print (b * math.floor(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 = (int(i) for i in input().split())  
now = A
result = 0

for i in range(999):
    if now < T+0.5:
        result = result + B
        now = now + A 
        
print(result)

Solution (Python):


def main():
	a,b,t = map(int,input().split())
	t = t+0.5
	n = 0
	c = a

	while c < t:
		n += b
		c += a
	print(n)
    
if __name__ == "__main__":
	main()

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


if __name__ == "__main__":
    main()

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

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

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):
List=[int(i) for i in input().split()]
ans = 0

counter = 1

for i in range(20):
    if List[1] == 0:
      break
    if counter >= int(List[2]) + 0.5:
      break       
    if counter % int(List[0]) == 0:
      ans += int(List[1])
    
    counter += 1
print(ans)

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

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

Solution (Python):


import sys
input = sys.stdin.readline



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


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

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

Solution (Python):
target = input().split()
per_second = int(target[0])
cokies = int(target[1])
times = int(target[2])
target_time = times + 0.5

print(int((target_time // per_second) * cokies) )

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

Solution (Python):



from collections import deque
import heapq
import math
import bisect


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())
if A ==0 or B == 0 or T == 0:
  print(0)
else:
  num = int(T / A) * B
  
  print(num)

Solution (Python):
a = list(map(int, input().split()))
A = a[0]
B = a[1]
T = a[2]
bis = 0
while T >= A:
  bis += B
  T -= A

print(bis)

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

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

biscuits = 0

end = int(T) + 0.5

count = int(A)
while end > count:
  biscuits += int(B)
  count += int(A)

print(biscuits)

Solution (Python):
A,B,T=map(int, input().split())
t_max = int((T+0.5)/A)
print(t_max*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(1,T+2):    
    if i > T+0.5:
        print(ans)
        break
    if i%A==0:
        ans += 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())
num = (t + 0.5) / a
bis = int(num) * b
print(bis)

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

cnt = (t+0.5)//a

print(int(cnt*b))

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

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

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

Solution (Python):

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

Solution (Python):
from sys import stdin

readline = stdin.readline

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

print(t // a * b)

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

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

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

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

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

import math
n = math.floor((int(T) + 0.5)/int(A))


print(n*int(B))

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

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

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

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

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

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

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

print((c//a)*b)

Solution (Python):


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

i = 1
c = 0
while i*A < T+0.5:
    c = c + B
    i = i + 1

print(c)

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



def count_total_biscuit(A, B, T):
    return (T // A) * B


print(count_total_biscuit(A, B, T))

Solution (Python):

import sys
input = sys.stdin.readline

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

Solution (Python):
import math;
str=input().split(" ");
ans=math.floor(int(str[2])/int(str[0]))*int(str[1]);
print(ans);

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

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

Solution (Python):

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

Solution (Python):

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

count = a
ans = 0
while True:
    if count > t + 0.5:
        break
    count += a
    ans += b
print(ans)

Solution (Python):
a,b,t=map(int,input().split())
x=0
while x<=t+0.5:
    x+=a
y=(x-a)/a
print(int(y*b))

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

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

Solution (Python):



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

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

main()

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

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

Solution (Python):
args = input().split(" ")
s = 0
t = 0
while(t+int(args[0]) < int(args[2]) + 0.5):
    t += int(args[0])
    s += int(args[1])
print(s)

Solution (Python):
import math

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

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

Solution (Python):

import numpy as np


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

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

t = 0
created = 0

while 1:
    t += 1

    if t%A == 0:
        
        created += B

    if t >= T:
        break

print(created)

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

Solution (Python):
a, b, c = map(int, input().split())
s=0
t=a
d = c +0.5
for num in range(100):
    
    if t>d:
        break
    s +=b
    t += a
    
print(s)

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

Solution (Python):
a,b,T= (int(i) for i in input().split()) 
cooky=0
t=a
while(t<T+0.5):
  cooky=cooky+b
  t=t+a
print(cooky)

Solution (Python):

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

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

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

C = T // A
D = B * C

print(D)

Solution (Python):






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

k = t//a
ans = k*b

print(ans)

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

for i in range(1,10000):
  S=i*A
  if T<S:
    
    print((i-1)*B)
    exit()

Solution (Python):

x,y, T = map(int,input().split())

result = 0;
for i in range(1,T+1):
	if(i%x == 0):
		result += y;
	
print(result)

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

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

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

Solution (Python):

import math
import sys


def parse(file):
    a, b, t = map(int, file.readline().split())
    return a, b, t


def main(a, b, t):
    return math.floor((t + 0.5) / a) * b


if __name__ == '__main__':
    print(main(*parse(sys.stdin)))

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

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

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

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

Solution (Python):
from collections import defaultdict,deque
import sys,heapq,bisect,math,itertools,string,queue,datetime,random
sys.setrecursionlimit(10**8)
INF = float('inf')
mod = 10**9+7
eps = 10**-7
def inpl(): return list(map(int, input().split()))
def inpls(): return list(input().split())

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

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

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

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

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

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

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

sums=0
for i in range(t/a):
    sums+=b
print sums

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

T2 = T + 0.5
Biscuits = int(T2 // A * B)

print(Biscuits)

Solution (Python):
a,b,c = map(int,input().split())
d = a + 0
e = 0

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

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

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

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

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

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

Solution (Python):


import itertools
from collections import Counter
from collections import defaultdict
import bisect

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(" "))
ans = B*int(T/A)
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())
N=T//A
print(B*N)

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

Solution (Python):
a,b,c = map(int,input().split())
d = a + 0
e = 0

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

Solution (Python):
A,B,T=map(int,input().split())
T=float(T)
a=A
sum=0
count=0.0
while  count<=T:
    count+=0.5
    if count>=a:
        sum+=B
        a+=A
print(sum)

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

    s+=b
print(s)

Solution (Python):


def main():
    sp = [int(e) for e in input().split(" ")]
    a = sp[0]
    b = sp[1]
    t = sp[2]

    print(int(t/a) * b)
    
    
    
    

main()

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

ans = int((int (a[2])/ int (a[0]))) * int(a[1])
print(ans)

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

print(t // a * b)

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

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

a, b, t = read_ints()
t += 0.5

ans = 0
timer = 1
while timer < t:
    if timer % a == 0:
        ans += b
    timer += 1

print ans

Solution (Python):

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

Solution (Python):
import sys

def main(inp):
    a,b,t=map(int,next(inp).split())
    print(int(t/a)*b)
    
main(sys.stdin)

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

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

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

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

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

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

Solution (Python):
x = input().split()
a = int(x[0])
b = int(x[1])
t = int(x[2])
print(int(t/a)*b)

Solution (Python):
time, cookie, totaltime = (int(i) for i in input().split())
print(cookie*(totaltime//time))

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

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

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

Solution (Python):
fq, num, max_time = map(int, input().split())
time = 0
_sum = 0
while 1:
    time += fq
    if time >= max_time + 0.5:
        break
    else:
        _sum += num
print(_sum)

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

print(ans)

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

t = int(T/A)
bisket = B*t
print(int(bisket))

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

if A>T:
	print(0)
else:
	print(int((T/A))*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(int((t+0.5)//a)*b)

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

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

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

ans = 0
count = 1
time = 0
while 1:
    time = count * A
    if T < time:
        print(ans)
        exit()
    ans += B
    count += 1

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

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

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


print((T//A)*B)

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

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

print(x)

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

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

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

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

Solution (Python):
data = input().split()
span = data[0]
num = data[1]
limit = data[2]
times = int(limit) / int(span)
import math
times = math.floor(times)
x = int(num) * int(times)
print(x)

Solution (Python):
abt = [int(s) for s in input().split(' ')]
print(str(int(abt[2]/abt[0])*abt[1]))

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


main()

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

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

r= int((c + 0.5)/a) * b

print(r)

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

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

def input_from_console():
    a, b, t = map(int, input().split())
    return a, b, t


def main():
    a, b, t = input_from_console()
    print(solve(a, b, t))

if __name__ == "__main__":
    main()

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

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

i = 0
while True:
    if i*a <= t:
        i += 1
    else:
        break
print((i-1)*b)

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

Solution (Python):


intA, intB, intT = map(int, input().split())
print(intT // intA * intB)

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

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

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

print(c)

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

Solution (Python):
import numpy as np
nums = map(int ,raw_input().split())
print str(int(np.trunc((nums[2]+0.5)/nums[0])*nums[1]))

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

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

Solution (Python):
import math

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

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

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

print( int(T / A) * B )

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

Solution (Python):



input_line = input().split()
inputInt = [int(i) for i in input_line]

A = inputInt[0]
maisuu = inputInt[1]
timeLimit = inputInt[2] + 0.5

i = 0
while A*i < timeLimit:
    i += 1
i -= 1

print(maisuu*i)

Solution (Python):
def biscuit_generator():
    number = [int(x) for x in input().split()]
    A = number[0]
    B = number[1]
    T = number[2]
    print(int(((T + 0.5) // A) * B))

biscuit_generator()

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

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

Solution (Python):
import math
A, B, T = map(int, input().split())
print(sum([B for x in range(A, int(math.ceil(T+0.5)), A)]))

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

  print(sum)
  
main()

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

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

times = (t-(t%a))/a

print(int(times*b))

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

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

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

ans = B * (t // A)
print(int(ans))

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

count = t // a

print(count * b)

Solution (Python):
l = input().split()
list = [int(i) for i in l]
x = int(list[-1] / list[0])
num = list[1] * x
print(num)

Solution (Python):


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

Solution (Python):


l = list(map(int,input().split()))
A = l[0]
B = l[1]
T = l[2]
ans = 0
for i in range(1, 30):
    if i >= T + 0.5:
        break
    elif i % A == 0:
        ans += B
        

print(ans)

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

Solution (Python):

a, b, c = map(int, input().split())
d = c + 0.5
bis = 0
byou = 0

for i in range(21):
    byou = i * a
    if byou >= d:
        break
    bis = i * b

print(bis)

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

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

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

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

value[2] = value[2] + 0.5

if value[0] <= value[2]:
  a = int(value[2] / value[0])
  print(value[1] * a)

else:
  print(0)

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

Solution (Python):
n = input().split(" ")
 
a = int(n[0])
b = int(n[1])
t = int(n[2])
 
w = int(t / a)
print(w * b)