CodeEff/ECCO huggingface dataset:
# Original solution
# coding: utf-8
# Your code here!
class UnionFind:
    def __init__(self, n):
        self.parent = list(range(n))#親ノード
        self.size = [1]*n #グループの要素数

    def root(self, x): #root(x): xの根ノードを返す．
        while self.parent[x] != x:
            self.parent[x] = self.parent[self.parent[x]]
            x = self.parent[x]
        return x 

    def merge(self, x, y): #merge(x,y): xのいるグループと$y$のいるグループをまとめる
        x = self.root(x)
        y = self.root(y)
        if x == y:
            return False
        if self.size[x] < self.size[y]: 
            self.size[y] += self.size[x] #yの要素数を更新
            self.parent[x] = y #xをyにつなぐ
        else:
            self.size[x] += self.size[y] #xの要素数を更新
            self.parent[y] = x #yをxにつなぐ
        return True

    def issame(self, x, y): #same(x,y): xとyが同じグループにあるならTrue
        return self.root(x) == self.root(y)
        
    def size(self,x): #size(x): xのいるグループの要素数を返す
        return self.size[self.root(x)]


n,m = [int(i) for i in input().split()]
 
T=UnionFind(n)
c=0
for _ in [0]*m:
    x,y,z=[int(i) for i in input().split()]
    if T.merge(x-1,y-1):
        c+=1
 
print((n-c))

# Optimized solution
class UnionFind:
    def __init__(self, size):
        self.parent = [-1]*size #非負なら親ノード，負ならグループの要素数

    def root(self, x): #root(x): xの根ノードを返す．
        if self.parent[x] < 0:
            return x
        elif self.parent[self.parent[x]] < 0:
            return self.parent[x]
        else:
            self.parent[x] = self.root(self.parent[x]) #xをxの根に直接つなぐ
            return self.parent[x]

    def merge(self, x, y): #merge(x,y): xのいるグループと$y$のいるグループをまとめる
        x = self.root(x)
        y = self.root(y)
        if x == y:
            return False
        if self.parent[x] > self.parent[y]: #xの要素数がyの要素数より「小さい」とき入れ替える
            x,y=y,x
        self.parent[x] += self.parent[y] #xの要素数を更新
        self.parent[y] = x #yをxにつなぐ
        return True

    def issame(self, x, y): #same(x,y): xとyが同じグループにあるならTrue
        return self.root(x) == self.root(y)
        
    def size(self,x): #size(x): xのいるグループの要素数を返す
        return -self.parent[self.root(x)]
        
        
n,m = [int(i) for i in input().split()]

T=UnionFind(n)
c=0
for _ in [0]*m:
    x,y,z=[int(i) for i in input().split()]
    if T.merge(x-1,y-1):
        c+=1

print((n-c))
# Original solution
class UnionFind:
    def __init__(self, n):
        self.par = [i for i in range(n+1)]
        self.rank = [0] * (n+1)

    # 検索
    def find(self, x):
        if self.par[x] == x:
            return x
        else:
            self.par[x] = self.find(self.par[x])
            return self.par[x]

    # 併合
    def union(self, x, y):
        x = self.find(x)
        y = self.find(y)
        if self.rank[x] < self.rank[y]:
            self.par[x] = y
        else:
            self.par[y] = x
            if self.rank[x] == self.rank[y]:
                self.rank[x] += 1

    # 同じ集合に属するか判定
    def same_check(self, x, y):
        return self.find(x) == self.find(y)
N,M=list(map(int,input().split()))
a=UnionFind(N)
for i in range(M):
    X,Y,Z=list(map(int,input().split()))
    if a.same_check(X,Y):
        pass
    else:
        a.union(X,Y)
answer=set()
for i in range(1,N+1):
    answer.add(a.find(i))
print((len(answer)))


# Optimized solution
class UnionFind:
    def __init__(self, n):
        self.par = [-1]*(n+1)
        self.sizes=[1]*(n+1)

    # 検索
    def find(self, x):
        if self.par[x]<0:
            return x
        else:
            self.par[x] = self.find(self.par[x])
            return self.par[x]

    # 併合
    def union(self, x, y):
        x = self.find(x)
        y = self.find(y)
        if x==y:
            return
        d1=self.par[x]
        d2=self.par[y]
        if d1<=d2:
            self.par[y]=x
            self.sizes[x]=self.sizes[x]+self.sizes[y]
            if d1==d2:
                self.par[x]=self.par[x]-1
        else:
            self.par[x]=y
            self.sizes[y]=self.sizes[x]+self.sizes[y]

    # 同じ集合に属するか判定
    def same_check(self, x, y):
        return self.find(x) == self.find(y)

    #サイズ
    def size(self,x):
        return self.sizes[find(x)]

    #木の数
    def number(self):
        count=0
        for i in self.par[1:]:
            if i<0:
                count=count+1
        return count
        
N,M=list(map(int,input().split()))
U=UnionFind(N)
for i in range(M):
    X,Y,Z=list(map(int,input().split()))
    U.union(X,Y)
print((U.number()))
# Original solution
class UnionFind:
    def __init__(self, n):
        self.n = n
        self.parents = list(range(n + 1))
        self.ranks = [0 for _ in range(n + 1)]

    def get_root(self, x):
        if self.parents[x] == x:
            return x
        self.parents[x] = self.get_root(self.parents[x])
        return self.parents[x]

    def merge(self, x, y):
        x = self.get_root(x)
        y = self.get_root(y)
        if x != y:
            if self.ranks[x] < self.ranks[y]:
                self.parents[x] = y
            else:
                self.parents[y] = x
                if self.ranks[x] == self.ranks[y]:
                    self.ranks[x] += 1


n, m = list(map(int, input().split()))
uf = UnionFind(n)
for _ in range(m):
    x, y, z = list(map(int, input().split()))
    uf.merge(x - 1, y - 1)
res = set()
for i in range(n):
    res.add(uf.get_root(i))
print((len(res)))

# Optimized solution
import sys

input = sys.stdin.readline

ri = lambda: int(eval(input()))
rs = lambda: input().rstrip()
ril = lambda: list(map(int, input().split()))
rsl = lambda: input().rstrip().split()
ris = lambda n: [ri() for _ in range(n)]
rss = lambda n: [rs() for _ in range(n)]
rils = lambda n: [ril() for _ in range(n)]
rsls = lambda n: [rsl() for _ in range(n)]


class UnionFind:
    def __init__(self, n):
        self.n = n
        self.parents = list(range(n))
        self.ranks = [0 for _ in range(n)]

    def get_root(self, x):
        if self.parents[x] == x:
            return x
        self.parents[x] = self.get_root(self.parents[x])
        return self.parents[x]

    def merge(self, x, y):
        x = self.get_root(x)
        y = self.get_root(y)
        if x != y:
            if self.ranks[x] < self.ranks[y]:
                self.parents[x] = y
            else:
                self.parents[y] = x
                if self.ranks[x] == self.ranks[y]:
                    self.ranks[x] += 1


n, m = ril()
uf = UnionFind(n)
for _ in range(m):
    x, y, z = ril()
    uf.merge(x - 1, y - 1)
res = set()
for i in range(n):
    res.add(uf.get_root(i))
print((len(res)))
# Original solution
import sys

input = sys.stdin.readline

ri = lambda: int(eval(input()))
rs = lambda: input().rstrip()
ril = lambda: list(map(int, input().split()))
rsl = lambda: input().rstrip().split()
ris = lambda n: [ri() for _ in range(n)]
rss = lambda n: [rs() for _ in range(n)]
rils = lambda n: [ril() for _ in range(n)]
rsls = lambda n: [rsl() for _ in range(n)]


class UnionFind:
    def __init__(self, n):
        self.n = n
        self.parents = list(range(n))
        self.ranks = [0 for _ in range(n)]

    def get_root(self, x):
        if self.parents[x] == x:
            return x
        self.parents[x] = self.get_root(self.parents[x])
        return self.parents[x]

    def merge(self, x, y):
        x = self.get_root(x)
        y = self.get_root(y)
        if x != y:
            if self.ranks[x] < self.ranks[y]:
                self.parents[x] = y
            else:
                self.parents[y] = x
                if self.ranks[x] == self.ranks[y]:
                    self.ranks[x] += 1


n, m = ril()
uf = UnionFind(n)
for _ in range(m):
    x, y, z = ril()
    uf.merge(x - 1, y - 1)
res = set()
for i in range(n):
    res.add(uf.get_root(i))
print((len(res)))

# Optimized solution
import sys

input = sys.stdin.readline

ri = lambda: int(eval(input()))
rs = lambda: input().rstrip()
ril = lambda: list(map(int, input().split()))
rsl = lambda: input().rstrip().split()
ris = lambda n: [ri() for _ in range(n)]
rss = lambda n: [rs() for _ in range(n)]
rils = lambda n: [ril() for _ in range(n)]
rsls = lambda n: [rsl() for _ in range(n)]


class UnionFind:
    def __init__(self, n):
        self.n = n
        self.parents = list(range(n))
        self.ranks = [0 for _ in range(n)]

    def get_root(self, x):
        if self.parents[x] == x:
            return x
        self.parents[x] = self.get_root(self.parents[x])
        return self.parents[x]

    def merge(self, x, y):
        x = self.get_root(x)
        y = self.get_root(y)
        if x != y:
            if self.ranks[x] < self.ranks[y]:
                self.parents[x] = y
            else:
                self.parents[y] = x
                if self.ranks[x] == self.ranks[y]:
                    self.ranks[x] += 1


n, m = ril()
uf = UnionFind(n)
for _ in range(m):
    x, y, z = ril()
    uf.merge(x - 1, y - 1)
for i in range(n):
    uf.get_root(i)
print((len(set(uf.parents))))
# Original solution
def dfs(g, start):
    global visit
    visiting = [start]
    while visiting:
        v = visiting.pop()
        visit[v] = True
        for v2 in g.get(v,()):
            if v2 in visit or v2 in visiting:
                continue
            visiting.append(v2)

N,M = list(map(int, input().split()))

visit = {}
g = {}
for v in range(1,N+1):
    g[v] = []

for _ in range(M):
    x,y,z = list(map(int, input().split()))
    g[x].append(y)
    g[y].append(x)

count = 0
for v in range(1,N+1):
    if v in visit:
        continue
    dfs(g,v)
    count += 1

print(count)


# Optimized solution
N, M = list(map(int, input().split()))
graph = [[] for i in range(N)]
for i in range(M):
    x, y, z = list(map(int, input().split()))
    x, y = x-1, y-1
    graph[x].append(y)
    graph[y].append(x)
visited = [False for i in range(N)]
def dfs(v):
    Q = []
    visited[v] = True
    Q.append(v)
    while len(Q) > 0:
        v = Q.pop()
        for u in graph[v]:
            if not visited[u]:
                visited[u] = True
                Q.append(u)

count = 0
for i in range(N):
    if not visited[i]:
        dfs(i)
        count += 1
print(count)
# Original solution
import sys
sys.setrecursionlimit(1000000)
N,M = list(map(int,input().split()))
XYZ = [list(map(int,input().split())) for _ in range(M)]

G = [[] for _ in range(N)]
 
for i in XYZ:
    G[i[0]-1].append(i[1])
    G[i[1]-1].append(i[0])
 
check = [False for _ in range(N)]
 
def DFS(G,s):
    check[s-1] = True
    for i in G[s-1]:
        if not check[i-1]:         
            DFS(G,i)
ans = 0
for i in range(N):
    if not check[i]:
        DFS(G,i+1)
        ans += 1

print(ans)


# Optimized solution
import sys
sys.setrecursionlimit(1000000)
N, M = list(map(int, input().split()))
X = [0] * M
Y = [0] * M
Z = [0] * M 
for i in range(M):
  X[i], Y[i], Z[i] = list(map(int, input().split()))

reach = [[] for _ in range(N)]

for i in range(M) :
    reach[Y[i]-1].append(X[i])
    reach[X[i]-1].append(Y[i])

approach = [False for _ in range(N)]

def change(reach, s):       
    approach[s-1] = True
    for i in reach[s-1]:
        if not approach[i-1] :
            change(reach, i)

ans = 0
for i in range(N) :
    if not approach[i]:
        change(reach, i+1)
        ans += 1

print(ans)
# Original solution
import sys
sys.setrecursionlimit(10**7)

def update(v):
    for nv in con[v]:
        if seen[nv]:
            continue
        seen[nv]=1
        update(nv)

N,M=list(map(int,input().split()))
seen=[0]*N
con=[[] for i in range(N)]
cnt=[[i,0] for i in range(N)]
for i in range(M):
    X,Y,Z=list(map(int,input().split()))
    X,Y=X-1,Y-1
    con[X].append(Y)
    con[Y].append(X)
    cnt[X][1]+=1
    cnt[Y][1]+=1
cnt.sort(key=lambda x:x[1],reverse=True)
ans=0
for i,a in cnt:
    if(seen[i]):
        continue
    ans+=1
    seen[i]=1
    update(i)
print(ans)

# Optimized solution
import sys
sys.setrecursionlimit(10**7)

def update(v):
    for nv in G[v]:
        if seen[nv]:
            continue
        seen[nv]=1
        update(nv)

N,M=list(map(int,input().split()))
seen=[0]*N
G=[[] for i in range(N)]
for i in range(M):
    X,Y,Z=list(map(int,input().split()))
    X,Y=X-1,Y-1
    G[X].append(Y)
    G[Y].append(X)
ans=0
for i in range(N):
    if(seen[i]):
        continue
    ans+=1
    seen[i]=1
    update(i)
print(ans)
# Original solution
n,m=list(map(int,input().split()))

parent=[i for i in range(n)]
rank=[0 for i in range(n)]

def find(a):
  if parent[a]==a:
    return a
  else:
    return find(parent[a])

def union(a,b):
  ar=find(a)
  br=find(b)
  if ar==br:
    return
  if rank[a]>rank[b]:
    parent[br]=ar
  else:
    parent[ar]=br
    if rank[a]==rank[b]:
      rank[a]+=1
      
def same(a,b):
  ar=find(a)
  br=find(b)
  return ar==br

q=[None]*m

for i in range(m):
  x,y,z=list(map(int,input().split()))
  q[i]=[x-1,y-1]

for i in range(len(q)):
  union(q[i][0],q[i][1])
  
roots=[0]*len(parent)
for i in range(len(parent)):
  roots[i]=find(i)

print((len(set(roots))))


# Optimized solution
import sys
read=sys.stdin.read
readline=sys.stdin.readline
readlines=sys.stdin.readlines

# 0-indexed
class UnionFind:
  N=0
  parent=None
  size=None
  def __init__(self,N):
    self.N=N
    self.parent=[i for i in range(self.N)]
    self.size=[1]*self.N
    
  def root(self,x):
    while x!=self.parent[x]:
      self.parent[x]=self.parent[self.parent[x]]
      x=self.parent[x]
    return x
  
  def same(self,x,y):
    return self.root(x)==self.root(y)
  
  def unite(self,x,y):
    x=self.root(x)
    y=self.root(y)
    if x==y:
      return
    if self.size[x]>self.size[y]:
      # 大きい方にくっつける
      self.parent[y]=x
      self.size[x]+=self.size[y]
    else:
      self.parent[x]=y
      self.size[y]+=self.size[x]
      
  def get_group_size(self,x):
    return self.size[self.root(x)]
  
  def get_roots(self):
    r=set()
    for i in range(self.N):
      r.add(self.root(i))
    return r
  
  def show_parent(self):
    print((self.parent))
    
  def show_size(self):
    print((self.size))
    
N,M=list(map(int,readline().split()))
UF=UnionFind(N)
for i in range(M):
  x,y,z=list(map(int,readline().split()))
  UF.unite(x-1,y-1)
  
print((len(UF.get_roots())))
# Original solution
N, M = list(map(int,input().split()))
par = [i for i in range(N+1)]
size = [1 for _ in range(N+1)]

def find(x):
    if par[x] == x:
        return x
    else:
        par[x] = find(par[x])
        return par[x]

def unite(x,y):
    x = find(x)
    y = find(y)
    if x == y:
        return 0
    par[x] = y
    size[y] += size[x]
    size[x] = 0

for i in range(M):
    x, y, z= list(map(int,input().split()))
    unite(x,y)

Ans = 0
for j in size[1:]:
    if j != 0:
        Ans +=1
print(Ans)


# Optimized solution
N, M = list(map(int,input().split()))
par = [i for i in range(N+1)]
size = [1 for _ in range(N+1)]

def find(x):
    if par[x] == x:
        return x
    else:
        par[x] = find(par[x])
        return par[x]

def unite(x,y):
    x = find(x)
    y = find(y)
    if x == y:
        return 1
    par[x] = y
    size[y] += size[x]
    size[x] = 0

for i in range(M):
    x, y, z= list(map(int,input().split()))
    unite(x,y)

Ans = 0
for j in size[1:]:
    if j != 0:
        Ans += 1
print(Ans)
# Original solution

import sys
sys.setrecursionlimit(10**6)

class UnionFind:
    def __init__(self, N):
        self.par = list(range(N))

    def root(self, x):
        if self.par[x] == x:
            return x
        else:
            self.par[x] = self.root(self.par[x])
            return self.par[x]

    def unite(self, x, y):
        rx = self.root(x)
        ry = self.root(y)
        if rx == ry:
            return
        else:
            self.par[rx] = ry

    def same(self, x, y):
        return self.root(x) == self.root(y)

def solve2():
    N, M = [int(_) for _ in input().split()]
    Tree = UnionFind(N)
    for i in range(M):
        Xi, Yi, Zi = [int(_) for _ in input().split()]
        Xi -= 1
        Yi -= 1
        Tree.unite(Xi, Yi)
    UnionSet = set()
    for i in range(N):
        UnionSet.add(Tree.root(i))
    print(len(UnionSet))

if __name__ == '__main__':
    solve2()


# Optimized solution
import sys
sys.setrecursionlimit(10**6)

class MergeFind:
    def __init__(self, N):
        self.par = list(range(N))
        self.num_sets = N

    def root(self, x):
        if self.par[x] == x:
            return x
        else:
            self.par[x] = self.root(self.par[x])
            return self.par[x]

    def unite(self, x, y):
        rx = self.root(x)
        ry = self.root(y)
        if rx == ry:
            return
        else:
            self.par[rx] = ry
            self.num_sets -= 1

    def same(self, x, y):
        return self.root(x) == self.root(y)

    def get_num_sets(self):
        return self.num_sets

def solve3():
    N, M = [int(_) for _ in input().split()]
    Tree = MergeFind(N)
    for i in range(M):
        Xi, Yi, Zi = [int(_) for _ in input().split()]
        Xi -= 1
        Yi -= 1
        Tree.unite(Xi, Yi)
    print(Tree.get_num_sets())

if __name__ == '__main__':
    solve3()
# Original solution
n,m=list(map(int,input().split()))
#union-find
par=[-1]*(n+1)
def find(x):
    if par[x]<0:
        return x
    else:
        par[x]=find(par[x])
        return par[x]
def size(x):
    oya=find(x)
    return -par[oya]
def unite(x,y):
    if find(x)==find(y):
        return False
    else:
        if size(y)>size(x):
            y,x=x,y  #xを大きい親にしておくか
        oya_x=find(x)
        oya_y=find(y)
        par[oya_x]-=size(oya_y)  #xの大きさをyにしておく
        par[oya_y]=oya_x  #yの親をxに
        return True

def is_same(x,y):
    return find(x)==find(y)
for _ in range(m):
    x,y,z=list(map(int,input().split()))
    unite(x,y)
ans_set=set()
for i in range(1,n+1):
    ans_set.add(find(i))
print((len(ans_set)))

# Optimized solution
import sys

input = sys.stdin.buffer.readline
n, m = list(map(int, input().split()))


# union-find
# xの根を求める


def find(x):
    if par[x] < 0:
        return x
    else:
        par[x] = find(par[x])
        return par[x]


# xとyの属する集合の併合
def unite(x, y):
    x = find(x)
    y = find(y)
    if x == y:
        return False
    else:
        # sizeの大きい方をxとする
        if par[x] > par[y]:
            x, y = y, x
        par[x] += par[y]
        par[y] = x
        return True


# xとyが同じ集合か判定
def is_same(x, y):
    return find(x) == find(y)


def size(x):
    return -par[find(x)]


# 初期化
# 根なら-size、子なら親の頂点
par = [-1] * (n + 1)

for _ in range(m):
    x, y, z = list(map(int, input().split()))
    unite(x, y)
ans = 0
for i in range(1, n + 1):
    if i == find(i):
        ans += 1
print(ans)
# Original solution
import sys
import os

ii = lambda: int(sys.stdin.buffer.readline().rstrip())
il = lambda: list(map(int, sys.stdin.buffer.readline().split()))

iss = lambda: sys.stdin.buffer.readline().decode().rstrip()
isn = lambda n: [sys.stdin.buffer.readline().decode().rstrip() for _ in range(n)]


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

    S = iss()
    T = iss()
    
    print(('Yes' if S in T*2 else 'No'))


if __name__ == '__main__':
    main()


# Optimized solution
import sys
import os

ii = lambda: int(sys.stdin.buffer.readline().rstrip())
il = lambda: list(map(int, sys.stdin.buffer.readline().split()))

iss = lambda: sys.stdin.buffer.readline().decode().rstrip()
isn = lambda n: [sys.stdin.buffer.readline().decode().rstrip() for _ in range(n)]


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

    S = iss()
    T = iss()

    tmp = S[len(S) - 1:], S[0:len(S) - 1]
    for s in range(len(S)):
        t = S[s - 1:] + S[0:s - 1]
        if t == T:
            print('Yes')
            exit()

    print('No')


if __name__ == '__main__':
    main()
# Original solution
numerosStr = input().split(" ")
numeros=[]
contador=0
i=0
for j in numerosStr:
    numeros.append(int(j))

A = numeros[0]
B = numeros[1]
T = numeros[2]+0.5

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

# Optimized solution
a,b,t = list(map(int, input().split()))
if a > t:
    print((0))
else:
    tempo = int((t + 0.5) / a)
    print((tempo * b))
# Original solution
a, b, t = [int(x) for x in input().split()]

s = 0
x = a
while x <= t + 0.5:
    s += b
    x += a

print(s)


# Optimized solution
A, B, C = list(map(int, input().split()))

ans = (int(C/A))*B
print(ans)
# Original solution
a,b,t=list(map(int,input().split()))
print((t//a*b))

# Optimized solution
a,b,t=list(map(int,input().split()))
print((int(((t+0.5)//a)*b)))
# Original solution
import itertools
import fractions
def main():
  a,b,t = list(map(int,input().split()))
  
  print((b * (t//a)))
if __name__ == '__main__':
  main()

# Optimized solution
#from statistics import median
#import collections
#aa = collections.Counter(a) # list to list || .most_common(2)で最大の2個とりだせるお a[0][0]
#from fractions import gcd
#from itertools import combinations # (string,3) 3回
#from collections import deque
from collections import defaultdict
#import bisect
#
#    d = m - k[i] - k[j]
#    if kk[bisect.bisect_right(kk,d) - 1] == d:
#
#
#
# pythonで無理なときは、pypyでやると正解するかも！！
#
#

import sys
sys.setrecursionlimit(10000000)
mod = 10**9 + 7
#mod = 9982443453
def readInts():
  return list(map(int,input().split()))
def I():
  return int(eval(input()))
a,b,t = readInts()
ans = 0
time = 0
while True:
    ans += b
    #print(time,t+0.5)
    if time + a > t + 0.5:
        break
    else:
        time += a
print((ans - b))
# Original solution
a,b,c=list(map(int,input().split()))
print(((c//a)*b))

# Optimized solution
a,b,t=list(map(int,input().split()))
print(((t//a)*b))
# Original solution
a,b,t=list(map(int,input().split()))
print(((t//a)*b))

# Optimized solution
a,b,t=list(map(int,input().split()))
print((b*(t//a)))
# Original solution
a,b,t = list(map(int, input().split()))
c = t // a
print((c*b))


# Optimized solution
a,b,t = list(map(int,input().split()))
print((t//a * b))
# Original solution
a,b,c=list(map(int, input().split()))
print((c//a*b))


# Optimized solution
a, b, t = list(map(int, input().split()))
print((t // a * b))
# Original solution
A, B, T = list(map(int, input().split()))

tmp = (T+0.5) // A

print((int(B*tmp)))

# Optimized solution
A, B, T = list(map(int, input().split()))

res = B * (T // A)
print(res)
# Original solution
# T/A * B を出力する
a,b,t = list(map(int,input().split()))
print((b*(t//a)))



# Optimized solution
a,b,c=list(map(int,input().split()))
print(((c//a)*b))
# Original solution
a,b,t = list(map(int,input().split()))
print(((t//a)*b))

# Optimized solution
a,b,t = list(map(int,input().split()))
ans = t//a*b
print(ans)
# Original solution
a, b, t = list(map(int, input().split()))
answer = int(t / a) * b
print(answer)

# Optimized solution
a,b,t=list(map(int,input().split()))
ans=int(t/a)*b
print(ans)
# Original solution
import itertools
import math
a, b, t = list(map(int, input().split()))
sum = 0
for i in range(1,21):
    if a * i <= t:
        sum += b
print(sum)

# Optimized solution
a, b, t = list(map(int, input().split()))

print((b*(t//a)))
# Original solution
A, B, T = list(map(int, input().split()))

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

print(ans)


# Optimized solution
A, B, T = list(map(int, input().split()))

ans = 0

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

print(ans)
# Original solution
a,b,t=list(map(int,input().split()));print((t//a*b))

# Optimized solution
a,b,c=list(map(int,input().split()))
print((c//a*b))
# Original solution
a,b,t = list(map(int,input().split()))
s = t + 0.5
print((int((s // a) * b)))

# Optimized solution
a,b,t=list(map(int,input().split()))
t+=0.5
print((int(b*(t//a))))
# Original solution
a,b,t = list(map(int,input().split()))
print((b*(t//a)))

# Optimized solution
a,b,t = list(map(int,input().split()))

ans = t//a*b
print(ans)
# Original solution
a, b, t = list(map(int, input().split()))
ret = 0
for i in range(a, t + 1, a):
    ret += b
print(ret)


# Optimized solution
a, b, t = list(map(int, input().split()))
print((b * (t // a)))
# Original solution
a, b, t = list(map(int, input().split()))
print((int((t+0.5)/a)*b))


# Optimized solution
a, b, t = list(map(int, input().split()))
print((t//a*b))