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())
time = 0
biscuit = 0
end = False

while not end:
    time += A
    if  time <= T:
        biscuit += B
    else:
        end = True

print(biscuit)

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

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

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

num = (int(N[2]) // int(N[0])) * int(N[1] )
print(num)

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

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


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

print(int(ans))

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

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

Solution (Python):
def main():
    a, b, t = list(map(int, input().split()))
    i = a
    count = 0
    while i < t + 0.5:
        count += b
        i += a

    print(count)


main()

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

Solution (Python):
import sys

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

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

print( (T) // A * B)

Solution (Python):
def main():
    ABT = input()
    ABT = list(map(int, ABT.split()))
    A = ABT[0]
    B = ABT[1]
    T = ABT[2]
    res = int((T+0.5)/A)*B
    print(res)
main()

Solution (Python):
a, b, t = map(int, raw_input().split())
s = 0
time = 0
while True:
    time += a
    if time > t + 0.5:
        break
    s += b
print(s)

Solution (Python):

import re
import math

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

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

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

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

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

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

for i in range(a[2]+1):
    if i != 0 and i % a[0] == 0:
        b += a[1]

print(b)

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

t = T + 0.5
times = int(t // A)

ans = 0
for i in range(times):
    ans = (i+1)*B

print(ans)

Solution (Python):

"""
Created on Sat Apr 27 20:57:04 2019

@author: Yamazaki Kenichi
"""

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

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

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

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

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

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

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

Solution (Python):

"""
Created on Sat Apr 27 20:59:13 2019

@author: yuta
"""

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

def main(abt):
    a = abt[0]
    b = abt[1]
    t = abt[2]
    count = int(t/a)*b
    print(count)
main(ABT)

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

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

while True:
    if a * cnt >= t + 0.5:
        break
    rtn += b
    cnt += 1

print(rtn)

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

ans = (T // A) * B

print(ans)

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

for i in range(len(line)):
    if i==2:
        t=int(line[2])
    elif i==1:
        b=int(line[i])
    else:
        a=int(line[i])

print(b*(t//a))

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

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

Solution (Python):

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

i = a
c = 0
while i<=(t):
  
  c+=b
  i+=a;
  
print(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())

ans = T // A * B

print(ans)

Solution (Python):

import re
import bisect
from datetime import datetime as dt

a, b, t = map(int, raw_input().split())
d = a
c = 0
while float(a) <= float(t) + 0.5:
    c += b
    a += d
print c

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

print(b * time)

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=a
ans=0
while T<=t:
    ans+=b
    T+=a
print(ans)

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

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

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

count = int(T / A) * B

print(count)

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())
counter = 0
c = a
while a <= t:
	counter += b
	a = a + c
print(counter)

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

cnt=-B
x=0
while x <= T:
    cnt += B
    x += A
print(cnt)

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

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

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

Solution (Python):
import sys
def p(*a):
  s=" ".join(map(str,a))
  
  sys.stderr.write(s+"\n")


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

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

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

Solution (Python):

import sys



def solve(lines):
    A,B,T = map(int, lines.pop(0).split(' '))
    res = 0
    S = A
    while S < T + 0.5:
        res += B
        S += A
    print(res)
lines = [x.strip() for x in sys.stdin.readlines()]
solve(lines)

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

print(B * int(T / A ))

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

i = 0
num = 0
while True:
    if i + a > t + 0.5:
        break
    i += a
    num += b

print(num)

Solution (Python):
A,B,T=map(int,input().split())
t=0
count=0
while True:
    t=t+A
    if t<T+0.5:
        count=count+B
    else:
        break
print(count)

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

count = 0

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

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 = [int(x) for x in input().split()]

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

Solution (Python):
import math
import functools
import itertools
import numpy as np
import sys
MAX_INT = int(10e10)
MIN_INT = -MAX_INT
mod = 1000000007
sys.setrecursionlimit(1000000)
def IL(): return list(map(int,input().split()))
def SL(): return input().split()
def I(): return int(sys.stdin.readline())
def S(): return input()

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

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

print(int(num))

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

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

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

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

print(int(T / A) * B)

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

while True:
    time += loop * a
    if time > t + 0.5:
        break
    ans += b

print(ans)

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

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

print(ans)

Solution (Python):

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

num = t // a

print(num * b)

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

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

Solution (Python):


a = []

a = input().split()

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

Solution (Python):
import sys
 
inp = map(int, raw_input().strip().split(" "))
 
print((inp[2]/(inp[0]))*inp[1])

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

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

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

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

print(B * t)

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

Solution (Python):



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


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

Solution (Python):
import sys
import collections
ns = lambda: sys.stdin.readline().rstrip()
ni = lambda: int(ns())
nm = lambda: map(int, sys.stdin.readline().split())
nl = lambda: list(nm())
nsl = lambda: map(str, sys.stdin.readline().split())

a, b, t = nm()
count = 0
aa = a
while(aa <= t + 0.5):
    count += b
    aa += a
print(count)

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

keika = A
goukei = 0

while keika < T + 0.5:
    goukei += B
    keika += A

print(goukei)

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

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

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

Solution (Python):
import math

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

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

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

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

Solution (Python):
import sys

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

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

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

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

Solution (Python):
def a():
    N = raw_input().split(" ")
    A = int(N[0])
    B = int(N[1])
    T = int(N[2])

    print T / A * B


def main():
    a()
	
if __name__ == '__main__':
    main()

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

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

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

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

a = int(int(str[2])/int(str[0]))

print(a*int(str[1]))

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

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

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

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

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

print(B*int(T/A))

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

print(t//a * b)

Solution (Python):
import sys

















input = sys.stdin.readline
def ii(): return int(input())
def mi(): return map(int, input().rstrip().split())
def lmi(): return list(map(int, input().rstrip().split()))
def li(): return list(input().rstrip())



A, B, T = mi()

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

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

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

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

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

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

print(ans)

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

print((T // A) * B)

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

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

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

Solution (Python):

if __name__ == '__main__':
    a,b,t = list(map(int, input().split()))
    t = t + 0.5

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

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

cnt = 0
time = 0
while(1):
  if time > t:
    break
  cnt += b
  time += 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())
count = 0
for i in range(1,t+1):
  if i % a == 0:
    count += b
    i -= a
print(count)

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

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

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

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

Solution (Python):
def main():
    result = sub()
    print(result)


def sub():
    A, B, T = [int(x) for x in (input().split())]
    n = T / A
    return int(n) * B


if __name__ == '__main__':
    main()

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

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

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

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

sum = 0

for i in range(A,T+1,A):
    sum += B

print(sum)

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+0.5) // A ) ))

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

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

    print(B * times)


if __name__ == '__main__':
    main()

Solution (Python):

num = input().split()

T = int(num[2]) + 0.5

B = int(num[1])
A = int(num[0])

result = 0
t= A


while t < T:
    result = result + B
    t = t + A


print(result)

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

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

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

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

print(b * (t // a))

Solution (Python):


import sys

def input(): return sys.stdin.readline().strip()
def list2d(a, b, c): return [[c] * b for i in range(a)]
def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]
def ceil(x, y=1): return int(-(-x // y))
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def NO(): print('NO')
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
MOD = 10 ** 9 + 7

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

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

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

print(ans)

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

Solution (Python):
import sys

input = sys.stdin.readline


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


if __name__ == "__main__":
    main()

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

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

Solution (Python):
import sys
input=sys.stdin.readline
A=list(map(int,input().split()))
print(int((A[2]+0.5)//A[0]*A[1]))

Solution (Python):
import numpy as np

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

time = T + 0.5
cnt = 0
while time > 0:
    time = time - A
    cnt += 1

if cnt != 0:
    cnt = cnt - 1

print(B * cnt)

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

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

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

S = T + 0.5

X = B * (S // A)

print(int(X))

Solution (Python):



inp = input().split()

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

step = int(T / A)
count = B * step

print(count)

Solution (Python):
A, B, T = [int(x) for x in input().split(" ")]
s = 0
i = A
while i <= T + 0.5:
    s += B
    i += A

print(s)

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

print(int(t/a)*b)

Solution (Python):
import numpy as np
huga = list(map(int, input().split()))

A=huga[0]
B=huga[1]
T=huga[2]+0.5
u=T//A
v=u*B

print(round(v))

Solution (Python):
import sys
import re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians
from itertools import permutations, combinations, product
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits


def input(): return sys.stdin.readline().strip()


def INT(): return int(input())


def MAP(): return map(int, input().split())


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


sys.setrecursionlimit(10 ** 9)
INF = float('inf')
MOD = 10 ** 9 + 7

a,b,t=MAP()

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

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

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

    t = A
    count = 0
    while t <= T:
        t += A
        count += B

    print(count)

main()

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

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

Solution (Python):
from collections import defaultdict
from string import ascii_uppercase
import sys, bisect, math
stdin = sys.stdin
read_int = lambda : list(map(int,stdin.readline().split()))
read_str = lambda : stdin.readline().rstrip()

a,b,t = read_int()

def solve():
    ans = 0
    c = int((t + 0.5) // a)
    ans = b*c
    return ans

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

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

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(100):
  if a * (i+1) <= t:
    ans += b

print(ans)

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

Solution (Python):


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

qtd = (t+0.5)/a

qtd = int(qtd)

print(qtd*b)

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

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

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

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

t = t + 0.5

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

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

    print((t//a)*b)
    

if __name__ == '__main__':
    main()

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



    
print(int(T/A) * B)

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

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

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

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

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

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

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

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

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

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

print(int(X)*int(B))

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

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

Solution (Python):


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

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

Solution (Python):
import sys
import math

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

time = math.floor(T/A)

print(B*time)

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

print(B * (T // A))

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

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

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

Solution (Python):
import sys
import io
import math
import re

datalist = input().split()
data_a = int(datalist[0])
data_b = int(datalist[1])
data_c = int(datalist[2])


print(int(data_c/data_a)*data_b)

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


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

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

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

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

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

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

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

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


print(ans)

Solution (Python):
A,B,T = map(int,input().split(" "))
ans = 0
if T % A == 0:
    print(int(B * (T / A)))
    
else:
    for i in range(int(T / A)):
        ans += B
    print(ans)

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

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


if __name__ == '__main__':
    main()

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

time = a
out = 0

while time <= t:
    out += b
    time += a

print(out)

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

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

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

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

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

Solution (Python):
import math
import re

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


a = int(a)
b = int(b)
t = int(t)

now = a
total = 0
while True:
    if now < t + 0.5:
        total += b
        now += a
    else:
        break

print total

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

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

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

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

Solution (Python):
import sys
from collections import Counter

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

print(str(int(b * int(t / a))))

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 = [int(x) for x in input().split()]

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

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

Solution (Python):


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

def answer():
    ans = T // A * B
    return ans

def main():
    print(answer())


if __name__ == '__main__':
    main()

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

s = b * (t//a)

print(s)

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

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

Solution (Python):

import sys
import math


def solve(A: int, B: int, T: int):
    print(math.floor(T/A)*B)
    return



def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    A = int(next(tokens))  
    B = int(next(tokens))  
    T = int(next(tokens))  
    solve(A, B, T)

if __name__ == '__main__':
    main()

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

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

Solution (Python):
a = [int(x) for x in input().split()]
count = 0
T = a[2]
while (T >= a[0]):
  count += a[1]
  T -= a[0]
print(count)

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

while t <= T:
    s += B
    t += A

print(s)

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

Solution (Python):
import numpy as np

s = input().split()
a = int(s[0])
b = int(s[1])
c = int(s[2])+0.5

w = np.floor(c/a)*b

print(int(w))

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

show = c//a

print(int(b*show))

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

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

Solution (Python):


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

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

print(ans)

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


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

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

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

print(B*(T//A))

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

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

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

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

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

print(T // A * B )

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

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

Solution (Python):

import sys


def solve(A: int, B: int, T: int):
    print((T // A) * B)
    return



def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    A = int(next(tokens))  
    B = int(next(tokens))  
    T = int(next(tokens))  
    solve(A, B, T)

if __name__ == '__main__':
    main()

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

kaisuu=C//A
kotae=kaisuu*B
print(kotae)

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

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

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

print(T//A*B)

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

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

Solution (Python):
from sys import stdin
a, b, c = [int(x) for x in stdin.readline().rstrip().split()]
print(int(c/a)*b)

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

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

def solve(a, b, t):
	x = 0
	if t < a:
		return 0
	for i in range(t//a):
		x += b
	return x

if __name__ == '__main__':
    a, b, t =  map(int, input().split())
    print(solve(a,b,t))