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


solve()

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

Solution (Python):
a,b,t = list(map(int, input().split()))
print(str(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(i) for i in input().split())
 
times = int(t / a)
 
num = times * b
 
print(num)

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

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

Solution (Python):



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

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

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

print(t // a * b)

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

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

print(ans)

Solution (Python):
if __name__ == '__main__':
  val = input()
  input_num = val.split(' ')
  
  a,b,t = input_num
  cuccki = 0
  
  for i in range(10000):
    if int(a)*(i+1) < (float(t)+0.5):
	    cuccki += int(b)
    else:
      break
      
  print(cuccki)

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

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

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

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

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

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

bai = (C + 0.5) // A
cnt = bai * B

print(int(cnt))

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

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

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

secs=T+0.5

count=secs//A

print(round(count*B))

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

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

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

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

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

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

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

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

ans = 0
i = 0

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

print(ans)

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

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

while(True):
    current = a*count
    if(current < t):
        biscuits += b
        count += 1
    else:
        break

print(biscuits)

Solution (Python):
from sys import stdin
from collections import deque, defaultdict as ddic
from itertools import combinations, permutations, product
import bisect
import heapq


rs = lambda: stdin.readline().strip()
ri = lambda: int(rs())
rsl = lambda: stdin.readline().split()
rim = lambda: map(int, rsl())
ril = lambda: list(rim())

A, B, T = rim()
seconds = A
if T < A:
    print(0)
else:
    cookies = 0
    while seconds <= T:
        cookies += B
        seconds += A

    print(cookies)

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

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

print(T//A*B)

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

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

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

def count(s):
    a = int(s[0])
    b = int(s[1])
    t = int(s[2])
    a_now = a
    sum_ = 0
    while a_now< t+0.5:
        sum_ += b
        a_now += a
    
    return sum_

print(count(li))

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

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

Solution (Python):


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

def biscuit_generator(a, b, t):
    biscuit = 0
    t -= a
    while (t+0.5) > 0:
      biscuit += b
      t -= a

    return biscuit

print(biscuit_generator(A, B, T))

Solution (Python):


a, b, t = map(int, input().split())
time = 0
limit = t + 0.5
bisc = 0

while True:
    time += a
    if time <= limit:
        bisc += b
    else:
        break

print(bisc)

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

Solution (Python):
import math
a,b,t =map(int,input().split())
mai=0
if a> t:
  print(mai)
else:
  mai = math.floor(t/a)*b
  print(mai)

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

Solution (Python):



ABT = input().split(' ')
A = int(ABT[0])
B = int(ABT[1])
T = int(ABT[2])

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

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

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

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

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

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

print(int(t / a) * b)

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

Solution (Python):
argA,argB,argT = list(map(int,input().split()))
print(int(argT / argA) * argB)

Solution (Python):
A, B, T = map(int, input().split()) 
biscuit = 0
i = A
while i <= T + 0.5:
  biscuit += B
  i += 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())
ans = 0
for i in range(t):
    if (i+1)%a == 0:
        ans += b

print(ans)

Solution (Python):
a, b, t = input().strip().split(' ')
a, b, t = [int(a), int(b), int(t)]

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

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

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

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

Solution (Python):
def biscuit(a,b,t):
    i = 1
    while i*a<=t:
        i = i+1
    return b*(i-1)
    
a,b,t = map(int, input().split())
print(biscuit(a,b,t))

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

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

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

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

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

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

print(count)

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

times = T//A
ans = B * times

print(ans)

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

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

Solution (Python):
a,b,c = map(int,input().split())
time = 0
biscuit = 0
kakeru = 1

if c < a:
    print(0)
else:
    while time < c+0.5:
        biscuit += b
        time += a
        if time > c+0.5:
            biscuit -= b
            break
    print(biscuit)

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

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

tt = t+0.5

print(int(tt/a)*b)

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

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

while t + 0.5 > tt + a:
	c+= b
	tt += a	

	
print(c)

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

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

total = int(count_a) * int(b)

print( int(total))

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

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,21):
  if i*A<=T:
    ans+=B
  else:
    break
print(ans)

Solution (Python):
a = list(map(int,input().split()))
time = 0
sum = 0
while a[2] >= time + a[0]:
    sum += a[1]
    time += a[0]
print(sum)

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

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

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

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

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

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

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

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

print(ans)

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

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

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

times = int(t / a)

print(times*b)

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

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

num = int(T/A)

print(num*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):


import sys

debug = False

def log(text):
    if debug:
        print(text)

def parse_input(lines_as_string = None):

    global debug
    lines = []
    if lines_as_string is None:
        debug = False
        lines.append(input())
    else:
        debug = True
        lines = [e for e in lines_as_string.split("\n")][1:-1]


    token = lines[0].split()
    a = int(token[0])
    b = int(token[1])
    t = int(token[2])

    return (a, b, t)


def solve(a, b, t):


    return t // a * b


def main():
    

    print("%s" % solve(*parse_input()))

if __name__ == '__main__':

    main()

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

Solution (Python):

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

bsk_cnt = 0
cnt = 0
time = 0
while time < t + 0.5:
    cnt += 1
    time = cnt*a
    if time < t+0.5:
        bsk_cnt += b

print(bsk_cnt)

Solution (Python):




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

  print((t // a) * b, flush=True)


if __name__ == '__main__':
  main()

Solution (Python):
A,B,C=map(int,input().split())
i=1
ans=0
while A*i<C+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):
import math

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

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

print(num)

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

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

print(c*b)

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

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

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

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

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

for i in range(t+1):
    if i != 0 and i % a == 0:
        sum += b

print(sum)

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

if not(t < a):
    sum = int(b * int((t / a)))

print(sum)

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

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

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

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

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

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

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

print(cookie)

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

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

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

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

time=0
out=0

while True:
  time+=A
  if T < time:
    break
  out+=B

print(out)

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

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

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

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

Solution (Python):
from sys import stdin
input=stdin.readline().rstrip().split()

for i in range(len(input)):
    input[i]=int(input[i])

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

x=0
output=0
while x<100:
    x+=A
    if x>T:
        break
    output+=B

print(output)

Solution (Python):
A, B, T = map(int,input().split())
i = 1
count = 0
while i <= T:
    if i % A == 0:
        count += B
    i += 1
print(count)

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

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

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

sum = ( (T + 0.5) / A )

print(int(sum)*B)

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

Solution (Python):
import math

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

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

print(bisket)

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

A = int(A)
B = int(B)
T = float(T) + 0.5

t = T // A

print(int(B * t))

Solution (Python):



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

bisk = 0
for t in range(T):
    t = t + 1
    if t % A == 0:
        bisk += B
    else:
        continue

print(bisk)

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

Solution (Python):
A, B, T = map(int, input().split())
ans = 0
t = 0
while t <= T - A:
    ans += B
    t += A
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):



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

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


if __name__ == '__main__':
    main()

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

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 = int(a)
b = int(b)
t = int(t)
ans = 0

c = t // a

ans = b*c
print(ans)

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

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

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

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

Solution (Python):
def main():
  if 'get_ipython' not in globals():  
    
    A,B,T = map(int, input().split())
  else:
    
    
    
    
    A,B,T = 20,20,19
  
  print(T//A*B)
    
main()

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

ans = 0
now = 1

while t + 0.5 > a * now:
    ans += b
    now += 1

print(ans)

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

print(int(t/a)*b)

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

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

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

print(ans)

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

print(ans)

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

print((T//A)*B)

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

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

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

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

print(cookie)

Solution (Python):
import math

a,b,t = (int(i) for i in input().split())

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

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

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

ans = [i for i in range(1,30) if i%a == 0 and i<t+0.5]
print(len(ans)*b)

Solution (Python):

ABT =input().split()
a = int(ABT[0])
b = int(ABT[1])
t = int(ABT[2])

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

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

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

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

Solution (Python):
raw_input = input()
a, b, t = map(int, raw_input.split())
counter = (t+0.5)//a 
number = b * counter 
print('%d' % number)

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

Solution (Python):
a, b, t = [int(i) for i in input().split()]
ans = 0
for i in range(1, 30):
    if t < a:
        break
    t = t - a
    ans += b
print(ans)

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

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

if A < (T+0.5):
    print(int(B*((T+0.5)//A)))
else:
    print(0)

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

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("{}".format(int((T+0.5)//a)*b))

Solution (Python):


from sys import stdin

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

C = T // A

print(C * B)

Solution (Python):
if __name__ == '__main__':
    input_list = list(map(int, input().split()))
    A = input_list[0]
    B = input_list[1]
    T = input_list[2]

    cnt = int(T+0.5)//int(A)
    answer = 0

    for i in range(1, cnt+1):
        answer += B

    print(answer)

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

x = (t + 0.5) // a

print(int(b * x))

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

Solution (Python):
import numpy as np

if __name__ == "__main__":
    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())

total = 0

for i in range(1, 1000):

    if A * i < T + 1:
        total += B

print(total)

Solution (Python):
a, b, t = (int(i) for i in input().split())
x=1
flag=True
while(flag):
    if(x*a>t):
        flag=False
    x+=1
print(b*(x-2))

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

time = 0
c = 0

while True:
    time += a
    if time <= t:
        c += b
    else:
        break

print(c)

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

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

print(count)

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

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

Solution (Python):
while True:
    try:
        listA=list(map(int,input().split()))
    except:
        break;
value = int((listA[2]+0.5)/listA[0])
print(listA[1] * value)

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

Solution (Python):

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

print("{}".format(ans))

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

print(b*(t//a))

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

Solution (Python):
def split_returner(chardata):
        chardata = str(chardata).split(" ")
        for i in range(0,len(chardata)):
            chardata[i] = int(chardata[i])
        return chardata

a = split_returner(input())
result = int((a[2]+0.5)/a[0]) * a[1]
print(result)

Solution (Python):

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

make_time = data[0]
num = data[1]
limit = data[2]

make_num = 0
for t in range(limit + 1):
    if t % make_time == 0 and t != 0:
        make_num += num

print(make_num)

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


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

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

print(ans)

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

Solution (Python):

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

t = (t+0.5)//a


bbb = int(t*b)

print(bbb)

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

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

print(x)

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

print((T // A) * B)

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

ans=0
for k in range(1,21):
	if k*A<=T:
		ans+=B

print ans

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

Solution (Python):

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

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

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

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

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

print((cnt-1)*B)

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

bis = 0

for i in range(1, T+1):
    if i % A == 0:
        bis += 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())

ans = 0
for i in range(a,10**10,a):
    if i >= t + 0.5:
        break
    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())
print(int((t+0.5)//a*b))

Solution (Python):
i = input().split()
a = float(i[0])
b = float(i[1])
t = float(i[2])
f = True
n = 0
while(f):

    if t  + 0.5 < n * a:
       f = False
       break
    n = n + 1
n = n-1
print(int(n * b))

Solution (Python):

import sys
read = sys.stdin.readline


def read_ints():
    return list(map(int, read().split()))


def read_a_int():
    return int(read())


def read_matrix(H):
    '''
    H is number of rows
    '''
    return [list(map(int, read().split())) for _ in range(H)]


def read_map(H):
    '''
    H is number of rows
    文字列で与えられた盤面を読み取る用
    '''
    return [read() for _ in range(H)]


def read_col(H, n_cols):
    '''
    H is number of rows
    n_cols is number of cols

    A列、B列が与えられるようなとき
    '''
    ret = [[] for _ in range(n_cols)]
    for _ in range(H):
        tmp = list(map(int, read().split()))
        for col in range(n_cols):
            ret[col].append(tmp[col])

    return ret


A, B, T = read_ints()

print(B*(T//A))

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


if __name__ == '__main__':
    main()

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

while i <= t:
    cnt += b
    i += a 


print(cnt)

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

x = (T + 0.5) / A
y = math.floor(x)

ans = y * B

print(ans)

Solution (Python):
a,b,t=[int(x) for x in 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 = list(map(int,input().split())) 
print((a[2]//a[0])*a[1])

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

ans = 0
s = 1
while True:
    if s % A == 0:
        ans += B
    s += 1
    if s > T + 0.5:
        break

print(ans)

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

print(int(T/A) * B)

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

Solution (Python):





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

time = T/A

if time < 0:
    ans = 0
else:
    ans = B*int(time)

print(ans)

Solution (Python):
inputs = input().split(" ")
print(int((float(inputs[2])+0.5)/int(inputs[0]))*int(inputs[1]))

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

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

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

print(ans)

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

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

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

m = int(t / a)

print(m * b)

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

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

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

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

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

res = 0

if A <= T:
    for i in range(T//A):
        res+=B
    print(res)
else:
    print(0)

Solution (Python):
from collections import Counter
from functools import reduce
import bisect
import fractions
import math
import statistics
import sys
import time
sys.setrecursionlimit(10**7)
INF = 10 ** 18
MOD = 10 ** 9 + 7
def LI(): return [int(x) for x in sys.stdin.readline().split()]  
def LF(): return [float(x) for x in sys.stdin.readline().split()]  
def LS(): return sys.stdin.readline().split()  
def MI(): return map(int, sys.stdin.readline().split())  
def II(): return int(sys.stdin.readline())  
def IS(): return input()  
def P(x): return print(x)
def C(x): return Counter(x)
def GCD_LIST(numbers):  
    return reduce(fractions.gcd, numbers)
def LCM_LIST(numbers):  
    return reduce(LCM, numbers)
def LCM(m, n):
    return (m * n // fractions.gcd(m, n))


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

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

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

print(t//a*b)

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

x=(t+0.5)//a

print(round( x*b))

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

b = 0
s = 0
i = 1
while True:
  s = int(A)*i
  if float(s) > float(T)+0.5:
    break
  i+=1
  b += int(B)
print(b)

Solution (Python):
import math

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

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

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

Solution (Python):
input = input().split(" ")
a = input[0]
b = input[1]
t = input[2]
sec = float(t) + 0.5
import math
time = math.floor(sec/int(a))
result = time*int(b)
print(result)

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

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

ans = 0

if t < a: ans = 0
elif t == a: ans = b
else:
  ans = (t // a) * b
  
print(ans)

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

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

ans = 0
time = 0
for i in range(1, 22):
    time += A
    if time > T:
        break
    ans += B

print(ans)

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

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

Solution (Python):
import math

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

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

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

Solution (Python):
import math

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

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

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

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

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

result = t//a*b

print(result)

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