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

    count = int((T + 0.5) // A)
    return B * count

if __name__ == '__main__':
    print(main())

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

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

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

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

S=T+0.5

C=S//A

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

Solution (Python):
A, B, T = (int(i) for i in input().split())  
c=int((T+0.5)/A)
ans=c*B
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())
print(math.floor((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())
ans = 0
i=1
while a*i <=t:
    ans +=b
    i+=1
print(ans)

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

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

print(c//a*b)

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


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

Solution (Python):

import sys
import math
from collections import defaultdict


sys.setrecursionlimit(10**7)
def input():
    return sys.stdin.readline()[:-1]


mod = 10**9 + 7


def I(): return int(input())
def II(): return map(int, input().split())
def III(): return list(map(int, input().split()))
def Line(N):
    read_all = [tuple(map(int, input().split())) for _ in range(N)]
    return map(list,zip(*read_all))



A,B,T = II()

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

Solution (Python):
list1 = [i for i in input().split()]

num1 = int(list1[0])
num2 = int(list1[1])
num3 = int(list1[2])

print (int(num3//num1 * num2))

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

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

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

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

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

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

d = (n[2] + 0.5) // n[0]
ans = d * n[1]
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())
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())
print( (T // A) * B )

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

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

Solution (Python):
import math

inputa = input().split()




a = int(inputa[0])
b = int(inputa[1])
c = int(inputa[2])






time = float(c)+0.5
ans = math.floor(time / float(a))
ans = int(ans)*b

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

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


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

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

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


if __name__ == "__main__":
    test()

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

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

if a > t:
    print(0)
else:
    ans = t//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(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("{}".format((t//a)*b))

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

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

print(T//A*B)

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

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

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

print(b*(i-1))

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

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

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

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

l_num = t // a

sum_ = 0
for n in range(1, l_num+1):
    sum_ += b

print(sum_)

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

print((t // a) * b)

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

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

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

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

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

buf=c//a

print(buf*b)

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

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

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

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

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

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

print((t//a)*b)

Solution (Python):



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





print(int(T / A) * B)

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

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

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

print(t//a*b)

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

Solution (Python):

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

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

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

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

print((t // a) * b)

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

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

print((T//A) * B)

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

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 = [int(i) for i in 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())

t = t + 0.5

result = (t // a) * b

print( "{:d}".format(int(result)) )

Solution (Python):


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

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

for i in range(1,21):
  if a*i <= T:
    ans += 1
print(ans*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())

t = 1
biscuit = 0
while t*A <= T:
  biscuit += B
  t += 1

print(biscuit)

Solution (Python):


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


bake = t // a
ans =  b * bake

print(ans)

Solution (Python):


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


bake = t // a
ans =  b * bake

print(ans)

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

res=t//a*b

print(res)

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

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

ans = 0
i = 1
c = a
while c < t + 0.5:
    ans += b
    i += 1
    c = a * i

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

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

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

print(c)

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

print((T // A)*B)

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

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

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

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

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

Solution (Python):
def biscuit(a,b,t):
    n = int(t/a) * b

    print("%d" %n)

if __name__ == '__main__':
    string = input().split()
    a = int(string[0])
    b = int(string[1])
    t = int(string[2])

    biscuit(a,b,t)

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

bisc = 0

while(A < (T + 0.5)):
    bisc += B
    A += step


print(bisc)

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

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

Solution (Python):
list = [int(i) for i in input().split(" ")]
interval = list[0]
qty = list[1]
t = list[2]
times = int((t+0.5)/interval)
print(times*qty)

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

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

Solution (Python):

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

res = 0
t = t + 1
for k in range(1,10000):
    now = k * a
    if now < t:
        res += b

print(res)

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

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):
l = [int(i) for i in input().split()]
print((l[2]//l[0])*l[1])

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

print((T//A)*B)

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

print(count)

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

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

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

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

Solution (Python):
def wei(A,B,T):
    if T+0.5 > A:
        return int(T/A)*B
    else:
        return 0

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

"""print(wei(3,5,7) == 10)
print(wei(3,2,9) == 6)
print(wei(20,20,19) == 0)"""

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

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

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

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

while i*A <= T2:
  i += 1
  
i=i-1
  
print(B*i)

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

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

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

Solution (Python):
def main25():
    data = input().split()
    num = []
    for i in range(3):
        num.append(int(data[i]))
    result = num[1] * int(num[2]/num[0])
    print(result)

if __name__ == "__main__":
    main25()

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

print((T // A) * B)

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

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

Solution (Python):
"""


 = sys.stdin.readline().rstrip()
 = list(sys.stdin.readline().rstrip())


 = int(sys.stdin.readline())
 = map(int, sys.stdin.readline().split())
 = list(map(int, sys.stdin.readline().split()))
 = [list(map(int,list(sys.stdin.readline().split()))) for i in range(h)]  


a = 100
b = 0.987654321
print("{0:06d}-{1:6f}".format(a,b))
000100-0.987654


char_list = list("abcd") 
"""

import math
import sys
import itertools
import queue
from fractions import gcd

def lcm(a, b):
    return a * b // gcd(a, b)

mod = 1000000007

if __name__ == "__main__":
    A,B,T= map(int, sys.stdin.readline().split())
    c=0
    i=1
    while True:
        if i*A < T+0.5:
            c +=1
            i +=1
        else:
            break
    print(B*c)

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

print(ans)

Solution (Python):
s = input()

arr = s.rstrip().split(" ")

sai = int(arr[2]) // int(arr[0])

print(sai * int(arr[1]))

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

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
ans = 0
now_time = 0
while 1:
    count+=1
    now_time += a
    if now_time > t:
        break
    ans += b

print(ans)

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

while(time <= T + 0.5):
  biscuits += B
  time += A
  
print(biscuits)

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

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

Solution (Python):

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

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

print(T//A * B)

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

print(b*(t//a))

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

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

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

if __name__ == "__main__":
    resolve()

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

num = ( T + 0.5 ) // a
print(int(b * num))

Solution (Python):

from collections import defaultdict
from collections import deque
from heapq import heappush, heappop
import sys
import math
import bisect
import random
import itertools
sys.setrecursionlimit(10**5)
stdin = sys.stdin
bisect_left = bisect.bisect_left
bisect_right = bisect.bisect_right
def LI(): return list(map(int, stdin.readline().split()))
def LF(): return list(map(float, stdin.readline().split()))
def LI_(): return list(map(lambda x: int(x)-1, stdin.readline().split()))
def II(): return int(stdin.readline())
def IF(): return float(stdin.readline())
def LS(): return list(map(list, stdin.readline().split()))
def S(): return list(stdin.readline().rstrip())
def IR(n): return [II() for _ in range(n)]
def LIR(n): return [LI() for _ in range(n)]
def FR(n): return [IF() for _ in range(n)]
def LFR(n): return [LI() for _ in range(n)]
def LIR_(n): return [LI_() for _ in range(n)]
def SR(n): return [S() for _ in range(n)]
def LSR(n): return [LS() for _ in range(n)]
mod = 1000000007
inf = float('INF')


def A():
    a, b, t = LI()
    print(b * (t // a))
    return


def B():
    return


def C():
    return


def D():
    return


def E():
    return


def F():
    return


def G():
    return


def H():
    return


if __name__ == '__main__':
    A()

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

print(count)

Solution (Python):
import sys
import math
from collections import deque

sys.setrecursionlimit(4100000)


def inputs(num_of_input):
    ins = [input() for i in range(num_of_input)]
    return ins


def solve(inputs):
    [A, B, T] = string_to_int(inputs[0])
    return B * (T // A)


def string_to_int(string):
    return list(map(lambda x: int(x), string.split()))


if __name__ == "__main__":
    ret = solve(inputs(1))
    print(ret)

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

print(t // a * b)

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

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

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

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

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

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

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 = [int(i) for i in input().split()]
X = (T + 0.5) // A
Y = (B * X)//1
Z = int(Y)
print(Z)

Solution (Python):
a, b, t = map(int, input().split(' '))
sec = 0
biscuit = 0
while True:
    sec += 0.5
    if sec >= t + 0.5:
        break
    if sec % a == 0:
        biscuit += b
print(biscuit)

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

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

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

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

Solution (Python):
import sys
from collections import deque  
from collections import defaultdict  
from heapq import heapify, heappush, heappop, heappushpop  
from bisect import bisect_left, bisect_right  



s2nn = lambda s: [int(c) for c in s.split(' ')]
ss2nn = lambda ss: [int(s) for s in ss]
ss2nnn = lambda ss: [s2nn(s) for s in ss]
i2s = lambda: sys.stdin.readline().rstrip()
i2n = lambda: int(i2s())
i2nn = lambda: s2nn(i2s())
ii2ss = lambda n: [sys.stdin.readline().rstrip() for _ in range(n)]
ii2sss = lambda n: [list(sys.stdin.readline().rstrip()) for _ in range(n)]
ii2nn = lambda n: ss2nn(ii2ss(n))
ii2nnn = lambda n: ss2nnn(ii2ss(n))
MOD = int(1e+9) + 7

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

main()

Solution (Python):



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


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

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

s = []
cnt = 1
while (A * cnt <= T + 0.5):
    s.append(A * cnt)
    cnt += 1
biscuit = B * len(s)

print(biscuit)

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

print(t//a*b)

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

print(t//a*b)

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

sum_count = 0
sum_time = 0

while True:
    sum_time += a
    if sum_time > t + 0.5:
        break
    sum_count += b

print(sum_count)

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


main()

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

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

Solution (Python):


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

ans = (T // A) * B

print(ans)

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

time = int(t / a)

print(b * time)

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

ans = 0
while True:
    if T < A:
        break;
    T -= A
    ans += B

print(ans)

Solution (Python):
A, B, C = map(int, input().split())
print(C//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())
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(b*(t//a))
"""
切り捨て除算なので場合分けはいらない
input()にしなかった私が悪うございました(￣^￣)
"""

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

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

Solution (Python):



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

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

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

print(B * (T // A))

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

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

out = 0
temp = a

for i in range(2, 100):
    if temp < t + 0.5:
        out += b
        temp = a * i

print(out)

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())
sum = 0

for i in range(T):
  if T + 0.5 < A * (i + 1):
    break
  sum = sum + B

print(sum)

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

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

time = 0
cnt = 0
while True:
    if time >= T+0.5:
        break
    cnt += 1
    time = cnt*A
print((cnt-1)*B)

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

Solution (Python):
Biscuit_factory_0, Biscuit_factory_1, Biscuit_factory_2 = (int(a)for a in input().split())

Number_of_sheets = (Biscuit_factory_2 // Biscuit_factory_0) * Biscuit_factory_1
print(Number_of_sheets)

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())
K=T//A
while A*K<=T+0.5:
  K+=1
print((K-1)*B)

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

Solution (Python):
a, b, t = map(int, input().split())
times = t // a
ans = 0
for i in range(1, times+2):
    if a * i <= t + 0.5:
        ans += b
print(ans)

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

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

print((t // a)*b)

Solution (Python):

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

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

n=t//a

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

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

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

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

unit = T // A

print(unit * B)

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

print((t // a) * b)

Solution (Python):

from collections import defaultdict
import math
import re

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

    num = 0
    for t in range(100):
        t += 1
        if t > T + 0.5:
            break
        if t % A == 0:
            num += B

    print(num)

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

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

Solution (Python):
from sys import stdin


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

biscket = 0
time = A
while time < T+0.5:
    biscket += B
    time += A

print(biscket)

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

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

Solution (Python):
A, B, T = list(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())

Z = T // A
count = Z*B

print(count)

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

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

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

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

a,b,t = map(int, input().split())
cnt = 0
time = a
while time <= t:
    cnt += b
    time += a
print(cnt)

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

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

Solution (Python):
from collections import defaultdict, Counter
from itertools import product, groupby, count, permutations, combinations
from math import pi, sqrt
from collections import deque
from bisect import bisect, bisect_left, bisect_right
from string import ascii_lowercase
from functools import lru_cache
import sys
sys.setrecursionlimit(10000)
INF = float("inf")
YES, Yes, yes, NO, No, no = "YES", "Yes", "yes", "NO", "No", "no"
dy4, dx4 = [0, 1, 0, -1], [1, 0, -1, 0]
dy8, dx8 = [0, -1, 0, 1, 1, -1, -1, 1], [1, 0, -1, 0, 1, 1, -1, -1]


def inside(y, x, H, W):
    return 0 <= y < H and 0 <= x < W


def ceil(a, b):
    return (a + b - 1) // b



def sum_of_arithmetic_progression(s, d, n):
    return n * (2 * s + (n - 1) * d) // 2



def gcd(a, b):
    if b == 0:
        return a
    return gcd(b, a % b)



def lcm(a, b):
    g = gcd(a, b)
    return a / g * b


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

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

print((T//A)*B)

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

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

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

t = int(t)

num = b*(t//a)

print(num)

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

for i in range(a):
  total += B
  
print(total)

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

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

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

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

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

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

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

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

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

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

print(bis)

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

print(c // a * b)

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