Problem:
 Score : 100 points    Problem Statement A biscuit making machine produces B biscuits at the following moments: A seconds, 2A seconds, 3A seconds and each subsequent multiple of A seconds after activation.  Find the total number of biscuits produced within T + 0.5 seconds after activation.      Constraints  All values in input are integers.  1 \leq A, B, T \leq 20         Input Input is given from Standard Input in the following format:  A  B  T       Output Print the total number of biscuits produced within T + 0.5 seconds after activation.        Sample Input 1 3 5 7      Sample Output 1 10   Five biscuits will be produced three seconds after activation.  Another five biscuits will be produced six seconds after activation.  Thus, a total of ten biscuits will be produced within 7.5 seconds after activation.        Sample Input 2 3 2 9      Sample Output 2 6       Sample Input 3 20 20 19      Sample Output 3 0

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

print((T//A)*B)

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

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

print(cnt)

Solution (Python):


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

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

if __name__ == "__main__":
    solve()

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
for i in range(t + 1):
    if i % a == 0 and i != 0:
        ans = ans + b
print(ans)

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

print((c // a) * b)

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

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

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

Solution (Python):


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

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

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

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

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

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

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

Solution (Python):
import atexit
import io
import sys

buff = io.BytesIO()
sys.stdout = buff


@atexit.register
def write():
    sys.__stdout__.write(buff.getvalue())

a,b,t = map(int, raw_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())
time = (t+0.5) // a
print(int(time*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=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=[int(i) for i in 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(b*(t//a))

Solution (Python):

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

print(T//A * B)

Solution (Python):
import sys
input = sys.stdin.readline
a,b,t = input().split()
a = int(a)
b = int(b)
t = int(t)
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())

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

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

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

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

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

print((t//a)*b)

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

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

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

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

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

Solution (Python):
import sys






"""Template"""


class IP:
    """
    入力を取得するクラス
    """

    def __init__(self):
        self.input = sys.stdin.readline

    def I(self):
        """
        1文字の取得に使います
        :return: int
        """
        return int(self.input())

    def S(self):
        """
        1文字の取得(str
        :return: str
        """
        return self.input()

    def IL(self):
        """
        1行を空白で区切りリストにします(int
        :return: リスト
        """
        return list(map(int, self.input().split()))

    def SL(self):
        """
        1行の文字列を空白区切りでリストにします
        :return: リスト
        """
        return list(map(str, self.input().split()))

    def ILS(self, n):
        """
        1列丸々取得します(int
        :param n: 行数
        :return: リスト
        """
        return [int(self.input()) for _ in range(n)]

    def SLS(self, n):
        """
        1列丸々取得します（str
        :param n: 行数
        :return: リスト
        """
        return [self.input() for _ in range(n)]

    def SILS(self, n):
        """
        Some Int LineS
        横に複数、縦にも複数
        :param n: 行数
        :return: list
        """
        return [self.IL() for _ in range(n)]

    def SSLS(self, n):
        """
        Some String LineS
        :param n: 行数
        :return: list
        """
        return [self.SL() for _ in range(n)]


class Idea:
    def __init__(self):
        pass

    def HF(self, p):
        """
        Half enumeration
        半分全列挙です
        pの要素の和の組み合わせを作ります。
        ソート、重複削除行います
        :param p: list : 元となるリスト
        :return: list : 組み合わせられた和のリスト
        """
        return sorted(set(p[i] + p[j] for i in range(len(p)) for j in range(i, len(p))))

    def Bfs2(self, a):
        """
        bit_full_search2
        bit全探索の改良版
        全探索させたら2進数のリストと10進数のリストを返す
        :return: list２つ : １個目 2進数(16桁)  2個目 10進数
        """
        
        
        
        value = []
        for i in range(1 << len(a)):
            output = []

            for j in range(len(a)):
                if self.bit_o(i, j):
                    """右からj+1番目のiが1かどうか判定"""
                    
                    output.append(a[j])
            value.append([format(i, 'b').zfill(16), sum(output)])

        value.sort(key=lambda x: x[1])
        bin = [value[k][0] for k in range(len(value))]
        val = [value[k][1] for k in range(len(value))]
        return bin, val

    def S(self, s, r=0, m=-1):
        """
        ソート関係行います。色々な設定あります。
        :param s: 元となるリスト
        :param r: reversするかどうか 0=False 1=True
        :param m: （2次元配列）何番目のインデックスのソートなのか
        :return: None
        """
        r = bool(r)
        if m == -1:
            s.sort(reverse=r)
        else:
            s.sort(reverse=r, key=lambda x: x[m])

    def bit_n(self, a, b):
        """
        bit探索で使います。0以上のときにTrue出します
        自然数だからn
        :param a: int
        :param b: int
        :return: bool
        """
        return bool((a >> b & 1) > 0)

    def bit_o(self, a, b):
        """
        bit探索で使います。1のときにTrue出すよ
        oneで1
        :param a: int
        :param b: int
        :return: bool
        """
        return bool(((a >> b) & 1) == 1)

    def ceil(self, x, y):
        """
        Round up
        小数点切り上げ割り算
        :param x: int
        :param y: int
        :return: int
        """
        return -(-x // y)

    def ave(self, a):
        """
        平均を求めます
        :param a: list
        :return: int
        """
        return sum(a) / len(a)

    def gcd(self, x, y):
        if y == 0:
            return x
        else:
            return self.gcd(y, x % y)


"""ここからメインコード"""


def main():
    
    r, e, p = range, enumerate, print
    ip = IP()
    id = Idea()
    mod = 10 ** 9 + 7

    """この下から書いてね"""
    a, b, t = ip.IL()
    print(int(((t+0.5) // a) * b))


main()

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

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

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

result = int(t/a) * b

print(result)

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

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

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

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

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

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

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

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

tmp = (T+0.5) // A

print(int(B*tmp))

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

T = T + 0.5

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

Solution (Python):
from bisect import bisect_left, bisect_right
from collections import Counter, defaultdict, deque, OrderedDict
from copy import deepcopy
from fractions import gcd
from functools import lru_cache, reduce
from math import ceil, floor
from sys import setrecursionlimit

import heapq
import itertools
import operator



inf = float('inf')
N = 0


def set_inputs():
    global N
    return


def main():
    setrecursionlimit(100000)
    set_inputs()
    
    a, b, t = get_li()
    print((t // a) * b)
    return


def get_int():
    return int(input())


def get_float():
    return float(input())


def get_str():
    return input().strip()


def get_li():
    return [int(i) for i in input().split()]


def get_lf():
    return [float(f) for f in input().split()]


def get_lc():
    return list(input().strip())


def get_data(n, types, sep=None):
    if len(types) == 1:
        return [types[0](input()) for _ in range(n)]
    return list(zip(*(
        [t(x) for t, x in zip(types, input().split(sep=sep))]
        for _ in range(n)
    )))


if __name__ == '__main__':
    main()

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(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):
def main():
    input = sys.stdin.readline
    try:
        a,b,t = map(int, input().split())
        result = 0
        for i in range(a, t+1, a):
            result += b
        print(result)

    finally:
        input = None

import sys; sys.setrecursionlimit(50000)
if __name__ == "__main__":
    main()

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

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

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

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

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

print(ans)

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

print(int(T/A) * B)

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

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

print(b * (t // a))

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

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

print(T//A*B)

Solution (Python):

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

print(b*(c//a))

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

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

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

val = int(T / A)

print (B * val)

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

res = (n//a)*b 

print(res)

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

print(int(t / a) * b)

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

Solution (Python):
a, b, t = [int(item) for item in 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())

x = t//a

print(x*b)

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

Solution (Python):
from heapq import heappush,heappop
import queue
import re

def int_raw():
    return int(input())

def ss_raw():
    return input().split()

def ints_raw():
    return list(map(int, ss_raw()))

INF = 1<<29

def make1d_arr(n,val=INF):
    return [val for i in range(n)]

def make2d_arr(h,w,val =INF):
    return [[val for i in range(w)]for i in range(h)]


A,B,T = ints_raw()


def main():

    return (T//A)*B
    
print(main())

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

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

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

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

print(ans)

Solution (Python):

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

print(t // a * b)

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

num = t//a

print(b*num)

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

print(int(t/a)*b)

Solution (Python):

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

Solution (Python):


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

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

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

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

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

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

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

Solution (Python):
A,B,T = map(int, raw_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, os

f = lambda:list(map(int,input().split()))
if 'local' in os.environ :
    sys.stdin = open('./input.txt', 'r')

def solve():
    a,b,t = f()
    print(t//a *b)

solve()

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

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

ans = t//a
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((t+0.5)//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):
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 = (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())
num = 0
for _ in range(A, T + 1, A):
    num += B
print(num)

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

Solution (Python):
from functools import reduce
import math

def main():
    
    
    
    

    
    
    
    
    
    

    
    

    
    
    
    
    
    
    
    
    
    INF = float("inf")

    
    MOD = 10**9+7
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    

    
    
    
    
    a, b, t = (int(_) for _ in input().split())
    
    print((t//a)*b)
    
if __name__ == '__main__':
    main()

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):
import sys

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

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

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

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

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

print(int(c/a) *b)

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

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


main()

Solution (Python):
import sys
stdin = sys.stdin
 
sys.setrecursionlimit(10**5) 
 
def li(): return map(int, stdin.readline().split())
def li_(): return map(lambda x: int(x)-1, stdin.readline().split())
def lf(): return map(float, stdin.readline().split())
def ls(): return stdin.readline().split()
def ns(): return stdin.readline().rstrip()
def lc(): return list(ns())
def ni(): return int(stdin.readline())
def nf(): return float(stdin.readline())

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

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

Solution (Python):


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

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

Solution (Python):

import copy
import random
import bisect 
import fractions 
import math

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

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

Solution (Python):
def input_ints():
    return list(map(int, input().split()))

def main():
    a, b, t = input_ints()
    print(t // a * b)

if __name__ == '__main__':
    main()

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

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

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

Solution (Python):

import sys


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



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

if __name__ == '__main__':
    main()

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

Solution (Python):
import sys

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

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


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

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

print(B * (T // A))

Solution (Python):

from __future__ import division, print_function

import os
import sys
from io import BytesIO, IOBase

if sys.version_info[0] < 3:
    from __builtin__ import xrange as range
    from future_builtins import ascii, filter, hex, map, oct, zip
else:
    _str = str
    str = lambda x=b"": x if type(x) is bytes else _str(x).encode()


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




BUFSIZE = 8192


class FastIO(IOBase):
    newlines = 0

    def __init__(self, file):
        self._buffer = BytesIO()
        self._fd = file.fileno()
        self._writable = "x" in file.mode or "r" not in file.mode
        self.write = self._buffer.write if self._writable else None

    def read(self):
        if self._buffer.tell():
            return self._buffer.read()
        return os.read(self._fd, os.fstat(self._fd).st_size)

    def readline(self):
        while self.newlines == 0:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            self.newlines = b.count(b"\n") + (not b)
            ptr = self._buffer.tell()
            self._buffer.seek(0, 2), self._buffer.write(b), self._buffer.seek(ptr)
        self.newlines -= 1
        return self._buffer.readline()

    def flush(self):
        if self._writable:
            os.write(self._fd, self._buffer.getvalue())
            self._buffer.truncate(0), self._buffer.seek(0)


class ostream:
    def __lshift__(self, a):
        if a is endl:
            sys.stdout.write(b"\n")
            sys.stdout.flush()
        else:
            sys.stdout.write(str(a))
        return self


def print(*args, **kwargs):
    sep, file = kwargs.pop("sep", b" "), kwargs.pop("file", sys.stdout)
    at_start = True
    for x in args:
        if not at_start:
            file.write(sep)
        file.write(str(x))
        at_start = False
    file.write(kwargs.pop("end", b"\n"))
    if kwargs.pop("flush", False):
        file.flush()


sys.stdin, sys.stdout = FastIO(sys.stdin), FastIO(sys.stdout)
cout, endl = ostream(), object()

readline = sys.stdin.readline
readlist = lambda var=int: [var(n) for n in readline().split()]
input = lambda: readline().rstrip(b"\r\n")



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

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

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

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

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

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

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

print((T//A) * B)

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

Solution (Python):
from sys import exit
A,B,C = [int(n) for n in input().split()]






print((C//A)*B)

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

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

Solution (Python):
from statistics import mean, median,variance,stdev
import numpy as np
import sys
import math
import fractions
import itertools
import copy
import collections
from operator import itemgetter

def j(q):
    if q==1: print("Yes")
    else:print("No")
    exit(0)


def ct(x,y):
    if (x>y):print("+")
    elif (x<y): print("-")
    else: print("?")

def ip():
    return int(input())
def printrow(a):
    for i in range(len(a)):
        print(a[i])
def combinations(n,r):
    if n<r:return 0
    return math.factorial(n) // (math.factorial(n - r) * math.factorial(r))
def permutations(n,r):
    if n<r:return 0
    return math.factorial(n) // math.factorial(n - r)


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









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

Solution (Python):

import sys
INF = float("inf")


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


def main():

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


if __name__ == '__main__':
    main()

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

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

result = T // A * B

print(result)

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

Solution (Python):
import sys
stdin = sys.stdin
 
ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))
nn = lambda: list(stdin.readline().split())
ns = lambda: stdin.readline().rstrip()

a,b,t = na()

print(t//a*b)

Solution (Python):

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

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

Solution (Python):


from collections import deque
import itertools as it
import sys
import math

sys.setrecursionlimit(1000000)

INF = 10 ** 18
MOD = 10 ** 9 + 7

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

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

Solution (Python):
import sys,collections as cl
Max = sys.maxsize
def l():
	return list(map(int,input.split()))
def m():
	return map(int,input().split())
def s(x):
	a = []
	aa = x[i]
	su = 1
	for i in range(len(x)-1):
		if aa == x[i+1]:
			a.append([aa,su])
			aa = x[i+1]
			su = 1
		else:
			su += 1
	a.append([aa,su])
	return a

a,b,t = m()

print((t//a) * b)

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

print(T // A * B)

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

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

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

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

Solution (Python):

import sys
sys.setrecursionlimit(10**9)
input = sys.stdin.readline

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

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

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

Solution (Python):
import collections as c
ip = lambda : map(int, input().split())


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

Solution (Python):
def gcd_core(a, b):
    if b == 0:
        return a
    else:
        return gcd_core(b, a % b)


def gcd(arr):
    g = gcd_core(arr[0], arr[1])
    for i in range(2, len(arr)):
        g = gcd_core(g, arr[i])
    return g

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

print(b*(t//a))