Harryxun/stf_run huggingface dataset:
N, K = map(int,input().split())
if K == 0:
  li = []
  for i in range(2**(M)):
    li += [i]*2
  print(' '.join(map(str, li)))
else:
  print(-1)


### FIXED CODE ###

M, K = map(int, input().split())

if K >= 2**M:
    print(-1)
elif M == 0:
    if K == 0:
        print(0,0)
    else:
        print(-1)
elif M == 1:
    if K >= 1:
        print(-1)
    else:
        print(0,0,1,1)
else:
    li = [i for i in range(2**M) if i != K]
    ans = li + [K] + list(reversed(li)) + [K]
    print(*ans)
s=input()
t=input()
c=0
for i in range(len(s)):
	if s[i]!=t[i]:
      c+=1
print(c)

### FIXED CODE ###

s=input()
t=input()
c=0
if len(s)==len(t):
    for i in range(len(s)):
        if s[i]!=t[i]:
            c+=1
    print(c)
else:
    print(c)
nums = ['a', 'b', 'c']
a = int(nums[0])
b = int(nums[1])
c = int(nums[2])
if a < b < c:
    print('Yes')
else:
    print('No')

### FIXED CODE ###

nums = input().split()
a = int(nums[0])
b = int(nums[1])
c = int(nums[2])
if a < b < c:
    print('Yes')
else:
    print('No')
mport math
k = int(input())
ans = 0
for i in range(1, k + 1):
    for j in range(1, k + 1):
        gcd1 = math.gcd(i, j)
        for l in range(1, k + 1):
            gcd2 = math.gcd(gcd1, l)
            ans += gcd2
print(ans)

### FIXED CODE ###

import math
k = int(input())
ans = 0
for i in range(1, k + 1):
    for j in range(1, k + 1):
        gcd1 = math.gcd(i, j)
        for l in range(1, k + 1):
            gcd2 = math.gcd(gcd1, l)
            ans += gcd2
print(ans)
import itertools
import numpy as np
N=int(input())
retu=[i for i in range(N)]
XY=[]
for i in range(N):
    x=list(map(int,input().split()))
    XY.append(x)
XY=np.array(XY)
permi=list(itertools.permutations(retu))
goukei=0
count=0
for i,j,k in permi:
    count+=1
    goukei+=np.linalg.norm(XY[i]-XY[j])+np.linalg.norm(XY[j]-XY[k])
print(goukei/count)

### FIXED CODE ###

import itertools
import numpy as np
N=int(input())
retu=[i for i in range(N)]
XY=[]
for i in range(N):
    x=list(map(int,input().split()))
    XY.append(x)
permi=list(itertools.permutations(retu))
goukei=0
count=0
for i in permi:
    count+=1
    for k in range(1,N):
        a=XY[i[k - 1]][0]- XY[i[k]][0]
        b=XY[i[k - 1]][1]- XY[i[k]][1]
        goukei+=(a**2+b**2)**0.5
print(goukei/count)
N, K = map(int, input().split())
h = [i for i in map(int, input().split())]
memo = [0]*N
for i in range(N):
    mini = 10**10
    for j in range(i-min(i, K), i, 1):
        if memo[j] + abs(h[i]-h[j]) < mini:
            mini = memo[j] + abs(h[i]-h[j])
    if i != 0:
        memo[i] = mini
print(memo[N-1])
N, K = map(int, input().split())
h = [i for i in map(int, input().split())]
memo = [0]*N
for i in range(N):
    mini = 10**10
    for j in range(i-min(i, K), i, 1):
        if memo[j] + abs(h[i]-h[j]) < mini:
            mini = memo[j] + abs(h[i]-h[j])
    if i != 0:
        memo[i] = mini
print(memo[N-1])
提出情報

### FIXED CODE ###

N, K = map(int, input().split())
h = [i for i in map(int, input().split())]
memo = [0]*N
for i in range(N):
    mini = 10**10
    for j in range(i-min(i, K), i, 1):
        if memo[j] + abs(h[i]-h[j]) < mini:
            mini = memo[j] + abs(h[i]-h[j])
    if i != 0:
        memo[i] = mini
print(memo[N-1])
import math
from functools import reduce
 
n,m = map(int,input().split())
x = list(map(int,input().split()))
 
aa = []
for i in range(len(x)-1):
    a = x[i+1] - x[i]
    aa.append(a)
 
def gcd(*numbers):
    return reduce(math.gcd, numbers)

if len(x) == 1:
    print(abs(x[0]-m))
else:
    print(gcd(*aa))

### FIXED CODE ###

n,m = map(int,input().split())
aa = list(map(int,input().split()))
 
bb = [abs(a-m) for a in aa]

def gcd(a,b):
    while b:
        a, b = b, a % b
    return a
    
if len(aa) == 1:
    print(abs(aa[0]-m))
else:
    while len(bb) > 1:
        a, b = bb.pop(), bb.pop()
        bb.append(gcd(a,b))
    print(bb[0])
n,m = map(int,input().split())
l = [0]*n
for i in range(0,m):
  for j in list(map(int,input().split())):
    l[j-1]+=1
for i in range(0,n):
  print(l[i])

### FIXED CODE ###

print('Yes') if list(map(lambda a: a[0]<=a[2] and  a[2] <= a[1], [list(map(int,input().split()))]))[0] else print('No')
n = int(input())

cand = 0

def digit_sum(num:int, base:int) -> int:
    if num < base:
        return num
    else:
        return digit_sum(int(num/base), base) + (num % base)

def judge(n: int) -> int:
    if n < 10:
        return n
    
    else:
        # 先頭の位が1のとき、先頭の1を落として全部9にしたものが候補
        if str(n)[0:1] == '1':
            cand = n % 10**(len(str(n)) - 1)
            print(cand)
            
            cand_str = "9"*len(str(cand))
            cand = int(cand_str)
            
            print(cand)
            
            return max(digit_sum(n,10), digit_sum(cand,10))
        
        # そうでないとき、先頭の位を1小さくする
        else:
            top = n // 10**(len(str(n)) - 1)
            cand_str = str(top-1) + "9" * (len(str(n))-1)
            cand = int(cand_str)
            
            return max(digit_sum(n,10), digit_sum(cand,10))
            
        
    


print(ans)

### FIXED CODE ###

def digit_sum(n:int) -> int:
    res = n
    ans = 0
    while res > 0:
        ans = ans + res%10
        res //= 10
    
    return ans

def keta(n:int) -> int:
    res = n
    ans = 0
    while res > 0:
        ans += 1
        res //= 10
    return ans

n = int(input())
n_keta = keta(n)

ans = 0
if n >= 2*10**(n_keta-1):
    ans = n // 10**(n_keta-1) - 1
    ans += 9 * (n_keta-1)
    
elif n == 2*10**(n_keta-1) - 1:
    ans = digit_sum(n)
    
else:
    ans = 9 * (n_keta-1)
    
ans = max(ans, digit_sum(n))
print(ans)
n = int(input())
s = list(int(input()))
cost = s[0]
for i in range(1, n):
    if s[i - 1] < s[i]:
        cost += s[i] - s[i - 1]
print(cost)

### FIXED CODE ###

n = int(input())
s = list(map(int, input().split()))
cost = s[0]
for i in range(1, n):
    if s[i - 1] < s[i]:
        cost += s[i] - s[i - 1]
print(cost)
from collections import defaultdict

n=int(input())
dct=defaultdict(list)

for i in range(n-1):
  a,b,c=map(int,input().split())
  dct[a]+=[[b,c]]
  dct[b]+=[[a,c]]


q,k=map(int,input().split())
lk=[0]*(n)

def dfs(v,p,d):
  lk[v-1]=d

  for l in dct[v]:
    if l[0]==p:
      continue
    else:
      dfs(l[0],v,d+l[1])
  return

dfs(k,-1,0)



for i in range(q):
  x,y=map(int,input().split())
  print(lk[x-1]+lk[y-1])
  
  
  
  
  
  

### FIXED CODE ###

from collections import defaultdict
import sys
sys.setrecursionlimit(10**9)

n=int(input())
dct=defaultdict(list)

for i in range(n-1):
  a,b,c=map(int,input().split())
  dct[a]+=[[b,c]]
  dct[b]+=[[a,c]]


q,k=map(int,input().split())
lk=[0]*(n)

def dfs(v,p,d):
  lk[v-1]=d

  for l in dct[v]:
    if l[0]==p or lk[l[0]-1]!=0:
      continue
    else:
      dfs(l[0],v,d+l[1])
  return

dfs(k,-1,0)



for i in range(q):
  x,y=map(int,input().split())
  print(lk[x-1]+lk[y-1])
def sample(n)
    return n * n * n

n = input()
print sample(n)

### FIXED CODE ###

def sample(n):
    return n * n * n

n = input()
x = sample(n)
print x
#! /usr/bin/env python
# -*- coding: utf-8 -*-

import os
import sys
import itertools
import math
from collections import Counter, defaultdict

class Main(object):
    
    def __init__(self):
        pass

    def solve(self):
        '''
        insert your code
        '''
        while True:
            e = input()
            if e == 0:
                break
            m = float('inf')
            for z in range(101):
                for y in range(1001):
                    x = e - z ** 3 - y ** 2
                    if x >= 0:
                        m = min(m, x + y + z)
            print m
        return None

if __name__ == '__main__':
    m = Main()
    m.solve()

### FIXED CODE ###

#! /usr/bin/env python
# -*- coding: utf-8 -*-

import os
import sys
import itertools
import math
from collections import Counter, defaultdict

class Main(object):
    
    def __init__(self):
        pass

    def solve(self):
        '''
        insert your code
        '''
        while True:
            e = input()
            if e == 0:
                break
            m = float('inf')
            for z in range(101):
                tmp = e - z ** 3
                if tmp < 0:
                    continue
                y = int(math.sqrt(tmp))
                x = e - y ** 2 - z ** 3
                m = min(m, x + y + z)
            print m
        return None

if __name__ == '__main__':
    m = Main()
    m.solve()
from statistics import mean
n = int(input())
a = list(map(int, input().split()))
t = round(mean(a))

sum = 0
for t in a:
    sum += (i - t)**2

print(sum)

### FIXED CODE ###

from statistics import mean
n = int(input())
a = list(map(int, input().split()))
t = round(mean(a))

sum = 0
for i in a:
    sum += (i - t)**2

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

### FIXED CODE ###

a,b,c = map(int, input().split())
print(a*b//2)
import math
n,m=int(input().split())
a=list(map(int,inpit().split()))
ans=0

for i in range(m):
  a=sorted(a,reverse=True)
  a[0]=math.floor(a[0]/2)
     
for j in range(n):
  ans+=a[j]
    
print(ans)


### FIXED CODE ###

import heapq as hq
n,m=map(int,input().split())
a=[-int(x) for x in input().split()]
hq.heapify(a)
for i in range(m):
    x=hq.heappop(a)
    x=-x//2
    hq.heappush(a,-x)
 
print(sum(a)*-1)
food = [int(input()) for _ in range(5)]

total = 0
compare = 0
largest = 0

for x in food:
    if (10 - (x % 10) > compare) and ((x % 10) != 0):
        largest = x
        compare = 10 - (x % 10)

food.remove(largest)
print(largest)

for i in range(len(food)):
    if food[i] % 10 != 0:
        total += round(food[i] + 5.1, -1)
    else:
        total += food[i]

print(int(total+largest))


### FIXED CODE ###

food = [int(input()) for _ in range(5)]

total = 0
compare = 0
largest = 0

if sum(food)%10 == 0:
    print(sum(food))

else:
    for x in food:
        if (10 - (x % 10) > compare) and ((x % 10) != 0):
            largest = x
            compare = 10 - (x % 10)

    food.remove(largest)

    for i in range(len(food)):
        if food[i] % 10 != 0:
            total += round(food[i] + 5.1, -1)
        else:
            total += food[i]

    print(int(total+largest))
a,b=map(int,input().split());print('Even' if a*b%==0 else 'Odd')

### FIXED CODE ###

a,b=map(int,input().split());print('Even' if a*b%2==0 else 'Odd')
s = input()
count = 0
for c in s:
  if c == '1':
    count++
    
print(count)

### FIXED CODE ###

s = input()
count = 0
for c in s:
  if c == '1':
    count += 1
    
print(count)
N=int(input())
S=list(map(int,input().split()))
D={}
mod=((10**9)+7)
ans=1
for i in range(N):
    if S[i]==0:
        if 0 not in D:
            D[0]=1
            ans*=3
        elif D[0]==1:
            D[0]+=1
            ans*=2
        else:
            D[0]=3
    elif S[i] not in D:
        ans*=D[S[i]-1]
        ans%mod
        D[S[i]]=1
    else:
        if D[S[i]]==1:
            ans*=(D[S[i]-1]-1)
            D[S[i]]+=1
            ans%=mod
        elif D[S[i]]==2:
            ans*=(D[S[i]-1]-2)
            D[S[i]]+=1
            ans%=mod
    #print(ans)
print(ans)
            

### FIXED CODE ###

N=int(input())
S=list(map(int,input().split()))
D={}
mod=((10**9)+7)
ans=1
for i in range(N):
    try:
        if S[i]==0:
            if 0 not in D:
                D[0]=1
                ans*=3
            elif D[0]==1:
                D[0]+=1
                ans*=2
            elif D[0]==2:
                D[0]=3
            else:
                ans=0
        elif S[i] not in D:
            ans*=D[S[i]-1]
            ans%mod
            D[S[i]]=1
        else:
            if D[S[i]]==1:
                ans*=(D[S[i]-1]-1)
                D[S[i]]+=1
                ans%=mod
            elif D[S[i]]==2:
                ans*=(D[S[i]-1]-2)
                D[S[i]]+=1
                ans%=mod
            else:
                ans=0
    except:
        ans=0
    #print(ans)
print(ans%mod)
N = int(input())
for i in range(N):
    n,k = map(int,input().split())
    L = list(map(int,input().split()))
    if n <= k:
        print(0)
    else:
        A = []
        for j in range(1,n):
            A.append(L[i]-L[i-1])
        A.sort()
        A.reverse()
        S = L[n-1]-L[0]
        for l in range(k-1):
            S -= A[l]
        print(S)


### FIXED CODE ###

N = int(input())
for i in range(N):
    n,k = map(int,input().split())
    L = list(map(int,input().split()))
    if n <= k:
        print(0)
    else:
        A = []
        for j in range(1,n):
            A.append(L[j]-L[j-1])
        A.sort()
        A.reverse()
        S = L[n-1]-L[0]
        for l in range(k-1):
            S -= A[l]
        print(S)
from bisect import bisect_left
from collections import deque

N = int(input())

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

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

for _ in range(N-1):
    u,v = map(int,input().split())
    u -= 1
    v -= 1
    graph[u].append(v)
    graph[v].append(u)

INF = 10**11
ans = [0]*N
dp = []###INFは空欄として扱って良い
stack = deque([])

def LISonTree(num,pre):
    ###num: 頂点番号
    ###pre: 1つ前にいた頂点番号
    p = bisect_left(dp,a[num])

    ###
    #print(p)
    ###

    if p >= len(dp):
        stack.appendleft((len(dp),INF))
        dp.append(a[num])
    else:
        stack.appendleft((p,dp[p]))
        dp[p] = a[num]
    
    q = bisect_left(dp,INF)
    ans[num] = q

    ###
    #print(num,'dp',dp)
    #print(num,'ans',ans)
    ###

    for x in graph[num]:
        if x == pre:
            continue
        LISonTree(x,num)
    
    changed_p, changed_v = stack.popleft()

    dp[changed_p] = changed_v

    ###
    #print(num,'dp',dp)
    ###

LISonTree(0,-1)
#print(ans)

for y in ans:
    print(y)

### FIXED CODE ###

from bisect import bisect_left
from collections import deque
import sys

sys.setrecursionlimit(200001)

N = int(input())

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

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

for _ in range(N-1):
    u,v = map(int,input().split())
    u -= 1
    v -= 1
    graph[u].append(v)
    graph[v].append(u)

INF = 10**11
ans = [0]*N
dp = []###INFは空欄として扱って良い
stack = deque([])

def LISonTree(num,pre):
    ###num: 頂点番号
    ###pre: 1つ前にいた頂点番号
    p = bisect_left(dp,a[num])

    ###
    #print(p)
    ###

    if p >= len(dp):
        stack.appendleft((len(dp),INF))
        dp.append(a[num])
    else:
        stack.appendleft((p,dp[p]))
        dp[p] = a[num]
        
    
    q = bisect_left(dp,INF)
    ans[num] = q

    ###
    #print(num,'dp',dp)
    #print(num,'ans',ans)
    ###

    for x in graph[num]:
        if x == pre:
            continue
        LISonTree(x,num)
    
    changed_p, changed_v = stack.popleft()

    dp[changed_p] = changed_v

    ###
    #print(num,'dp',dp)
    ###

LISonTree(0,-1)
#print(ans)

for y in ans:
    print(y)
N=int(input())
B=map(int,input().split())
sum=B[0]
for i in range(len(B)-1):
  sum+=min(B[i],B[i+1])
sum+=B[-1]
print(sum)

### FIXED CODE ###

N=int(input())
B=list(map(int,input().split()))
sum=B[0]
for i in range(len(B)-1):
  sum+=min(B[i],B[i+1])
sum+=B[-1]
print(sum)
def rec(c, a, x, n, m, start, states, best, price):

    for i in range(start, n):
        price += c[i]
        states[0] += a[i][0]
        states[1] += a[i][1]
        states[2] += a[i][2]

        if states[0] >= x and states[1] >= x and states[2] >= x and price < best:
            best = price

        if i != n - 1:
            best = rec(c, a, x, n, m, i + 1, states, best, price)

        states[0] -= a[i][0]
        states[1] -= a[i][1]
        states[2] -= a[i][2]
        price -= c[i]

    return best


def task(n, m, x, c, a):
    mx = [0] * n
    for i in range(0, n):
        for j in range(0, m):
            mx[j] += a[i][j]

    for j in range(0, m):
        if mx[j] < x:
            print(-1)
            return

    best = rec(c, a, x, n, m, 0, [0, 0, 0], 1000000, 0)

    print(best)


n, m, x = map(int, input().split())
c = []
a = []
for i in range(0, n):
    values = list(map(int, input().split()))
    c.append(values[0])
    a.append(values[1:])

task(n, m, x, c, a)


### FIXED CODE ###

def task(n, m, x, c, a):
    mx = [0] * m
    for i in range(0, n):
        for j in range(0, m):
            mx[j] += a[i][j]

    for j in range(0, m):
        if mx[j] < x:
            print(-1)
            return

    states = [0] * m

    best = 100000000
    for i in range(1, 2**n):
        price = 0

        for k in range(0, m):
            states[k] = 0

        for j in range(0, n):
            if ((i >> j) & 1):
                price += c[j]
                for k in range(0, m):
                    states[k] += a[j][k]

        if price < best:
            found = True
            for k in range(0, m):
                if states[k] < x:
                    found = False
                    break

            if found:
                best = price

    print(best)


n, m, x = map(int, input().split())
c = []
a = []
for i in range(0, n):
    values = list(map(int, input().split()))
    c.append(values[0])
    a.append(values[1:])

task(n, m, x, c, a)
a, b = map(float, input().split())
ans = a * b

print(math.floor(ans))


### FIXED CODE ###

a, b = map(float, input().split())
a = int(a)
b = int(b * 1000)

print(a*b//1000)
S=int(input())
h=int(S/3600)
S2=S-h
m=int(S2/60)
s=S2-m
print('{}:{}:{}',format(h,m,s))

### FIXED CODE ###

S=int(input())
h=int(S/3600)
m=int(S/60)%60
s=S%60
print('{}:{}:{}'.format(h,m,s))
S, W = map(int, input().split())
if S <= 2 * W:
  print("unsafe")
else:
  print(safe)

### FIXED CODE ###

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

if W >= S:
  print('unsafe')
else:
  print('safe')
N = int(input())
sum=0
for i in range(N):
    x, u = input().split()
    if u == "JPY":
        sum+=int(x)
    else:
        sum+=int(x)*380000
print(sum)

### FIXED CODE ###

N = int(input())
sum=0
for i in range(N):
    x, u = list(map(str, input().split()))
    if u == "JPY":
        sum+=int(x)
    else:
        sum+=float(x)*380000
print(sum)
C = [list(map(int, input().split()))  for _ in range(3)]

for i in range(2):
  for j in range(2):
    if C[i][j] - C[i][j+1] != C[i+1][j] - C[i+1][j+1] :
    break
    if C[j][i] - C[j+1][i] != C[j][i+1] - C[j+1][i+1] :
      break
else:
  print("Yes")
  out = True
if not out:
  print("No")


### FIXED CODE ###

C = [list(map(int, input().split()))  for _ in range(3)]

x = [list() for _ in range(2)]
y = [list() for _ in range(2)]
for i in range(3):
  for j in range(2):
    x[j].append(C[i][j] - C[i][j+1])
    y[j].append(C[j][i] - C[j+1][i])

out = False
for j in range(2):
  if min(x[j]) != max(x[j]):
    break
  if min(y[j]) != max(y[j]):
    break
else:
  print("Yes")
  out = True
if not out:
  print("No")
def is_even(num):
    if num == 0:
        return True
    return num % 2 == 0


height, width = list(map(int, input().split()))
coin_table = [list(map(is_even, map(int, input().split()))) for i in range(height)]

move_list = list()

for h in range(height):
    for w in range(width):
        if not(coin_table[h][w]):
            coin_table[h][w] = True
            if w == width-1:
                coin_table[h + 1][w] = not coin_table[h + 1][w]
                move_list.append([h + 1, w + 1, h + 2, w + 1])
            else:
                coin_table[h][w+1] = not coin_table[h][w+1]
                move_list.append([h + 1, w + 1, h + 1, w + 2])

print(len(move_list))
for i in range(len(move_list)):
    print("{0} {1} {2} {3}".format(move_list[i][0], move_list[i][1], move_list[i][2], move_list[i][3]))


### FIXED CODE ###

def is_even(num):
    if num == 0:
        return True
    return num % 2 == 0


height, width = list(map(int, input().split()))
coin_table = [list(map(is_even, map(int, input().split()))) for i in range(height)]

move_list = list()

for h in range(height):
    for w in range(width):
        if not(coin_table[h][w]):
            coin_table[h][w] = True
            if w == width-1:
                if h == height-1:
                    break
                coin_table[h + 1][w] = not coin_table[h + 1][w]
                move_list.append([h + 1, w + 1, h + 2, w + 1])
            else:
                coin_table[h][w+1] = not coin_table[h][w+1]
                move_list.append([h + 1, w + 1, h + 1, w + 2])

print(len(move_list))
for i in range(len(move_list)):
    print("{0} {1} {2} {3}".format(move_list[i][0], move_list[i][1], move_list[i][2], move_list[i][3]))
N = int(input())
A = list(map(int, input().split()))
import numpy as np
ans = np.prod(A)

if 0 in A:
    print(0)
    exit(0)
if ans<= 10**18:
    print(ans)
    exit(0)
else:
    print(-1)

### FIXED CODE ###

import sys  # sys.exit()を使いたいので

n = int(input())
a = list(map(int, input().split()))

if 0 in a:
# 0が1つでもあれば0です
    print(0)
else:
# 0がない場合
    cur = 1  # 現在の数値
    for x in a:
        cur *= x
        if cur > 10 ** 18:
        # 10**18を超えたので終了します
            print(-1)
            sys.exit()
    print(cur)  # 10**18以下なので、出力します
n,m = map(int,input().split())
keta = []
number = []

for i in range(m):
    n,a=input().split()
    keta.append(int(n))
    number.append(a)

ccount = 0
count = 0   
ans = 0
if n == 3:
   ans = 100
if n == 2:
   ans = 10
if n == 1:
   ans = 0

while count == 0:
   ans = str(ans)
   for i in range(0,m):
      if ans[keta[i]-1] == number[i]:
         ccount += 1
   if ccount == m:
      count += 1
   ccount = 0
   ans = int(ans)
   ans += 1
   if n = 3 and (ans - 1) == 1000:
      ans = 0
      break
   if n = 2 and (ans - 1) == 100:
      ans = 0
      break
   if n = 1 and (ans - 1) == 10:
      ans = 0
      break
print(ans - 1)

### FIXED CODE ###

n,m = map(int,input().split())
keta = []
number = []

for i in range(m):
    b,a=input().split()
    keta.append(int(b))
    number.append(a)

ccount = 0
count = 0   
ans = 0
if n == 3:
   ans = 100
else:
   pass
if n == 2:
   ans = 10
else:
   pass
if n == 1:
   ans = 0
else:
   pass

while count == 0:
   ans = str(ans)
   for i in range(0,m):
      if ans[keta[i]-1] == number[i]:
         ccount += 1
   if ccount == m:
      count += 1
   ccount = 0
   ans = int(ans)
   ans += 1
   if n == 3 and (ans - 1) == 1000:
      ans = 0
      break
   if n == 2 and (ans - 1) == 100:
      ans = 0
      break
   if n == 1 and (ans - 1) == 10:
      ans = 0
      break
print(ans - 1)
from collections import Counter
N = int(input())
A = [int(i) for i in input().split()]
ct = list(Counter(A).items())
flg = 0
ct. sort(key=lambda x: x[0], reverse=True)
for i in ct:
    if i[1] >= 4 and flg == 0:
        ans = i[0]**2
        break
    if i[1] >= 2 and flg == 0:
        flg = 1
        ans = i[0]
    elif i[1] >= 2 and flg == 1:
        ans *= i[0]
        break
print(ans)

### FIXED CODE ###

from collections import Counter
N = int(input())
A = [int(i) for i in input().split()]
ct = list(Counter(A).items())
flg = 0
ct. sort(key=lambda x: x[0], reverse=True)
for i in ct:
    if i[1] >= 4 and flg == 0:
        flg = 2
        ans = i[0]**2
        break
    if i[1] >= 2 and flg == 0:
        flg = 1
        ans = i[0]
    elif i[1] >= 2 and flg == 1:
        flg = 2
        ans *= i[0]
        break

if flg != 2:
    print(0)
else:
    print(ans)
a,b=map(int,intpu().split())
if a<10 and b<10:
  print(a*b)
else:
  print('-1')

### FIXED CODE ###

a,b=map(int,input().split())
if a<10 and b<10:
  print(a*b)
else:
  print('-1')
n=['A', 'B', 'C', 'D', 'E', 'F']
a,b=map(int,input().split())
c,d=n.index(a),n.index(b)
if c>d:
  print('>')
elif c<d:
  print('<')
else:
  print('=')

### FIXED CODE ###

c,d=map(str,input().split())
n=sorted([c,d])
a=n.index(c)
b=n.index(d)
if a>b:
  print('>')
elif a==b:
  print('=')
else:
  print('<')