Harryxun/stf_run huggingface dataset:
n = int(input())
aList = list(map(int, input().split()))
count = 0

while True:
  flag = True
  for i in range(n):
    if aList[i] % 2 != 0:
      flag = False
    aList[i] /= 2
   
  if flag = False:
    break

  count += 1

### FIXED CODE ###

n = int(input())
aList = list(map(int, input().split()))
count = 0

while True:
  flag = True
  for i in range(n):
    if aList[i] % 2 != 0:
      flag = False
    aList[i] /= 2
   
  if flag == False:
    break

  count += 1

print(count)
n,d = input().split()
n = int(n)
d = int(d)
t = 2d + 1
     
if n % t == 0:
	ans = n/t
else:
	ans = n/t
    ans = ans + 1

print(ans)

### FIXED CODE ###

n,d=(int(x) for x in input().split())
t = 2 * d + 1
     
if n % t == 0:
    ans = n/t
else:
    ans = n/t
    ans = ans + 1

ans = int(ans)
print(ans)
import sys

N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
A = [0] + A
town = 1
visited = [0]*(N+1)

for i in range(1, K+1):
    town = A[town]
    if visited[town] == 0:
        visited[town] = i
    else:
        loop = i - visited[town]
        town = (K - visited[town]) % loop + visited[town]
print(town)

### FIXED CODE ###

import sys

N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
A = [0] + A
town = 1
visited = [0]*(N+1)

for i in range(1, K+1):
    town = A[town]
    if visited[town] == 0:
        visited[town] = i
    else:
        loop = i - visited[town]
        place = (K - visited[town]) % loop + visited[town]
        print(visited.index(place))
        sys.exit()
print(town)
import sys
input = sys.stdin.readline
sys.setrecursionlimit(1000000)

N,K = map(int,input().split())
c = [[0 for _ in range(N)] for _ in range(N)]
c[0][0] = 1
for i in range(N-1):
    for j in range(N):
        if j > 0: c[i+1][j] += c[i][j-1]
        c[i+1][j] += c[i][j]
def f2(n,k):
    return c[n+k-1][k-1]
def f(n,k):
    if n-k<0: return 0
    if k<1: return 0
    return f2(n-k,k)%((1e+9)+7)

for i in range(1,K+1):
    blue = f(K,i)
    red = f(N-K,i-1)+2*f(N-K,i)+f(N-K,i+1)
    ans=blue*red
    print(int(ans%(1e+9+7)))


### FIXED CODE ###

import sys
input = sys.stdin.readline
sys.setrecursionlimit(1000000)

N,K = map(int,input().split())
c = [[0 for _ in range(N)] for _ in range(N)]
c[0][0] = 1
for i in range(N-1):
    for j in range(N):
        if j > 0: c[i+1][j] += c[i][j-1]
        c[i+1][j] += c[i][j]
def f2(n,k):
    return c[n+k-1][k-1]%1000000007
def f(n,k):
    if n-k<0: return 0
    if n==k: return 1
    if k<1: return 0
    return f2(n-k,k)%1000000007

for i in range(1,K+1):
    blue = f(K,i)
    red = f(N-K,i-1)+2*f(N-K,i)+f(N-K,i+1)
    ans=blue*red
    print(int(ans%1000000007))
S = input()
 
if S = "AAA":
    print("No")
elif S = "BBB":
    print("No")
else:
    print("Yes")

### FIXED CODE ###

S = input()
 
if S == "AAA":
    print("No")
elif S == "BBB":
    print("No")
else:
    print("Yes")
import numpy as np

N = int(input())
A = [int(c) for c in input().split(' ')]

ret = np.prod(A, dtype='float128')
if int(ret) > 1e18:
  print(-1)
else:
  print(ret)

### FIXED CODE ###

#import functools

def main():
    N = int(input())
    A = [int(c) for c in input().split(' ')]
    A.sort(reverse=True)

    if A[-1] == 0:
        print('0')
        exit()
    elif A[0] > 1e18:
        print('-1')
        exit()

    ret = 1
    for x in A:
        ret = ret * x
        if ret > 1e18:
            print('-1')
            exit()
        elif ret == 0:
            print('0')
            exit()

    if ret == 0:
        print('0')
        exit()
    elif ret > 1e18:
        print('-1')
        exit()
    print(f'{ret}')


if __name__ == "__main__":
    main()
import sys

H, N = list(map(int, input().split()))
AB = [list(map(int, input().split())) for n in range(N)]

dp = [sys.maxsize for i in range(H+1)]
dp[0] = 0

# 各ダメージ段階の最小値を求める
for i in range(H):
    if dp[i] == sys.maxsize:
        continue
    # 各魔法を使って最小値なら更新
    for j in range(N):
        a = min(i + AB[j][0], H)
        b = dp[i] + AB[j][1]
        if dp[a] > b:
            dp[a] = b

print(dp[H])


### FIXED CODE ###

import math

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

N = math.ceil(H/A)

print(N)
a, b, c = sorted(map(int, input().split()))
list = sorted(abc)

print("Yes" if a+b==c else "No")


### FIXED CODE ###


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

print("Yes" if a+b==c else "No")
if X > 10100:
    print(1)
    quit()
lst = []
for i in range(20):
    lst.append([i*105+1, i*100+99])
for item in lst:
    if X >= item[0] and X<=item[1]:
        print(0)
        quit()
print(1)

### FIXED CODE ###

X =int(input())
if X > 10100:
    print(1)
    quit()
lst = []
for i in range(20):
    lst.append([i*105+1, i*100+99])
for item in lst:
    if X >= item[0] and X<=item[1]:
        print(0)
        quit()
print(1)
X = input(); Y = input(); Z = input()
print((X-Z)/Y)

### FIXED CODE ###

X, Y, Z = map(int, raw_input().split())
print((X-Z)/(Y+Z))
s = sorted(input())
t = sorted(input(), reverse=True)
alf = 'abcdefghijklmnopqrstuvwxyz'
r = 'No'
if len(s)<len(t) and s==t[len(s):]:
    r = 'Yes'
for i in range(len(s)):
    si = alf.index(s[i])
    ti = alf.index(t[i])
    if si < ti:
        r = 'Yes'
        break
    elif si == ti:
        continue
    else:
        break
print(r)

### FIXED CODE ###

s = input()
t = input()
alf = 'abcdefghijklmnopqrstuvwxyz'
r = 'No'
if len(s)<len(t) and s==t[:len(s)]:
    r = 'Yes'

s = sorted(s)
t = sorted(t, reverse=True)
for i in range(min(len(s),len(t))):
    si = alf.index(s[i])
    ti = alf.index(t[i])
    if si < ti:
        r = 'Yes'
        break
    elif si == ti:
        continue
    else:
        break
print(r)
X,Y=map(int, input().split())

MOD = 10**9 + 7
def prepare(n, MOD):

    # 1! - n! の計算
    f = 1
    factorials = [1]  # 0!の分
    for m in range(1, n + 1):
        f *= m
        f %= MOD
        factorials.append(f)
    # n!^-1 の計算
    inv = pow(f, MOD - 2, MOD)
    # n!^-1 - 1!^-1 の計算
    invs = [1] * (n + 1)
    invs[n] = inv
    for m in range(n, 1, -1):
        inv *= m
        inv %= MOD
        invs[m - 1] = inv

    return factorials, invs
if (X+Y)%3!=0:
    print(0)
else:
    #最初に行き方を決めて、使う移動方法の個数を求めて、重複組み合わせ
    #決め打ちしてから n:2x+yの移動　m:x+2yの移動
    n = (2*X-Y)//3
    m = (2*Y-X)//3


    fac, invs = prepare((n+m), MOD)


    print(fac[n+m]*invs[n]*invs[m]%MOD)


### FIXED CODE ###

X,Y=map(int, input().split())

MOD = 10**9 + 7
def prepare(n, MOD):

    # 1! - n! の計算
    f = 1
    factorials = [1]  # 0!の分
    for m in range(1, n + 1):
        f *= m
        f %= MOD
        factorials.append(f)
    # n!^-1 の計算
    inv = pow(f, MOD - 2, MOD)
    # n!^-1 - 1!^-1 の計算
    invs = [1] * (n + 1)
    invs[n] = inv
    for m in range(n, 1, -1):
        inv *= m
        inv %= MOD
        invs[m - 1] = inv

    return factorials, invs
if (X+Y)%3!=0:
    print(0)
else:
    #最初に行き方を決めて、使う移動方法の個数を求めて、重複組み合わせ
    #決め打ちしてから n:2x+yの移動　m:x+2yの移動
    n = (2*X-Y)//3
    m = (2*Y-X)//3

    if n<0 or m<0:
        print(0)
        exit()


    fac, invs = prepare((n+m), MOD)


    print(fac[n+m]*invs[n]*invs[m]%MOD)
n,m = map(int,input().split())
ACcount = 0
WAcount = 0
WA = []
AC = []
for i in range(n):
  WA.append(0)
  AC.append(1)
for i in range(m):
  p,s = input().split()
  p = int(p)
  if s == "WA":
    if WA[p-1] >= 0:
      WA[p-1] += 1
  if s == "AC":
    ACcount += AC[p-1]
    AC[p-1] = 0
    if WA[p-1] >= 0:
       WAcount += WA[p-1]
       WA[p-1] = -1
print(ACcount,WAcount)

### FIXED CODE ###

l = ["a","b","c","d","e","f","g","h","i","j","k","l","m","n","o","p","q","r","s","t","u","v","w","x","y","z"]
s = input()
for i in range(25):
  if s == l[i]:
    print(l[i+1])
n = int(input())
ary = list(map(int,input().split()))
a = sorted(ary)
c = (len(ary)+1)//2-1
for i in range(n):
    b = a.copy()
    b.remove(ary[i])
    print(b[c])

### FIXED CODE ###

n = int(input())
ary = list(map(int,input().split()))
a = sorted(ary)
b = (len(ary)+1)//2-1
for i in range(n):
    if a[b] < ary[i]:
        print(a[b])
    elif a[b] == ary[i]:
        print(a[b+1])
    elif a[b] > ary[i]:
        print(a[b+1])
# coding: utf-8

n = int(input()) 
t = sorted([int(input()) for i in range(n)])

def gcd(a, b):
  while b:
    a, b = b, a % b
  return a
	
def lcm(a, b):
  return a * b // gcd(a, b)
	
def nlcm(list):
  if len(list) > 2:
  	lcm_num = lcm(list[0], list[1])
    for i in range(2, len(list)):
      lcm_num = lcm(lcm_num, list[i])
    print(lcm_num)
  elif len(list) == 2:
    print(lcm(list[0], list[1]))
  else:
  	print(len[-1])


nlcm(t)


### FIXED CODE ###

# coding: utf-8

n = int(input()) 
t = sorted([int(input()) for i in range(n)])

def gcd(a, b):
  while b:
    a, b = b, a % b
  return a
	
def lcm(a, b):
  return a * b // gcd(a, b)
	
def nlcm(list):
  if len(list) > 2:
    lcm_num = lcm(list[0], list[1])
    for i in range(2, len(list)):
      lcm_num = lcm(lcm_num, list[i])
    
    print(lcm_num)
  elif len(list) == 2:
    print(lcm(list[0], list[1]))
  else:
  	print(list[-1])

nlcm(t)
N, M = map(int, input().split())
drink = []
cost = 0
count = 0
d_count = 0
rest = 0


for _ in range(N):
    drink.append(list(map(int, input().split())))
    drink.sorted(drink)

for i in range(N):
    cost += drink[i][0] * drink[i][1]
    d_count += drink[i][1]
    count += 1
    if d_count > M:
      break
      
cost -= drink[count-1][0] * drink[count-1][1]
d_count -= drink[count-1][1]
rest = M - d_count
cost += rest * drink[count-1][0]
print(cost)
    

### FIXED CODE ###

N, M = map(int, input().split())
drink = []
cost = 0
d_count = 0


for _ in range(N):
    drink.append(list(map(int, input().split())))
    
drink = sorted(drink)

for i in range(N):
    cost += drink[i][0] * drink[i][1]
    d_count += drink[i][1] 
    if d_count > M:
      cost -= drink[i][0] * (d_count - M)
      break
      

print(cost)
X,Y,Z,K = list(map(int,input().split()))

A = sorted(list(map(int,input().split())))
A.reverse()
B = sorted(list(map(int,input().split())))
B.reverse()
C = sorted(list(map(int,input().split())))
C.reverse()

a = [A[i] - A[i+1] for i in range(len(A)-1) ]
b = [B[i] - B[i+1] for i in range(len(B)-1) ]
c = [C[i] - C[i+1] for i in range(len(C)-1) ]

st = A[-1]+B[-1]+C[-1]

s_a,s_b,s_c = 1,1,1
for i in range(K-1):
    # どれを取るか選ぶ
    m = min(a[0] if len(a)>0 else 100000000001
            ,b[0] if len(b)>0 else 100000000001
            ,c[0] if len(c)>0 else 100000000001)
    #print(a[0],b[0],c[0])
    consider_list = [0]*3
    if len(a)>0 and a[0] == m:
        consider_list[0] = (s_a+1) * s_b * s_c

    if len(b)>0 and b[0] == m:
        consider_list[1] = (s_a) * (s_b+1) * s_c
    if len(c)>0 and c[0] == m:        
        consider_list[2] = (s_a) * (s_b) * (s_c+1)
    #print(consider_list.index(max(consider_list)))
    if consider_list.index(max(consider_list)) == 0:
        a.pop(0)
        s_a += 1
    elif consider_list.index(max(consider_list)) == 1:
        b.pop(0)
        s_b += 1
    else:
        c.pop(0)
        s_c += 1
    if (s_a-1) * (s_b-1)*(s_c-1) >= K:
        break

import itertools
#print(list(itertools.product(A[:s_a], B[:s_b],C[:s_c])))
for idx,value in enumerate(sorted([sum(i) for i in  list(itertools.product(A[:s_a+1], B[:s_b+1],C[:s_c+1]))])[::-1]):
  if idx > K-1:
    break
  print(value)
             

### FIXED CODE ###

X,Y,Z,K = list(map(int,input().split()))
A = [(sorted(list(map(int,input().split())))[::-1]) for i in range(3)]
b = sorted([i+j for i in A[0] for j in A[1]])[-K:]
for i in sorted([i+j for i in b for j in A[2]])[-K:][::-1] :
  print(i)
import math

al = ["a", "b", "c", "d", "e", "f", "g", "h", "i", "j"]

N = int(input())
S = [[""] * math.factorial(i+1) for i in range(N-1)]

S[0][0] = al[0]
for i in range(1, N-1):
  prev_S = S[i-1]
  al_use = al[:i+1]
  S[i] = [s + a for s in prev_S for a in al_use]

prev_S = S[N-2]
al_use = al[:N]
for s in prev_S:
  for a in al_use:
    print(s + a)


### FIXED CODE ###

import sys
from collections import deque

input = sys.stdin.readline


def dfs(N):
    alphabet = "abcdefghij"
    stack = deque(["a"])
    while stack:
        s = stack.pop()
        if len(s) == N:
            print(s)
            continue
        suffixes = []
        for al in alphabet:
            suffixes.append(al)
            if al not in s:
                break
        for suffix in reversed(suffixes):
            stack.append("".join((s, suffix)))


def main():
    N = int(input())

    dfs(N)


if __name__ == "__main__":
    main()
import numpy as np
n, k = map(int, input().split())
nlist = np.array(list(map(int, input().split())))
print(len(nlist[nlist>=k]))


### FIXED CODE ###

import numpy as np
n, k = map(int, input().split())
nlist = np.array(list(map(int, input().split())))
print(len(nlist[nlist>=k]))
def resolve():
    a, b = list(map(int, input().split()))
    l = list(range(a, b + 1))
    l.sort()
    minus = list(filter(lambda x: x < 0, l))
    minus = len(minus)

    if 0 in l:
        print('Zero')
        return
    else:
        if minus % 2 == 1:
            print('Negative')
            return
        else:
            print('Positive')
            return
    return

resolve()

### FIXED CODE ###

def resolve():
    a, b = list(map(int, input().split()))

    if a <= 0 and b >= 0:
        print('Zero')
    elif b < 0 and (b - a + 1) % 2 == 1:
        print('Negative')
    else:
        print('Positive')
    return


resolve()
#abc139d
N = int(input())

if N>2:
    #ans=0
    #for i in range(2,N,1):
    #    ans+=i
    #print(ans+1)
    print(int((N*(N-1))/2))
    
elif N==2:
    print("1")
elif N==1:
    print("0")

#abc139c
N = int(input())
list_H = list(map(int, input().split()))

ans =[]
move_count=0

if i!=1:
    for i in range(1,N,1):
        if list_H[i-1]>=list_H[i]:
            move_count+=1

            if i==N-1:
                ans.append(move_count)
        else:
            ans.append(move_count)
            move_count=0

    if len(ans)!=0:
        print(max(ans))
    else:
        print("0")
else:
    print("0")

### FIXED CODE ###

#abc139c
N = int(input())
list_H = list(map(int, input().split()))

ans =[]
move_count=0

if N!=1:
    for i in range(1,N,1):
        if list_H[i-1]>=list_H[i]:
            move_count+=1

            if i==N-1:
                ans.append(move_count)
        else:
            ans.append(move_count)
            move_count=0

    if len(ans)!=0:
        print(max(ans))
    else:
        print("0")
else:
    print("0")
s = int(input())
k = int(input())
li = [int(k) for k in list(str(s))]
#print(li)
if k = 1:
  print(li[0])
else:
  print(li[1])

### FIXED CODE ###

s = int(input())
k = int(input())
li = [int(k) for k in list(str(s))]
#print(li)
count = 0
for i in li:
  if i ==1:
    count+=1
  else:
    ans = i
    break
    
if k <= count:
  print(1)
else:
  print(ans)
# -*- coding: utf-8 -*-
import sys


def main():
    N,M = list(map(int, sys.stdin.readline().split()))
    AB_list = [ list(map(int, sys.stdin.readline().split())) for _ in range(M) ]


    edge = {}  
    # { int : set }
    # { the number of human : {friends} }

    for a,b in AB_list:
        edge.setdefault(a, set())
        edge[a].add(b)

        edge.setdefault(b, set())
        edge[b].add(a)
    

    visited = [None] + [0]*N
    #  0: not visited,  1:visited


    max_relation = 0

    for i in range(1, N+1):
        if visited[i] == 0:
            visited[i] = 1
            ret = dfs(edge, visited, i, 0)
            max_relation = max(max_relation, ret)
    
    
    print( max_relation + 1 )


def dfs(edge, visited, num, cnt):
    max_cnt = cnt

    if num in edge:
        for next_node in edge[num]:
            if visited[next_node] == 0:
                visited[next_node] = 1
                cnt += 1
                ret = dfs(edge, visited, next_node, cnt)
                max_cnt = max(max_cnt, ret)

    return max_cnt


if __name__ == "__main__":
    main()


### FIXED CODE ###

# -*- coding: utf-8 -*-
import sys
from collections import Counter


def main():
    N,M = list(map(int, sys.stdin.readline().split()))
    AB_list = [ list(map(int, sys.stdin.readline().split())) for _ in range(M) ]


    ##############################
    # Union Find
    parents = [-1] * (N + 1)

    def find(x :int) -> int:
        if parents[x] < 0:
            return x
        
        parents[x] = find( parents[x] )
        return parents[x]

    def union(x,y):
        root_x = find(x)
        root_y = find(y)

        if root_x == root_y:
            return
        
        depth_x = parents[root_x]
        depth_y = parents[root_y]

        if depth_x <= depth_y:
            parents[root_y] = root_x

            if depth_x == depth_y:
                parents[root_x] -= 1

        else:
            parents[root_x] = root_y
    ##############################


    for a,b in AB_list:
        union(a,b)
    
    group = [ find(num) for num in range(1,N+1) ]
    cnt = Counter(group)
    
    print(cnt.most_common(1)[0][1])


if __name__ == "__main__":
    main()
n, k = map(int, input())
total = set()
for _ in range(k):
  d = int(input())
  a = set(map(int, input().split()))
  for b in a:
    total.add(b)
ans = n - len(total)
print(ans)
  


### FIXED CODE ###

n, k = map(int, input().split())
total = []
for _ in range(k):
  d = int(input())
  A = list(map(int, input().split()))
  for a in A:
    total.append(a)
ans = n - len(set(total))
print(ans)
S, W= map(int,input().split(""))

if S < W:
    print("unsafe")
else :
    print("safe")

### FIXED CODE ###

S, W= map(int,input().split())

if S <= W:
    print("unsafe")
else :
    print("safe")
import sys
from collections import Counter, deque, defaultdict
from itertools import accumulate, permutations, combinations, takewhile, compress, cycle
from functools import reduce
from math import ceil, floor, log10, log2, factorial
from pprint import pprint

sys.setrecursionlimit(1000000)
# MOD = 10 ** 9 + 7
# N = int(input())
# A = [int(x) for x in input().split()]
# V = [[0] * 100 for _ in range(100)]
# A = [int(input()) for _ in range(N)]

N, W = [int(x) for x in input().split()]

dp = [float('inf')] * 1000 * 100
vs = set()
vs.add(0)
dp[0] = 0

for i in range(N):
    w, v = [int(x) for x in input().split()]

    tmpDP = dp.copy()
    for vv in list(vs):
        if dp[vv + v] > dp[vv] + w:
            # print(
            #     "(w,v)=({0},{1}): dp[{2}]:{3} dp[{4}]:{5} --> {6}".format(w, v, vv, dp[vv], vv + v, dp[vv + v],
            #                                                                dp[vv] + w))
            tmpDP[vv + v] = dp[vv] + w
            vs.add(vv + v)
    dp = tmpDP

# for i in range(len(dp)):
#     if dp[i] < float('inf'):
#         print("{}, {}".format(i, dp[i]))

ans = 0
for v in list(vs):
    # print("{}, {}".format(v, dp[v]))
    if dp[v] <= W:
        ans = max(ans, v)
print(ans)


### FIXED CODE ###

import sys
from collections import Counter, deque, defaultdict
from itertools import accumulate, permutations, combinations, takewhile, compress, cycle
from functools import reduce
from math import ceil, floor, log10, log2, factorial
from pprint import pprint

sys.setrecursionlimit(1000000)
# MOD = 10 ** 9 + 7
# N = int(input())
# A = [int(x) for x in input().split()]
# V = [[0] * 100 for _ in range(100)]
# A = [int(input()) for _ in range(N)]

N, W = [int(x) for x in input().split()]

dp = [float('inf')] * 1000 * 100*10
vs = set()
vs.add(0)
dp[0] = 0

for i in range(N):
    w, v = [int(x) for x in input().split()]

    tmpDP = dp.copy()
    for vv in list(vs):
        if dp[vv + v] > dp[vv] + w:
            tmpDP[vv + v] = dp[vv] + w
            vs.add(vv + v)
    dp = tmpDP


ans = 0
for v in list(vs):
    if dp[v] <= W:
        ans = max(ans, v)
print(ans)
N = int(input())
A = [int(i) for i in input().split()]

def CheckColor(a):
    global free_count
    if 1 <= 0 a and a <= 399:
        return 'gray'
    elif 400 <= a and a <= 799:
        return 'blown'
    elif 800 <= a and a <= 1199:
        return 'green'
    elif 1200 <= a and a <= 1599:
        return 'water'
    elif 1600 <= a and a <= 1999:
        return 'blue'
    elif 2000 <= a and a <= 2399:
        return 'yellow'
    elif 2400 <= a and a <= 2799:
        return 'orange'
    elif 2800 <= a and a <= 3199:
        return 'red'
    else:
        free_count += 1
        return 'free'

def Max(L):
    global gree_count
    max_num = min_num + free_count
    if max_num > 7:
        return 7        
    else:
        return max_num

def Min(L):
    global min_num
    if 'free' in ans_set:
        min_num = len(L) - 1
    else:
        min_num = len(L)
    return min_num


ans_list = []
count = 0
min_num = 0
free_count = 0

for a in A:
    ans_list.append(CheckColor(a))

ans_set = set(ans_list)

print(Min(ans_set), Max(ans_set))

### FIXED CODE ###

N = int(input())
A = [int(i) for i in input().split()]

def CheckColor(a, count):
    if 1 <= a and a <= 399:
        count[0] += 1
    elif 400 <= a and a <= 799:
        count[1] += 1
    elif 800 <= a and a <= 1199:
        count[2] += 1
    elif 1200 <= a and a <= 1599:
        count[3] += 1
    elif 1600 <= a and a <= 1999:
        count[4] += 1
    elif 2000 <= a and a <= 2399:
        count[5] += 1
    elif 2400 <= a and a <= 2799:
        count[6] += 1
    elif 2800 <= a and a <= 3199:
        count[7] += 1
    else:
        count[8] += 1

ans = 0
count = [0 for _ in range(9)]

for a in A:
    CheckColor(a, count)

for c in count[:8]:
    if c != 0:
        ans += 1

print(max(ans, 1), ans + count[8])
text = input()
cnt = 0
if 1000 <= int(text) and int(text) <= 9000:
	for i in range(len(text)):
		if i == 2:
			cnt += 1
		else:
			pass
print (i)

### FIXED CODE ###

text = input()
cnt = 0
for i in text:
	if i == "2":
		cnt += 1
print (cnt)
n=int(input())
li=[0]*((10**9)+1)
ans=0
for i in range(n):
  a=int(input())
  if li[a]==0:
    li[a]=1
    ans += 1
  else:
    li[a]=0
    ans -= 1
print(ans)

### FIXED CODE ###

n=int(input())
li=[int(input()) for i in range(n)]
import collections
a=collections.Counter(li)
b=a.most_common()
ans=0
for i in range(len(b)):
  if b[i][1]%2==1:
    ans += 1
print(ans)
#%%
N, M = map(int, input().split())

a = [0] * M
b = [0] * M
c = [[] for _ in range(M)]
for i in range(M):
    a[i], b[i] = map(int, input().split())
    c[i] = list(map(int, input().split()))

inf = float('inf') 
cost = [inf] * (2**N)
cost[0] = 0

movement = []
for i in range(M):
    move = 0
    for j in range(len(c[i])):
        move += 2 ** (c[i][j]-1)
    movement.append(move)

for i in range(2**N):
    for j in range(M):
        move2 = movement[j] 
        if cost[i|move2] < cost[i]+a[j]:
        cost[i|move2] = cost[i]+a[j]

if cost[2**N-1] == inf:
    print(-1)
else:
    print(cost[2**N-1])

### FIXED CODE ###

#%%
N, M = map(int, input().split())

a = [0] * M
b = [0] * M
c = [[] for _ in range(M)]
for i in range(M):
    a[i], b[i] = map(int, input().split())
    c[i] = list(map(int, input().split()))

inf = float('inf') 
cost = [inf] * (2**N)
cost[0] = 0

movement = []
for i in range(M):
    move = 0
    for j in range(len(c[i])):
        move += 2 ** (c[i][j]-1)
    movement.append(move)

for i in range(2**N):
    for j in range(M):
        move2 = movement[j] 
        if cost[i|move2] > cost[i]+a[j]:
            cost[i|move2] = cost[i]+a[j]

if cost[2**N-1] == inf:
    print(-1)
else:
    print(cost[2**N-1])
from decimal import Decimal, getcontext
getcontext().prec = 1000

li = list(map(Decimal, input().split()))
li = map(lambda x: x.sqrt(), li)

print("Yes" if a + b < c else "No")

### FIXED CODE ###

from decimal import Decimal
a, b, c = map(Decimal, input().split())

ans = (c - a - b)**2 > 4 * a * b

if c - a - b < 0:
    ans = False

print("Yes" if ans else "No")