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
input = sys.stdin.readline


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

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

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

Solution (Python):


A,B,T = [int(x) for x in input().split()]
count = A
ans = 0
while count < T+0.5:
    ans += B
    count += A

print(ans)

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

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

s = 0
for i in range(a, t+1, a):
    s += b

print(s)

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

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

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

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

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

print(int(T/A) * B )

Solution (Python):
a, b, t = list(map(int, input().split(' ')))
x = 1
ans = 0
while True:
    if x * a < t + 0.5:
        ans += b
        x += 1
    else:
        break

print(ans)

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

print(T // A * B)

Solution (Python):
def getInt(): return int(input())
def getIntList(): return [int(x) for x in input().split()]
def zeros(n): return [0]*n

class Debug():
    def __init__(self):
        self.debug = True
 
    def off(self):
        self.debug = False
 
    def dmp(self, x, cmt=''):
        if self.debug:
            if cmt != '':
                w = cmt + ': ' + str(x)
            else:
                w = str(x)
            print(w)
        return x

def prob():
    d = Debug()
    d.off()
    A, B, T = getIntList()
    d.dmp((A, B, T),'A, B, T')
    return T//A*B

ans = prob()
print(ans)

Solution (Python):




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


ans = int(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())

p=(t+0.5)//a

print(int(p*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 = 0
i = A
while i <= T:
    ans += B
    i += A
print(ans)

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

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

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

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

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

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

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

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

Solution (Python):

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

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

Solution (Python):
from sys import stdin

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

time = A
res = 0

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

print(res)

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

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

Solution (Python):
A,B,T = [int(i) for i in input().split()]
if 1 <= A and B and T <= 20:
    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())
time=A
ans=0
while time<=T:
  ans=ans+B
  time=time+A
  
print(ans)

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

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

print(cnt*B)

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

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

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

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

print((t // a) * b)

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

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

print(i[1] * int(i[2]/i[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,c=input().split()
a=int(a)
b=int(b)
c=int(c)
t=c//a
count=0
for i in range(t):
    count+=b
print(count)

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

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

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

Solution (Python):
"""
ビスケット生産装置を起動すると、起動してから A 秒後、2A 秒後、3A 秒後、... (A の倍数秒後) に B

枚ずつビスケットを生産します。

ビスケット生産装置を起動してから T+0.5
秒後までに生産されるビスケットの合計枚数を求めてください。

return int(T/A) * B

test : A = 3 , B = 2 , T = 6
kotae : 4
"""

s = input().split(" ")
s = [int(s[i]) for i in range(3)]
A = s[0]
B = s[1]
T = s[2]
print(int(T/A) * B)

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

print(b*(t//a))

Solution (Python):
import sys

stdin = sys.stdin

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

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

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

print(ans)

Solution (Python):

import sys


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

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

print(int(T / A)* B)

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

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

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

print(res)

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())
F = T // A
print(F * 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 = 0
i = 0
while True:
    i += A
    if i <= T + 1/2:
        ans += B
    else:
        break
print(ans)

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

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

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

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

Solution (Python):

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

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 = 0
ans = 0
while(1):
  time+=A
  if time>T+0.5:
    break
  else:
    ans+=B
print(ans)

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

Ans = (T // A) * B

print(Ans)

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

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

print(T // A * B)

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

count = 0
a_ = A

while a_ <= T+0.5:
    count += B
    a_ += 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(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())

ans = 0
count = 0

while True:
    count += A
    if count > T:
        break
    ans += B

print(ans)

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

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

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

mul = (t + 0.5) // a

print(int(b * mul))

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

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

print(b * (t // a))

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

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

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

print((T // A) * B)

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

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

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

print(t//a * b)

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

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

T = T + 0.5

times = int(T // A)

out = B * times

print(out)

Solution (Python):
A, B, T = [int(c) for c in input().split()]
print(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(int(B* (T//A)))

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

if __name__ == '__main__':
    main()

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

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

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


print(t//a*b)

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

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

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

C = int(T / A)

print(C * B)

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

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

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

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

print(m*B)

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

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

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

Solution (Python):
from sys import stdin

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

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

input = lambda: stdin.readline()
main()

Solution (Python):


import sys

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

def main(A, B, T):
    n = int((T + 0.5) / A) * B
    print(n)

A, B, T = i2nn()
main(A, B, T)

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

Solution (Python):


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

tt=t+0.5

print((int)(tt/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())

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

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

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

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

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

Solution (Python):
a,b,t = map(int,input().split())
c=0
time = 0
while time<=t:
  time+=a
  if time>t:
    break
  c+=b
print(c)

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

d = int(inp[2]) // int(inp[0])
c = d * int(inp[1])

print(c)

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

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

lim = t + 0.5

print(int(lim / a)*b)

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

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

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

print(T//A * B)

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

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

Solution (Python):

import sys

import heapq
import re
import bisect
import random
import math
import itertools
from collections import defaultdict, deque
from copy import deepcopy
from decimal import *

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

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

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

Solution (Python):
"""
python3 main.py < input.txt
"""
import math
import itertools as it
import heapq

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

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

Solution (Python):


def main():
    a, b, t = [int(i) for i in input().split()]
    
    ans = 0
    for i in range(t):
        if (i+1)%a == 0:
            ans += b

    print(ans)

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

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

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

Solution (Python):

import sys
import math
import numpy as np
import itertools



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

print(b* (t//a))

Solution (Python):
import sys

def main():
    input = sys.stdin.readline
    A, B, T = map(int, input().split())
    n = T // A
    return n * B


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

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

Solution (Python):


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

ans = 0
time = a
while time < t + 0.5:
    ans += b
    time += a
print(ans)

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

ans = 0
time = A

while time < T+0.5:
    ans += B
    time += A

print(ans)

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

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

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

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


main()

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

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

Solution (Python):

"""
Created on Sat Apr 20 20:47:47 2019

@author: Owner
"""


"""
Created on Sat Apr 13 09:53:12 2019

@author: Owner
"""

import numpy as np
import sys
""""
import collections
import scipy.misc
import sys
import numpy as np
import math
from operator import itemgetter
import itertools
import copy
import bisect
"""


def prime_decomposition(n):
  i = 2
  table = []
  while i * i <= n:
    while n % i == 0:
      n /= i
      table.append(int(i))
    i += 1
  if n > 1:
    table.append(int(n))
  return table   

def digit(i):
    if i > 0:
        return digit(i//10) + [i%10]
    else:
        return []
    
def getNearestValueIndex(list, num):
    """
    概要: リストからある値に最も近い値のインデックスを取得する関数
    @param list: データ配列
    @param num: 対象値
    @return 対象値に最も近い値
    """

    
    idx = np.abs(np.asarray(list) - num).argmin()
    return idx

def find_index(l, x, default=False):
    if x in l:
        return l.index(x)
    else:
        return default


"""
N, X = map(int, input().split())

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

P = [0]*N
Y = [0]*N
for n in range(N):
    P[n], Y[n] = map(int, input().split())


dp = np.zeros((N+1, 4,4,4))
    
all(nstr.count(c) for c in '753')


ABT = zip(A, B, totAB)
result = 0

sorted(ABT,key=itemgetter(2))
A, B, totAB = zip(*ABT)
A.sort(reverse=True)


(x >> i) & 1


dp = [np.inf]*N
for n in range(N):
    if n == 0:
        dp[n] = 0
    else:
        for k in range(1,K+1):
            if n-k >= 0:
                dp[n] = min(dp[n], dp[n-k] + abs(h[n]-h[n-k]))
            else:
                break

add = 1 
res = 0
sums = [0]*(len(nums)+1)
for i in range(len(nums)):
    sums[i+1] = sums[i] + nums[i]
for i in range(0, len(nums), 2):
    left = i
    right = min(i+add, len(nums))
    tmp = sums[right] - sums[left]
    res = max(tmp, res)


li, ri = bisect.bisect_left(p_ac, l[i]-1), bisect.bisect_right(p_ac, r[i]-1)    


org_list = [3, 1, 4, 5, 2]
new_list = sorted(org_list)
print(org_list)
print(new_list)



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

def main():
    print((T//A)*B)
    
if __name__ == '__main__':
    main()

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

print((t//a) * b)

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

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

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

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

Solution (Python):


def readInts():
  return [int(s) for s in input().split(" ")]

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

if __name__ == "__main__":
  main()

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

print(int(T / A) * B)

Solution (Python):


import sys
 
input = sys.stdin.readline
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(int((T+0.5)//A*B))

Solution (Python):
from sys import stdin
A,B,T=[int(x) for x in stdin.readline().rstrip().split()]
ans=(T//A)*B
print(ans)

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

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

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

print(int(c/a) * b)

Solution (Python):
import math

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

Solution (Python):



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


if __name__ == "__main__":
    main()

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

Solution (Python):


import numpy as np
import math
import re

n = input()
n = re.split(" ",n)

x = int(int(n[2])/int(n[0]))

print(x*int(n[1]))

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

Solution (Python):
def main():
    A, B, T = [int(n) for n in input().split()]
    time = A
    res = 0
    while True:
        if time > T + 0.5:
            break
        res += B
        time += A
    print(res)
main()

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


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

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

Solution (Python):

import sys
import math
from bisect import bisect_left
from bisect import bisect_right
import collections
input = sys.stdin.readline




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

	tmp = T // A
	ans = tmp * B


	print(ans)
	
if __name__ == "__main__":
	main()

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

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

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

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

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

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

print '{}'.format( int((T+0.5)/A) * B)

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

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

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

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

print(t//a * b)

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

print(B * (T//A))

Solution (Python):

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

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

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

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

print((T // A) * B)

Solution (Python):


import sys


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

def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x) - 1 for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def II(): return int(sys.stdin.readline())
def SI(): return input()


def main():
    a, b, t = LI()
    res = 0
    for i in range(a, 21, a):
        if i < t + 0.5:
            res += b

    return res


print(main())

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

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

now = 0
for i in range(a, 1000, a):
    if i >= t + 0.5:
        break
    now += b
print(now)

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

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

ans = 0
time = 0
while True:
    time += A
    if time > T:
        break
    ans += B
print(ans)

Solution (Python):
import math
a, b, t = (int(i) for i in input().split())  
print(math.floor(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())

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

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

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

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

n = int(float(T+0.5)/A) * B

print(n)

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

t = t + 0.5
ans = 0
while t > a:
    ans += b
    t -= a

print(ans)

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

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

ans = 0
t = 0

while True:
    t += A
    if t > T +0.5:
        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())
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((T//A)*B)

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

Solution (Python):
from sys import stdin

a, b, t = [int(x) for x in stdin.readline().rstrip().split()]

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

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

s = (T + 0.5) // A

ans = int(s * B)

print(ans)

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

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

Solution (Python):
a,b,c = map(int,input().split())
print(c//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, n = [int(i) for i in input().split(" ")]
print(n // a * b)

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

print(T // A * B)

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

Solution (Python):

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

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

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

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

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

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

print(T // A * B)

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

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

Solution (Python):
import math

a, b, t = [int(i) for i in input().split(" ")]
print(b * math.floor(t / a))

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

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

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

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

print(c // a * b  )

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

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

print(b * int(t / a))

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

print((t//a)*b)

Solution (Python):
import math
A,B,T = map(int,(input().split()))
ans = B * math.floor(T/A)
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):
abt  = list(map(int,input().split()))
a=abt[0]
b=abt[1]
t=abt[2]
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(t//a*b)

Solution (Python):
from sys import stdin
import math

a, b, t = [int(x) for x in stdin.readline().rstrip().split()]

sum = math.floor(t / a) * b

print(sum)

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

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

print(c // a * b)

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

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

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

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

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

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

print((t//a)*b)

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

bis = 0
time = 0
while True :
    time += A
    if time < T + 0.5 :
        bis += B
    else :
        break
print(bis)

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

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

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

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

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

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

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

Solution (Python):


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

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