Problem:
 Score : 100 points    Problem Statement A biscuit making machine produces B biscuits at the following moments: A seconds, 2A seconds, 3A seconds and each subsequent multiple of A seconds after activation.  Find the total number of biscuits produced within T + 0.5 seconds after activation.      Constraints  All values in input are integers.  1 \leq A, B, T \leq 20         Input Input is given from Standard Input in the following format:  A  B  T       Output Print the total number of biscuits produced within T + 0.5 seconds after activation.        Sample Input 1 3 5 7      Sample Output 1 10   Five biscuits will be produced three seconds after activation.  Another five biscuits will be produced six seconds after activation.  Thus, a total of ten biscuits will be produced within 7.5 seconds after activation.        Sample Input 2 3 2 9      Sample Output 2 6       Sample Input 3 20 20 19      Sample Output 3 0

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

while cnt < T + 0.5:
	if cnt % A == 0:
		sum += B
	cnt += 1

print(sum)

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

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

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

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

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

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

Solution (Python):
A,B,T = [int(i) for i in input().split()]
t = 0
count = 0
while True:
    t += A
    if t > T:
        break
    count +=B
print(count)

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

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

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

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

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

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

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

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

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

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

sum = 0
for i in range(1, 21):
    if (t + 0.5) < a * i:
        break
    else:
        sum += b

print(sum)

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

print(t // a * b)

Solution (Python):
import sys

INPUT = lambda: sys.stdin.readline().rstrip()
MAP = lambda: map(int, INPUT().split())

sys.setrecursionlimit(10 ** 9)


def main():
    A, B, T = MAP()
    print((T//A)*B)


if __name__ == '__main__':
    main()

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

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

    ans = 0

    time = 0
    while(t+0.5 > time):
        time += 1
        if time % a == 0 and time < t+0.5:
            ans += b

    print(ans)

if __name__ == '__main__':
    main()

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

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

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

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

Solution (Python):




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

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

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

print((T//A)*B)

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

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

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

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

Solution (Python):
first = input().split(' ')
per_time = int(first[0])
per_make = int(first[1])
time = int(first[2]) + 0.5

made = per_make * int(time / per_time)

print(made)

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

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

while 1:
  
  f=a*e
  if c+0.5>=f:
    e+=1
    
    d+=b
  else:
    break
print(d)

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

print(t//a * b)

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

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

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

print(T//A*B)

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

ans = 0
time = A
while time <= T:
  ans += B
  time += A
print(ans)

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

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

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

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

print(c//a * b)

Solution (Python):
s = input().split()
a=int(s[0])
b=int(s[1])
t = int(s[2])
i=0
while True :
    if i*a>t:
        break
    i+=1

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

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

Solution (Python):
import sys

stdin = sys.stdin

mod = 1000000007
inf = 1 << 60

ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))
ns = lambda: stdin.readline().rstrip()
nas = lambda: stdin.readline().split()

a, b, t = na()
k = 1
ans = 0
while a * k <= t:
    k += 1
    ans += b

print(ans)

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

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

Solution (Python):

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

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

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

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
print(ans * b)

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

print(ans * b)

Solution (Python):
import sys
def input(): return sys.stdin.readline().rstrip()

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

if __name__ == '__main__':
    main()

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

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

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

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

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

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

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

Solution (Python):
import sys

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

def main():
    return b * (t // a)

if __name__ == '__main__':
    ans = main()
    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(B*(T//A))

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

Solution (Python):
import sys
import math

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

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

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

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

Solution (Python):
t, mai, lim = (int(x) for x in input().split())
total = 0
for i in range(1,lim+1):
    if i%t == 0:
        total += mai
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())
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())

n = t//a

N = b*n
print(N)

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

Solution (Python):


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

print(T//A*B)

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

print(T // A * B)

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

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

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

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

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

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

print t/a*b

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

Solution (Python):



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

print t / a * b

Solution (Python):
import math

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

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

Solution (Python):
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):
import os, sys, re, math

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

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

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

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

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

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

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

print(T // A * B)

Solution (Python):
a, b, c = list(map(int, input().split(' ')))
i = 0
ans = 0
while i <= c:
  i += a
  ans += (b * (i <= c))
print(ans)

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

Solution (Python):
import math

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

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

for i in range(1,90):
  if a*i >=t+0.5:
    if i==1:
      print(0)
      break
    else:
      print(b*(i-1))
      break

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

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

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

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

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

ans = T // A * B

print(ans)

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

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

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

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

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

    print((int(t+0.5)//a * b))
    
if __name__ == '__main__':
    main()

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

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

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

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

Solution (Python):
"""
author : halo2halo
date : 12, Jan, 2020
"""

import sys

read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(10 ** 7)

A,B, T = map(int, readline().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())
u = t//a

print(u*b)

Solution (Python):
def main():
    A, B, T = map(int, input().split(" "))
    result = 0
    if T >= A:
        while T > A - 1:
            result += B
            T -= A
    print(result)


if __name__ == '__main__':
    main()

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

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

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

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

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

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

Solution (Python):
x = input()
x_list = x.split(" ")
a = int(x_list[0])
b = int(x_list[1])
t = int(x_list[2])

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

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

print(t//a*b)

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

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

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

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

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

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

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

print(B * int(T / A))

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

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

Solution (Python):
A, B, T = map(int, open(0).read().split())

print(B*(T//A))

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

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

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

Solution (Python):
INT = lambda: int(input())
INTM = lambda: map(int,input().split())
STRM = lambda: map(str,input().split())
STR = lambda: str(input())
LIST = lambda: list(map(int,input().split()))
LISTS = lambda: list(map(str,input().split()))
def do():
    a,b,c=INTM()
    print(c//a*b)
if __name__ == '__main__':
    do()

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+1):
    if i%a==0:
        ans+=b
print(ans)

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

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

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

total_t = 0
i = 1
count = 0

while True:
  total_t += a*i
  if t+1/2 <= total_t:
    break
  else:
    count += b

print(count)

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

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

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

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

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

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

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

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

print(ans)

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

total = 0
j = a
for i in range(1, 100):
    if j < t + 0.5:
        total += b
        j = a*(i+1)
    else:
        print(total)
        break

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

Solution (Python):
li = list(map(int,input().split()))
ans=0
k=1
while k<=(li[2]+0.5)/li[0]:
    ans+=li[1]
    k+=1
print(ans)

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

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

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

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

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

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

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

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

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

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




e=int(c/a)

print(e*b)

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

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


if __name__ == '__main__':
    solve()

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

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

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

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

ans = 0
t += 0.5
i = 1
while(i < t):
    if(i % a == 0):
        ans += b
    i += 1

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

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

ans = (t//a) * b

print(ans)

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

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

Solution (Python):

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

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

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

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

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

Solution (Python):

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


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

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

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

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

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

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

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

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

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

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

Solution (Python):

import sys, math, itertools, heapq, collections, bisect, string
input = lambda: sys.stdin.buffer.readline().rstrip().decode('utf-8')
sys.setrecursionlimit(10**7)
inf = float('inf')
mod = 10**9+7
ans = inf ;count = 0 ;pro = 1

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

Solution (Python):

import sys, math, itertools, heapq, collections, bisect, string
input = lambda: sys.stdin.buffer.readline().rstrip().decode('utf-8')
sys.setrecursionlimit(10**7)
inf = float('inf')
mod = 10**9+7
ans = inf ;count = 0 ;pro = 1

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

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

ans = 0
for i in range(20):
    t -= a
    if ( t >= 0):
        ans += b
    else:
        break

print(ans)

Solution (Python):

def check(a, time):
  ret, mod = divmod(time, a)
  value = True if mod == 0 else check(a, ret) if ret > a else False
  return value


a, b, t, biscuit = map(int, input().split() + ["0"])
for i in range(1, t + 1):
  if check(a, i):
    biscuit = biscuit + b

print(biscuit)

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

print(t // a * b)

Solution (Python):
import math

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

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

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

i = 1
time = 0
bis = 0
while time < t+0.5:
    time = a*i
    bis += b
    i += 1

print(bis-b)

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

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

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

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

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

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

Solution (Python):
a,b,t=map(int,raw_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())
s=0
x=a
while x<=t+0.5:
    s+=b
    x+=a
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(t // a * b)

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

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

time = i[0]
num = i[1]
limit_time = i[2]

times = (limit_time+0.5) // time

print(int(num*times))

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

x = b * (t // a)

print(x)

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

x = t // a
y = b * x

print(y)

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

Solution (Python):

import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**6)

a, b, t = map(int, input().split())
now = 0
bis = 0
while(now <= t):
    now += a
    bis += b
print(bis-b)

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

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

print(b*(t//a))

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

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

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

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

print(T // A * B)

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

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

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

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



ans = int(i[1]*((i[2]+0.5)//(i[0])))
print(ans)

Solution (Python):

import math
import datetime





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

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

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

print(T//A*B)

Solution (Python):
A,B,T=tuple(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())
aa=int((t+0.5)//a)
print(b*aa)

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

Solution (Python):
import sys
input = sys.stdin.readline
def print_ans(A, B, T):
    """Test Case
    >>> print_ans(3, 5, 7)
    10
    >>> print_ans(3, 2, 9)
    6
    >>> print_ans(20, 20, 19)
    0
    """
    tmp, _ = divmod(T, A)
    print(tmp * B)

if __name__ == '__main__':
    A, B, T = map(int, input().rstrip().split())
    print_ans(A, B, T)

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

Solution (Python):

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

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

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

p_a()

Solution (Python):
a,b,t=map(int,input().split())
i=0
cum_time=0
total=0
while True : 
  cum_time+=a
  if cum_time>t+0.5:
    break
  else:
    total+=b
print(total)

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

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

PART = T//A

print(B*PART)

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

Solution (Python):
def examA():
    A, B, T = LI()
    ans = (T//A)*B
    print(ans)

import sys,copy,bisect,itertools,heapq,math
from heapq import heappop,heappush,heapify
from collections import Counter,defaultdict,deque
def I(): return int(sys.stdin.readline())
def LI(): return list(map(int,sys.stdin.readline().split()))
def LSI(): return list(map(str,sys.stdin.readline().split()))
def LS(): return sys.stdin.readline().split()
def S(): return sys.stdin.readline().strip()
mod = 10**9 + 7
inf = float('inf')

examA()

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

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

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

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

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

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

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

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

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

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

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

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

ans = 0
for a in range(A, (T+1), A):
    ans += 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( b*(t//a) )

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

Solution (Python):
a,b,t = (int(x) for x in input().split())
t = t + 0.5
c = a
n = 0
while t >= a :
    a = a + c
    n += 1
print((n)*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):
def inpl():
    return list(map(int, input().split()))


def gcd(a, b):
    
    while b > 0:
        a, b = b, a % b

    return a


A, B, T = inpl()

print(B * (T // A))

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

total = 0

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

print(total)

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

Solution (Python):
import sys
sys.setrecursionlimit(10**9)
INF=10**18
def input():
    return sys.stdin.readline().rstrip()

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

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

print(B*n)

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

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

Solution (Python):

import sys










def main():
    a, b, t = [int(x) for x in sys.stdin.readline().split()]
    ans = int((t + 0.5) // a) * b
    print(ans)


if __name__ == "__main__":
    main()

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

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

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

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

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

while float(a*i) < float(c)+0.5:
  i += 1

ans = (i-1)*b  
print(ans)

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

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


ans = 0

print(t // a * b)

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

import math

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

bisket = B * n

print(bisket)

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

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

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

ret = (t//a)*b

print(ret)

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

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

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

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

print (t // a * b)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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 = [B for i in range(T//A)]
print(sum(ans))