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):
import sys, os, math, bisect, itertools, collections, heapq, queue

from decimal import Decimal
from collections import defaultdict



sys.setrecursionlimit(10000000)

ii = lambda: int(sys.stdin.buffer.readline().rstrip())
il = lambda: list(map(int, sys.stdin.buffer.readline().split()))
fl = lambda: list(map(float, sys.stdin.buffer.readline().split()))
iln = lambda n: [int(sys.stdin.buffer.readline().rstrip()) for _ in range(n)]

iss = lambda: sys.stdin.buffer.readline().decode().rstrip()
sl = lambda: list(map(str, sys.stdin.buffer.readline().decode().split()))
isn = lambda n: [sys.stdin.buffer.readline().decode().rstrip() for _ in range(n)]

lcm = lambda x, y: (x * y) // math.gcd(x, y)


MOD = 10 ** 9 + 7
MAX = float('inf')


def main():
    if os.getenv("LOCAL"):
        sys.stdin = open("input.txt", "r")

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


if __name__ == '__main__':
    main()

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

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

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

main()

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

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

print(B*(T//A))

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

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

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

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

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

ans = (t // a) * b

print(ans)

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

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

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

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

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

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

Solution (Python):
import sys

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

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


main()

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

a = 0
bis_num = 0
while True:
    a = a + A
    if a > T:
        break
    bis_num += B

print(bis_num)

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

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

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

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

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

if __name__ == '__main__':
    solve()

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

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

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

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())
t += 0.5
b_num = 0
i = 1
while t >= a * i:
    b_num += b
    i += 1
print(b_num)

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

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

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

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

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

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

Solution (Python):



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

print(T//A*B)

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

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

Solution (Python):
import sys
input=sys.stdin.readline
sys.setrecursionlimit(10 ** 8)
from itertools import accumulate
from itertools import permutations
from itertools import combinations
from collections import defaultdict
from collections import Counter
import fractions
import math
from collections import deque
from bisect import bisect_left
from bisect import insort_left
import itertools
from heapq import heapify
from heapq import heappop
from heapq import heappush
import heapq
from copy import deepcopy
from decimal import Decimal
alf = list("abcdefghijklmnopqrstuvwxyz")
ALF = list("ABCDEFGHIJKLMNOPQRSTUVWXYZ")

INF = float("inf")


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

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

Solution (Python):
from sys import stdin, setrecursionlimit


def main():
    input = stdin.buffer.readline
    a, b, t = map(int, input().split())
    print((t // a) * b)


if __name__ == "__main__":
    setrecursionlimit(10000)
    main()

Solution (Python):
import sys

input = lambda: sys.stdin.readline().rstrip()


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


if __name__ == '__main__':
    solve()

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

print(T//A*B)

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

print(b*(t//a))

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

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

print(t//a*b)

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

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

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

now = a
cnt = 0
t += (0.5 - a)
while(t > 0):
    cnt += b
    now += a
    t -= a
print(cnt)

Solution (Python):
import sys
from collections import defaultdict

def solve():
    input = sys.stdin.readline
    A, B, T = map(int, input().split())
    time = A
    count = 0
    while time < T + 0.5:
        count += B
        time += A
    print(count)

    return 0

if __name__ == "__main__":
    solve()

Solution (Python):
from sys import exit
import math
ii = lambda : int(input())
mi = lambda : map(int,input().split())
li = lambda : list(map(int,input().split()))

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

Solution (Python):






from collections import defaultdict











import sys
sys.setrecursionlimit(10000000)
mod = 10**9 + 7

def readInts():
  return list(map(int,input().split()))
def I():
  return int(input())
a,b,t = readInts()
ans = 0
time = 0
while True:
    ans += b
    
    if time + a > t + 0.5:
        break
    else:
        time += a
print(ans - 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((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((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())

turn = t // a
count = b * turn

print(count)

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

print((t // a) * b)

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

print(z//x*y)

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

ans=(t//a)*b

print(ans)

Solution (Python):
import sys

A, B, T = map(int, sys.stdin.readline().strip().split())
print(B * (T // A))

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

bai = int(t/a)

print(bai*b)

Solution (Python):
import math
def ip():return int(input())
def inp():return map(int,input().split())
def inpstr():return map(str,input().split())
def linp():return list(map(int,input().split()))
def linpstr():return list(map(str,input().split()))

a,b,t=inp()
print(t//a*b)

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

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

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

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

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

sum = int((time // a) * b)

print(sum)

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

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

Solution (Python):
import itertools
import decimal
import math
import collections
import sys
input = sys.stdin.readline

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

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

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

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

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

n = int(t + 0.5) // a

print(n * b)

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

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

print(ans)

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

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

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

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

Solution (Python):

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

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

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

print(b*(t//a))

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

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

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

Solution (Python):

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

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

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

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

    ans = T // A * B

    print(ans)


resolve()

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

print(b*(t//a))

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

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

t = t + 0.5

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

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

main()

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):
from collections import defaultdict, deque
import sys

INF = float('inf')
def LI(): return list(map(int, sys.stdin.buffer.readline().split()))
def I(): return int(sys.stdin.buffer.readline())
def LS(): return sys.stdin.buffer.readline().rstrip().decode('utf-8').split()
def S(): return sys.stdin.buffer.readline().rstrip().decode('utf-8')
def IR(n): return [I() for i in range(n)]
def LIR(n): return [LI() for i in range(n)]
def SR(n): return [S() for i in range(n)]
def LSR(n): return [LS() for i in range(n)]
def SRL(n): return [list(S()) for i in range(n)]
def MSRL(n): return [[int(j) for j in list(S())] for i in range(n)]


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

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

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

print(ans)

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(1,90):
  if i*a > t+ (1/2):
    ans = i-1
    break
    
for j in range(1,ans+1):
  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())
print(t//a*b)

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

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

import sys
input = sys.stdin.readline
A,B,T = (int(x) for x in input().split())
num =(T +0.5)//A
ans =B *num
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()))
print(int((t+0.5)//a)*b)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Solution (Python):

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


print(T // A * B)

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


if __name__ == '__main__':
    main()

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

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(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())
a=float(a)
t=float(t)
j=a
c=0
n=2.0
while True:
    if j<=t+0.5:
        c+=b
        j=a*n
        n+=1.0
    else:
        break
print(c)

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

sum = 0
for i in range(1, t+1):
    if(i % a == 0):
       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())
print(int(((T + 0.5)//A * B)))

Solution (Python):
from collections import Counter 
from collections import defaultdict
from collections import deque
import math
import itertools
import heapq
import numpy as np
import sys
sys.setrecursionlimit(10**6)




ceil=lambda x,y: (x+y-1)//y
input_list = lambda : list(map(int,input().split()))
import fractions


a,b,t=input_list()

c=(t+0.5)//a

print(int(c*b))

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

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

print(B * (T // A))

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

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

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

print(sum([B if(i%A==0) else 0 for i in range(A,T+1)]))

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


if __name__ == "__main__":
    main()

Solution (Python):


import sys






















def main():
    mod = 1000000007                
    inf = float('inf')              
    
    sys.setrecursionlimit(10**6)    
    def input(): return sys.stdin.readline().rstrip()
    def ii():    return int(input())
    def mi():    return map(int, input().split())
    def mi_0():  return map(lambda x: int(x)-1, input().split())
    def lmi():   return list(map(int, input().split()))
    def lmi_0(): return list(map(lambda x: int(x)-1, input().split()))
    def li():    return list(input())
    
    
    a, b, t = mi()
    print(b * (t // a))


if __name__ == "__main__":
    main()

Solution (Python):
def q1():
    A, B, T = (int(i) for i in input().split())
    d,_ = divmod(T, A)
    ans = B * d
    return ans

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

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


if __name__ == "__main__":
    main()

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

bisc = ((t + 0.5) // a)  * b

print(int(bisc))

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

print((T//A) * B)

Solution (Python):
import bisect,collections,copy,heapq,itertools,math,string
import sys
def S(): return sys.stdin.readline().rstrip()
def M(): return map(int,sys.stdin.readline().rstrip().split())
def I(): return int(sys.stdin.readline().rstrip())
def LI(): return list(map(int,sys.stdin.readline().rstrip().split()))
def LS(): return list(sys.stdin.readline().rstrip().split())
a, b, t = M()
print((t//a)*b)

Solution (Python):






import sys
input = sys.stdin.readline

import math
from collections import deque
from fractions import gcd
from functools import lru_cache






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






def inputI(): return int(input().strip())
def inputS(): return input().strip()
def inputIL(): return list(map(int,input().split()))
def inputSL(): return list(map(str,input().split()))
def inputILs(n): return list(int(input()) for _ in range(n))
def inputSLs(n): return list(input().strip() for _ in range(n))
def inputILL(n): return [list(map(int, input().split())) for _ in range(n)]
def inputSLL(n): return [list(map(str, input().split())) for _ in range(n)]


def inv(n): return pow(n, MOD-2, MOD)


kaijo_memo = []
def kaijo(n):
  if(len(kaijo_memo) > n):
    return kaijo_memo[n]
  if(len(kaijo_memo) == 0):
    kaijo_memo.append(1)
  while(len(kaijo_memo) <= n):
    kaijo_memo.append(kaijo_memo[-1] * len(kaijo_memo) % MOD)
  return kaijo_memo[n]

gyaku_kaijo_memo = []
def gyaku_kaijo(n):
  if(len(gyaku_kaijo_memo) > n):
    return gyaku_kaijo_memo[n]
  if(len(gyaku_kaijo_memo) == 0):
    gyaku_kaijo_memo.append(1)
  while(len(gyaku_kaijo_memo) <= n):
    gyaku_kaijo_memo.append(gyaku_kaijo_memo[-1] * pow(len(gyaku_kaijo_memo),MOD-2,MOD) % MOD)
  return gyaku_kaijo_memo[n]

def nCr(n,r):
  if(n == r):
    return 1
  if(n < r or r < 0):
    return 0
  ret = 1
  ret = ret * kaijo(n) % MOD
  ret = ret * gyaku_kaijo(r) % MOD
  ret = ret * gyaku_kaijo(n-r) % MOD
  return ret


def factorization(n):
    arr = []
    temp = n
    for i in range(2, int(-(-n**0.5//1))+1):
        if temp%i==0:
            cnt=0
            while temp%i==0:
                cnt+=1
                temp //= i
            arr.append([i, cnt])
    if temp!=1:
        arr.append([temp, 1])

    if arr==[]:
        arr.append([n, 1])
    return arr


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





A,B,T = inputIL()

print((T//A)*B)

Solution (Python):
import sys
import math
import bisect

def main():
    a, b, t = map(int, input().split())
    ans = t // a * b
    print(ans)
    
if __name__ == "__main__":
    main()

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

Solution (Python):
from operator import itemgetter
import sys
sys.setrecursionlimit(1000000)


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

cookie = (t+0.5) // a

print(int(b*cookie))

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

Solution (Python):
from collections import defaultdict, deque, Counter
from heapq import heappush, heappop, heapify
from itertools import permutations, accumulate, combinations, combinations_with_replacement
from math import sqrt, ceil, floor, factorial
from bisect import bisect_left, bisect_right, insort_left, insort_right
from copy import deepcopy
from operator import itemgetter
from functools import reduce
from fractions import gcd
import sys
def I(): return int(input())
def Is(): return map(int, input().split())
def LI(): return list(map(int, input().split()))
def TI(): return tuple(map(int, input().split()))
def IR(n): return [I() for _ in range(n)]
def LIR(n): return [LI() for _ in range(n)]
def TIR(n): return [TI() for _ in range(n)]
def S(): return input()
def Ss(): return input().split()
def LS(): return list(input())
def SR(n): return [S() for _ in range(n)]
def SsR(n): return [Ss() for _ in range(n)]
def LSR(n): return [LS() for _ in range(n)]
sys.setrecursionlimit(10**6)
MOD = 10**9+7
INF = float('inf')


a, b, t = Is()
n = (t+0.5)//a
print(int(b*n))

Solution (Python):
import sys
from bisect import insort_left
def input(): return sys.stdin.readline().strip()


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



if __name__ == "__main__":
    main()

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


if __name__ == '__main__':

    ABC_125_A()

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

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

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

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

if __name__ == '__main__':
    main()

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

Solution (Python):
import itertools
import math
a, b, t = map(int, input().split())
sum = 0
for i in range(1,21):
    if a * i <= t:
        sum += b
print(sum)

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

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

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

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

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

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

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

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

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

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

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

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

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

Solution (Python):



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

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

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

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

Solution (Python):


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

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

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

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

Solution (Python):
def biscuit_generator(a, b, t):

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

if __name__ == '__main__':
    main()

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

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

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

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

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

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

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

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

print(B * (T // A))

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

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

for i in range(1,t+1):
    
    if a*i<t+0.5:
        count+=b
print(count)

Solution (Python):
a,b,c=map(int,input().split())
n=len([i for i in range(1,c+1) if i%a==0])
print(b*n)

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

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

print(int(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())
if a > t:
    print("0")
else:
    s = t//a
    print(b*s)

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

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

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

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

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

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

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

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())
c=0
for i in range(T//A):
    c+=B
print(c)

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

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

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

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())
count = t//a

bis =  b * count
print(bis)

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

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

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

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

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

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