Harryxun/stf_run huggingface dataset:
import bisect
from collections import deque
N,M = map(int,input().split())
A = (list(map(int,input().split())))
A.sort()
A = deque(A)
for i in range(M):
  mx = A.pop()
  insert_index = bisect.bisect_left(A,mx//2)
  A.insert(insert_index,mx//2)
print(sum(A))
  


### FIXED CODE ###

N,M = map(int,input().split())
A = list(map(lambda x: int(x)*(-1),input().split()))
import heapq
heapq.heapify(A)
for i in range(M):
  B = heapq.heappop(A)
  heapq.heappush(A,-1*((-B)//2))
print(-sum(A))
N = int(input())
arr = map(int, input().split(' '))
ans = []
for i, num in enumerate(arr)
	if num != 0:
    	ans.append(i+1)
print(''.join(ans))


### FIXED CODE ###

def main():
    n = int(input())
    A = [0] + list(map(int, input().rstrip().split()))
    for i in range(n // 2, 0, -1):  # second half: no multiples
        A[i] = sum(A[i::i]) % 2
    ans = [i for i, j in enumerate(A) if j]
    print(len(ans))  # all cells: [1] -> len() (much faster than sum())
    print(*ans)


if __name__ == "__main__":
    main()
n, k = map(int, input().split(' '))
s = list(map(int, list(input())))

s.append(9)
ran = []
a = 0
i = 1
#ランレングス圧縮
while i < len(s):
    if s[a] == s[i]:
        i +=1
    else:
        ran.append(i-a)
        a = i
        i += 1
ran.append(0)
ran.append(0)
ran.append(0)
b = s[0]
result = []
i = 0
counter = 0
if n/2 <= k:
    print(n)
else:
    while i+2*k <= len(ran)-3:
        if s[counter] == 1:
            result.append(sum(ran[i:2*k+i+1]))
        else:
            result.append(sum(ran[i:2*k+i]))
        counter += ran[i]
        i += 1
    print(max(result))

### FIXED CODE ###

n, k = map(int, input().split())
s = list(map(int, list(str(input()))))
c = 0
ran = [0,0]
for i in range(n):
    if s[c] == s[i]:
        ran[-1] += 1
    else:
        ran.append(i+1)
        c = i
result = []
for i in range(1, len(ran)):
    if s[ran[i-1]] == 1:
        result.append(ran[min(i+2*k,len(ran)-1)]-ran[i-1])
    else:
        result.append(ran[min(i+2*k-1, len(ran)-1)]-ran[i-1])
print(max(result))
K = int(input())
I = sorted(map(int, input().split()))
minX = 1000000
for i in range(I):
  minX = min(minX, abs(sum(I[:-i]) - sum(I[-i:]) ) )
  
print(minX)

### FIXED CODE ###

N = int(input())
I = list(map(int, input().split()))
minX = 10000000000
end = I.pop()
sumI = sum(I)
for i in range(len(I)):
  minX = min(minX, abs(sumI - end ) )
  popped = I.pop()
  sumI -= popped
  end += popped
  
print(minX)
# coding: utf-8
# Your code here!
# from collections import Counter
# from functools import *

def LI():
    return list(map(int,input().split()))

n,k=LI()
a=LI()
b=[1]
visited=[-1]*n
visited[0]=0
# print(visited)

for i in range(k):
    # print(visited)
    nxt=a[b[-1]-1]
    b.append(nxt)
    if visited[nxt-1]==-1:
        visited[nxt-1]=i+1
    else:
        mod=(visited[nxt-1],i+1)
        break
    
# print(visited,b,mod)

ml,mr=mod
shuuki=mr-ml
k=k%shuuki+shuuki
# print(k)

now=1
for i in range(k):
    now=a[now-1]
print(now)


### FIXED CODE ###

n,k=map(int,input().split())
a=[0]+list(map(int,input().split()))

MAX_N=2*10**5
b=[1]
visited=[-1]*(n+10)
for i in range(1,2*MAX_N+1):
    nxt=a[b[-1]]
    b.append(nxt)
        
if k<=n:
    print(b[k])
    exit()
# print(b)  
for i,bi in enumerate(b):
    if visited[bi]==-1:
        visited[bi]=i
    else:
        m=i-visited[bi]
        l=visited[bi]
        break
k=k%m

while k<n:
    k+=m
print(b[k])
a, b = map(int, input().split())

if a*b % 2 == 0:
  return 'Even'
else:
  return 'Odd'

### FIXED CODE ###

a, b = map(int, input().split())
 
if a*b % 2 == 0:
  print('Even')
else:
  print('Odd')
N = int(input())
A = sorted((map(int,input().split())))
A_Max = A[-1]
B = [True]*A_Max

for i in range(N):
    if B[A[i]]:
        for j in range(2, A_Max):
            if A[i]*j > A_Max:
                break
            B[A[i] * j] = False

ans = 0
for i in range(N-1):
    if B[A[i]]:
        if A[i] == A[i+1]:
            B[A[i]] = False
        else:
            ans += 1

print(ans)



### FIXED CODE ###

N = int(input())
A = sorted((map(int,input().split())))
a_Max = A[-1]
B = [0]*a_Max

for a in A:
    if B[a-1] == 0:
        B[a-1] = 1
        for j in range(2,a_Max+1):
            if a*j > a_Max:
                break
            B[a*j-1] = 2
    elif B[a-1] == 1:
        B[a-1] = 2
            
ans = 0
for b in B:
    if b == 1:
        ans += 1

print(ans)
S = input()

if(S == ABC):
	print("ARC")
elif(S == ARC):
	print("ABC")



### FIXED CODE ###

S = input()

if(S == "ABC"):
	print("ARC")
elif(S == "ARC"):
	print("ABC")
while 1:
  x = int(raw_input())
  if x ~= 0:
    print 'Case i: {0}'.format(x)
  else:
    break

### FIXED CODE ###

count = 1
while 1:
  x = int(raw_input())
  if x == 0:
    break
  print 'Case {0}: {1}'.format(count, x)
  count += 1
a, b = int(input().split())
print(a*b)

### FIXED CODE ###

a, b = map(int,input().split())
print(a*b)
import statistics
while True:
    x = input()
    if x == 0:
        break
    else:
        ls = list(map(int, input().split()))
        print("{0:.8f}".format(statistics.pstdev(ls)))

### FIXED CODE ###

import statistics
while True:
    x = int(input())
    if x == 0:
        break
    else:
        ls = list(map(int, input().split()))
        print("{0:.8f}".format(statistics.pstdev(ls)))
n=int(input())
S=[]
for i in range(n):
  s=list(input())
  S+=[s]
ANS=[]
for k in range(len(S[0])):
  if S[0][k] in S[1]:
    ANS+=[S[0][k]]
    S[1].remove(S[0][k])
for i in ANS:
  for k in range(2,n):
    if i in S[k]:
      S[k].remove(i)
    else:
      ANS.remove(i)
      break
ANS.sort()      
ans="".join(ANS)  
print(ans)

### FIXED CODE ###

import sys
n=int(input())
S=[]
for i in range(n):
  s=list(input())
  S+=[s]
ANS=[]
if n==1:
  ANS=S[0]
  ANS.sort()
  ans="".join(ANS) 
  print(ans)
  sys.exit()
for k in range(len(S[0])):
  if S[0][k] in S[1]:
    ANS+=[S[0][k]]
    S[1].remove(S[0][k])
rem=[]
for i in ANS:
  flag=0
  for k in range(2,n):
    if i in S[k]:
      S[k].remove(i)
    elif flag!=1:
      rem+=[i]
      flag=1
for i in rem:
  ANS.remove(i)
ANS.sort()      
ans="".join(ANS)  
print(ans)
print pow(x,3)

### FIXED CODE ###

x = int(input())
print(x ** 3)
# coding: utf-8
# Your code here!
N=int(input())
S=list(map(int,input().split()))

S1=[]
for i in range(N):
    S1.append(S[i])
S1.sort()
chuouchi=S1[len(S1)//2]
chuouchi2=S1[len(S1)//2+1]
ans=10**15
ansj=0
for i in range(chuouchi-N//2-10,chuouchi-N//2+10):
    goukei=0
    for j in range(N):
        goukei+=abs(S[j]-(i+j+1))
        ansj=j
    if ans>goukei:
        ans=goukei
        
for i in range(chuouchi2-N//2-10,chuouchi2-N//2+10):
    goukei=0
    for j in range(N):
        goukei+=abs(S[j]-(i+j+1))
        ansj=j
    if ans>goukei:
        ans=goukei
        
        
print(ans)


### FIXED CODE ###

# coding: utf-8
# Your code here!
import statistics

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

S1=[]
for i in range(N):
    S1.append(S[i]-i)
S1.sort()
chuouchi=statistics.median_high(S1)
chuouchi2=statistics.median_low(S1)
chuouchi3=statistics.median(S1)
ans=10**20
ansj=0
A=chuouchi-4
B=chuouchi+4
C=chuouchi2-4
D=chuouchi2+4
E=int(chuouchi3)-4
F=int(chuouchi3)+4
for i in range(A,B):
    goukei=0
    for j in range(N):
        goukei+=abs(S[j]-(i+j+1))
        
    if ans>goukei:
        ans=goukei
        
for i in range(C,D):
    goukei=0
    for j in range(N):
        goukei+=abs(S[j]-(i+j+1))
        
    if ans>goukei:
        ans=goukei

for i in range(E,F):
    goukei=0
    for j in range(N):
        goukei+=abs(S[j]-(i+j+1))
        
    if ans>goukei:
        ans=goukei        
        
print(ans)
N,M = map(int,input().split())
a = []
for i in range(M):
    a.append(int(input()))

def fibo(x2):
    if (x2 == 1) or (x2 == 2):
        return (1)
    else:
        return((fibo(x2-1) + fibo(x2-2)) // (10**9 + 7))

aa = []
#aa.append(a[0]-)
for k in range(M-1):
    aa.append(a[k+1] - a[k] - 1)
#aa.append(N - a(M))

if 0 in aa:
    ans = 0

else:
    ans_list = []
    for i in range(M-1):
        if aa[i] >= 1:
            ans_list.append(fibo(aa[i]))

	ans_list.append(fibo(a[1])
	ans_list.append(fibo(N - a[M]))

	ans = (sum(ans_list) // (10**9 + 7))

print(ans)


### FIXED CODE ###

N,M = map(int,input().split())
a = []
if M >= 1:
    for i in range(M):
        a.append(int(input()))

def fibo(n):
    a, b = 1, 1
    if (n == 0) or (n == 1) or (n == 2):
        return 1
    else:
        for _ in range(n-2):
            a, b = b, a + b
        return b

aa = [] #aの差を取ったもののリスト
if M >= 2:
    for k in range(M-1):
        aa.append(a[k+1] - a[k] - 1)
#print(aa)
#aa.append(N - a(M))

    if 0 in aa:
        ans = 0

    else:
        ans = 1
        ans_list = []
        for i in range(M-1):
            ans_list.append(fibo(aa[i]))

        ans_list.append(fibo(a[0]))
        ans_list.append(fibo(N - a[M-1]))
    #print(ans_list)
    
        for i in range (len(ans_list)):
            ans = (ans * ans_list[i]) % (10**9 + 7)

elif M == 1:
    ans_list = []
    ans_list.append(fibo(a[0]))
    ans_list.append(fibo(N - a[0]))
    ans = (ans_list[0] * ans_list[1]) % (10**9 + 7)

elif M == 0:
    ans = fibo(N+1) % (10**9 + 7)

print(ans)
N = int(input())
    A = [int(i) for i in input().split(" ")]
def bubble(A, N):
    count = 0
    flag = True
    while flag == True:
        flag = False
        for j in range(N-1, 0, -1):
            if A[j] < A[j - 1]:
                A[j -1],A[j] = A[j], A[j - 1]
                count += 1
                flag = True
        print(" ".join(map(str, A)))
        print(count)

print(bubble(A, N))

### FIXED CODE ###

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


def bubble_sort(A, N):
    cnt = 0
    flag = True
    while(flag):
        flag = False
        for i in range(N-1, 0, -1):
            if(A[i-1] > A[i]):
                A[i-1], A[i] = A[i], A[i-1]
                cnt += 1
                flag = True

    print(" ".join(list(map(str, A))))
    print(cnt)

bubble_sort(A, N)
n = int(input())
lis = list(map(int,input().split()))
li =[]
cou = 0
key = 0
if n % 2 == 1:
  while cou < n:
    if key == 0:
      li.insert(0,lis[cou])
      cou += 1
      key = 1
    else:
      li.append(lis[cou])
      cou += 1
      key = 0
else:
  while cou < n:
    if key == 0:
      li.append(lis[cou])
      cou += 1
      key = 1
    else:
      li.insert(0,lis[cou])
      cou += 1
      key = 0
print(" ".join(li))

### FIXED CODE ###

n = int(input())
lis = []
li = list(map(str,input().split()))
if n % 2 == 0:
    b = li[1::2]
    for m in range(n//2):lis.append(b[-(m + 1)])
    print(" ".join(lis[::] + li[::2]))
else:
    b = li[::2]
    for m in range((n//2)+1):lis.append(b[-(m + 1)])
    print(" ".join(lis[::]+li[1::2]))
a, b = input()

 
if a < b:
 print "a < b"
elif a > b:
 print "a > b"
else a == b:
 print "a == b"

### FIXED CODE ###

a, b = map(int, raw_input().split())
    
if a < b:
 print "a < b"
elif a > b:
 print "a > b"
else:
 print "a == b"
a = [int(i) for i in input().split()]
if a[0] > a[1]:
  pass
else:
  b = a[0]
  c = a[1]
  a[0] = c
  a[1] = b

b = a[0]
c = a[1]

import fractions

g = fractions.gcd(b,c)

print(int((b * c) / g))

### FIXED CODE ###

t = [int(input()) for i in range(2)] 
k = [1,2,3]
for i in k:
  if i in t:
    pass
  else:
    print(i)
import sys
for line in sys.stdin:
    a,b = line.split()
    a,b = int(a),int(b)
    print '%d %d %f' %(a/b, a%b, 1.0*a/b)

### FIXED CODE ###

a, b = map(int, raw_input().split())
print '%d %d %.12f' %(a/b, a%b, 1.0*a/b)
T = int(input(""))
X = int(input(""))

if T < 1 or T > 100:
    exit()
if X < 1 or X > 100:
    exit()
print(T/X)


### FIXED CODE ###

input_str = input("")
T = int(input_str.split(" ")[0])
X = int(input_str.split(" ")[1])

if T < 1 or T > 100:
    exit()
if X < 1 or X > 100:
    exit()
print(T/X)
#TIME : 
import sys
from math import sqrt
input = sys.stdin.readline

def inp():
    return(int(input()))
def inlt():
    return(list(map(int,input().split())))
def insr():
    s = input()
    return(list(s[:len(s) - 1]))
def invr():
    return(map(int,input().split()))

AB = input().split()
a = int(AB[0])
b = int(AB[1]*100)
res = int((a*b/100))
print(res)

### FIXED CODE ###


#TIME : 
#python에서 소수점연산을 할때 Decimal library를 사용해야한다. float는 바이너리로 표현을 해서 오차가 발생한다.
import sys
from math import sqrt
from decimal import Decimal

input = sys.stdin.readline

def inp():
    return(int(input()))
def inlt():
    return(list(map(int,input().split())))
def insr():
    s = input()
    return(list(s[:len(s) - 1]))
def invr():
    return(map(int,input().split()))

AB = input().split()
a = Decimal(AB[0])
b = Decimal(AB[1])
res = (a*b).__trunc__()
print(res)
from math import gcd
a, b = map(int, input().split())
print((a*b)//gcd(a,b))

### FIXED CODE ###

from fractions import gcd
a, b = map(int, input().split())
print((a*b)//gcd(a,b))
A, B = map(int, input().split())

print(max[A+B, A-B, A*B])

### FIXED CODE ###

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

print(sorted([A+B, A-B, A*B], reverse=True)[0])
from heapq import heappush, heappop
import sys
input = sys.stdin.readline


def dijkstra(edges, size, source):
    distance = [float('inf')] * size
    distance[source] = 0
    visited = [False] * size
    pq = []
    heappush(pq, (0, source))
    while pq:
        dist_v, v = heappop(pq)
        visited[v] = True
        for u, weight in edges[v]:
            if not visited[u]:
                new_dist = dist_v + weight
                if distance[u] > new_dist:
                    distance[u] = new_dist
                    heappush(pq, (new_dist, u))
    return distance


N, M = map(int, input().split())
G = [[] for _ in range(N+1)]
for _ in range(M):
    u, v = map(int, input().split())
    G[u].append(v)
S, T = map(int, input().split())
G2 = [[] for _ in range(N+1)]


def dfs(nodes, v):
    if nodes[0] != -1:
        if (v, 1) in G2[nodes[0]]:
            return
        G2[nodes[0]].append((v, 1))
    for u in G[v]:
        dfs(nodes[1:] + [v], u)


dfs([-1] * 3, S)
dist = dijkstra(G2, N+1, S)
print(dist[T] if dist[T] != float('inf') else -1)


### FIXED CODE ###

from collections import deque
import sys
input = sys.stdin.readline

N, M = map(int, input().split())
G = [[] for _ in range(N+1)]
for _ in range(M):
    u, v = map(int, input().split())
    G[u].append(v)
S, T = map(int, input().split())
queue = deque()
queue.append((S, 0))
visited = [[False] * 3 for _ in range(N+1)]
while queue:
    u, d = queue.popleft()
    if visited[u][d % 3]:
        continue
    visited[u][d % 3] = True
    if d % 3 == 0 and u == T:
        print(d // 3)
        exit()
    for v in G[u]:
        queue.append((v, d+1))
print(-1)
import math

N, K = list(map(int,input().split()))
A = list(map(int,input().split()))

def is_ok(mid):
    cnt = 0
    for i in range(N):  cnt += math.floor(A[i] / mid)
    return cnt <= K

def binary_search(left, right):
    while (abs(right - left) > 1):
        mid = (left + right) // 2
        if is_ok(mid):  right = mid
        else:  left = mid
    return right

if K == 0:  print(max(A))
else:
    left = max(A)
    right = -1
    ret = binary_search(right, left)
    print(ret)

### FIXED CODE ###

import math

N, K = list(map(int,input().split()))
A = list(map(int,input().split()))

def is_ok(mid):
    cnt = 0
    for i in range(N):  cnt += (math.ceil(A[i] / mid) - 1)
    return cnt <= K

def binary_search(left, right):
    while (abs(right - left) > 1):
        mid = (left + right) // 2
        if is_ok(mid):  right = mid
        else:  left = mid
    return right

if K == 0:  print(max(A))
else:
    left = max(A)
    right = 0
    ret = binary_search(right, left)
    print(ret)
# C - Guess The Number
def guess_number(N: int, M: int, conditions: list) -> int:
    if N == 1:
        digit, num = conditions[0]
        if M != 1 or digit != 1:
            return -1
        return num

    if any(cond == (1, 0) for cond in conditions):  # 1st digit mustn't be 0
        return -1

    result = [0] * N
    for digit, num in conditions:
        if result[-digit] not in (0, num):
            return -1
        result[-digit] = num
    return sum(x * (10 ** i) for i, x in enumerate(result))


def main():
    N, M, *SC = map(int, open(0).read().split())
    conditions = list(zip(*[iter(SC)] * 2))
    ans = guess_number(N, M, conditions)
    print(ans)


if __name__ == "__main__":
    main()


### FIXED CODE ###

# C - Guess The Number
def guess_number(N: int, conditions: list) -> int:
    if N > 1 and any(cond == (1, 0) for cond in conditions):  # 1st digit mustn't be 0 if N > 1
        return -1
    result = [-1] * N
    for digit, num in conditions:
        if result[-digit] >= 0 and result[-digit] != num:
            return -1
        result[-digit] = num
    if result[-1] == -1:  # 1st digit must be 1 if N > 1 (no leading zeros)
        result[-1] = 1 if N > 1 else 0
    return sum(x * (10 ** i) if x != -1 else 0 for i, x in enumerate(result))


def main():
    N, M, *SC = map(int, open(0).read().split())
    conditions = list(zip(*[iter(SC)] * 2))
    ans = guess_number(N, conditions)
    print(ans)


if __name__ == "__main__":
    main()
from collections import deque
n,m = map(int,input().split())
l = [list(map(int,input().split())) for i in range(m)]
for i in range(m):
    x,y = l[i][0],l[i][1]
    x,y = x-1,y-1
    if x > y:
        x,y = y,x
    l[i] = [x,y]
l.sort()
print(l)
a,b = deque(),deque()
for i in range(m):
    a.append(l[i][0])
    b.append(l[i][1])
ans = [-1] * n
ans[0] = 0
queue = deque()
for i in range(n):
    queue.append(i)
while queue:
    h = queue.popleft()
    flg = False
    p = 0
    q = len(a)
    while p < q:
        x = a.popleft()
        y = b.popleft()
        if h == x or h == y:
            if ans[x] == -1 and ans[y] == -1:
                a.append(x)
                b.append(y)
                flg = True
            elif ans[x] == -1:
                ans[x] = ans[y] + 1
            elif ans[y] == -1:
                ans[y] = ans[x] + 1
            else:
                ans[x] = min(ans[x],ans[y]+1)
                ans[y] = min(ans[y],ans[x]+1)
        else:
            a.append(x)
            b.append(y)
        p += 1
    if flg:
        queue.append(h)
    print(ans)
if -1 in ans:
    print('No')
else:
    print('Yes')
    for i in ans[1:]:
        print(i)

### FIXED CODE ###

# 参考にした提出:https://atcoder.jp/contests/abc168/submissions/16604668 #
from collections import deque
n,m = map(int,input().split())
l = [[] for i in range(n+1)]
for i in range(m):
    a,b = map(int,input().split())
    l[a].append(b)
    l[b].append(a)
d = [-1] * (n+1)
d[0],d[1] = 0,0
queue = deque()
queue.append(1)
while queue:
    x = queue.popleft()
    for i in l[x]:
        if d[i] == -1:
            d[i] = x
            queue.append(i)
if -1 in d:
    print('No')
else:
    print('Yes')
    for i in d[2:]:
        print(i)
n = int(input())

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

if n == 1:
   print(0)
   exit()

ans = 0
for p, i in factorization(n):
   j = 0
   while i > j:
      j += 1
      i -= j
      ans += 1
print(ans)


### FIXED CODE ###

n = int(input())

from collections import Counter

factors = []
i = 2
while n > 1:
   if n < i * i:
      factors.append(n)
      break
   while n % i == 0:
      factors.append(i)
      n //= i
   i += 1

ans = 0
for cnt in Counter(factors).values():
   i = 1
   while cnt >= i:
      cnt -= i
      i += 1
      ans += 1
print(ans)
import sys
#from scipy.special import comb
from scipy.misc import comb

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

A = [0]*M

for i in range(M):
    A[i] = int(input())

A.append(N+1)

def step_comb(L):
    c = 0
    if L==1 or L == 0:
        c = 1
    else:
        for i in range(L//2 +1):
            j = L - 2*i
            c += comb(j+i, i, exact=True)
    return c

total_comb = 1
NOW = 0
for a in A:
    if NOW == a:
        print(0)
        sys.exit()
    L = a-1-NOW
    total_comb *= step_comb(L)
    NOW = a + 1
    
print(total_comb % 1000000007 )


### FIXED CODE ###

import sys
sys.setrecursionlimit(100000000)

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

if M == 0:
    A = []
else:
    A = [0]*M
    for i in range(M):
        A[i] = int(input())

A.append(N+1)

# DP version
DP = [0]*(N+1)
DP[0] = 1
# １段の階段を登るやり方の数
DP[1] = 1
# 2段の階段を登るやり方の数
#DP[2] = 2

for i in range(2,N+1):
    DP[i] = DP[i-1] + DP[i-2]

def step_comb(L):
    if DP[L]>0:
        return DP[L]
    DP[L] = step_comb(L-1) + step_comb(L-2)
    return DP[L]
    
total_comb = 1
NOW = 0
for a in A:
    if NOW == a:
        print(0)
        sys.exit()
    L = a-1-NOW
    total_comb *= step_comb(L)
    NOW = a + 1
    if NOW == N:
        break
    
print(total_comb % 1000000007 )
x = int(input("x : ")
print(x ** 3)

### FIXED CODE ###

x = int(input())
print(x**3)
a,t,x=input().split()
a=int(a)
t=int(t)
x=a*t
i=int(input(i))
c=min(x,i)

### FIXED CODE ###

a,t,i=input().split()
a=int(a)
t=int(t)
x=a*t
i=int(i)
c=min(x,i)
print(c)
a,b=map(int,input().split())
print(int(a*b))

### FIXED CODE ###

import decimal
a,b=input().split()
a=int(a)
b=decimal.Decimal(b)
print(int(a*b))
class UnionFind:
    def __init__(self, n):
        self.sizes = [1] * n
        self.par = list(range(n))

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

    def unite(self, x, y):
        x, y = self.find(x), self.find(y)
        if x == y:
            return
        if self.sizes[x] < self.sizes[y]:
            x, y = y, x
        self.par[y] = x
        self.sizes[x] += self.sizes[y]

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

    def size(self, x):
        return self.sizes[self.find(x)]
N, M = map(int, input().split())
comb = [int(n * (n - 1) / 2) for n in range(100000)]
bridge = list()
 
for m in range(M):
    a, b = map(int, input().split())
    bridge.append([a - 1, b - 1])
bridge = bridge[::-1]
u = UnionFind(N)
ls_sm = []
for a,b in bridge:
    sm =  -  comb[u.size(a)] - comb[u.size(b)]
    u.unite(a,b)
    sm += comb[u.size(a)]
    ls_sm.append(sm)
ans = 0
for sm in ls_sm[::-1]:
    if sm > 0:
        ans += sm
    print (ans)
    
    



### FIXED CODE ###

N, M = map(int, input().split())
ab = [tuple(map(lambda x:int(x)-1, input().split())) for _ in range(M)]
 
 
class UnionFind:
    def __init__(self,size):
        self.rank = [-1 for _ in range(size)]
        self.number = [1 for _ in range(size)]
 
    def find(self,x):
        while self.rank[x] >= 0:
            x = self.rank[x]
        return x
 
    def union(self,x,y):
        s1 = self.find(x)
        s2 = self.find(y)
        if s1 == s2:
            return
        if self.rank[s1] == self.rank[s2]:
            self.rank[s1] -= 1
            self.rank[s2] = s1
            self.number[s1] += self.number[s2]
        elif self.rank[s1] < self.rank[s2]:
            self.rank[s2] = s1
            self.number[s1] += self.number[s2]
        else:
            self.rank[s1] = s2
            self.number[s2] += self.number[s1]
 
 
def main():
    uf = UnionFind(N)
    p = N * (N - 1) // 2
    ans = [p]
    for x, y in reversed(ab):
        px = uf.find(x)
        py = uf.find(y)
        if px != py:
            p -= uf.number[px] * uf.number[py]
            uf.union(px, py)
        ans.append(p)
 
    for a in reversed(ans[:-1]):
        print(a)
 
 
main()
s = input()
ch = [chr(i) for i in range(97, 97+26)]
for i in range(len(ch)):
    if not ch[i] in s :
        print(ch[i])
        sys.exit()
print("None")

### FIXED CODE ###

s = input()
ch = {chr(i) for i in range(ord('a'), ord('z')+1)}
ss = set()
for i in range(len(s)): ss.add(s[i])
tmp = sorted(list(ch ^ ss))
print(tmp[0] if len(tmp) else "None")
a, b, c = map(int,input(),split())
if a + b <= c:
  print('Yes')
else:
  print('No')

### FIXED CODE ###

a, b, c = map(int, input().split())
if a + b >= c:
  print('Yes')
else:
  print('No')
if input()== 'a' or input()=='i' or input()=='u' or input()=='e' or input()=='o':
    print('vowel')
else:
    print('consonant')

### FIXED CODE ###

c = {input()}
vowels = {'a', 'i', 'u', 'e', 'o'}
if c < vowels:
    print('vowel')
else:
    print('consonant')