Harryxun/stf_run huggingface dataset:
D = []

def append(value):
    global D

    hashvalue = ""
    for letter in value:
        hashvalue += str(ord(letter))

    D.append(int(hashvalue))

def find(value):
    hashvalue = ""
    for letter in value:
        hashvalue += str(ord(letter))

    hashvalue = int(hashvalue)

    left = 0
    right = len(D) - 1

    while True:
        mid = (left + right) // 2

        if D[mid] == hashvalue:
            print("yes")
            return
        elif D[mid] < hashvalue:
            left = mid + 1
        else:
            right = mid - 1

        if left > right:
            print("no")
            return


def main():
    global D

    N = int(input())
    finds = []

    for _ in range(N):
        command, value = [i for i in input().split()]

        if command == "insert":
            append(value)
            D.sort()
        else:
            find(value)

main()



### FIXED CODE ###

import sys
import collections

# Set max recursion limit
sys.setrecursionlimit(1000000)


def li_input():
    return [int(_) for _ in input().split()]


def main():
    N = int(input())
    C = [input().split() for _ in range(N)]

    D = collections.defaultdict(lambda: 0)

    for c in C:
        command, value = c

        if command == "insert":
            D[value] = 1
        else:
            if D[value] == 1:
                print("yes")
            else:
                print("no")


main()
import math
r = int(input())
print("{0:.6f} {1:.6f}".format(r**2*math.pi,r*2*math.pi))

### FIXED CODE ###

import math
r = float(input())
print("{0:.6f} {1:.6f}".format(r**2*math.pi,r*2*math.pi))
a,b,c=[int(i) for i in input().split()
print(max(a,b,c)*9+a+b+c)

### FIXED CODE ###

a,b,c=[int(i) for i in input().split()]
print(max(a,b,c)*9+a+b+c)
n, k = map(int, input().split(" "))
houses = list(map(int, input().split(" ")))
dif_houses = [houses[x+1]-houses[x] for x in range(k-1)]
dif_houses.append(houses[0]-houses[k-1]+n)

max_dif = max(dif_houses)
print(n-max_dif)

### FIXED CODE ###

s = input()
if s[2]==s[3] and s[4]==s[5]:
    print("Yes")
else:
    print("No")
s=input()
if s.startwith("YAKI"):
  print("Yes")
else:
  print("No")

### FIXED CODE ###

s=input()
if s.startswith("YAKI"):
  print("Yes")
else:
  print("No")
T = list(input())

for i in reversed(range(len(T))):
    if T[i] == '?':
        if i == len(T)-1:
            T[i] = 'D'
        if T[i+1] == 'D':
            T[i] = 'P'
        else:
            T[i] = 'D'
    else:
        continue

print(''.join(T))

### FIXED CODE ###

import copy
T = list(input())
P = [0]*(len(T)+10)
P[0] = 0
if T[0] == '?':
    T[0] = 'D'
for i in range(len(T)):
    if T[i] == '?':
        if T[i-1] == 'D':
            T[i] = 'D'
            P[i+1] = P[i] + 1
        else:
            T[i] = 'D'
            P[i+1] = P[i] + 2
    else:
        if T[i] == 'D':
            if T[i-1] == 'D':
                P[i+1] += P[i]+1
            else:
                P[i+1] = P[i]+2
        else: 
            P[i+1] = P[i]   


print(''.join(T))
import fractions
n, m = map(int, input().split())
a = list(map(int, input().split()))
a = [i//2 for i in a]

def f(x):
  cnt = 0
  while x%2 == 0:
    x /= 2
    cnt += 1
  return cnt

t = f(a[0])
for i in range(1, t):
  if f(a[i]) != t:
    print(0)
    break
  a[i] //= 2 ** t

lcm = a[0]
for i in range(1, n):
  lcm = lcm * a[i] // fractions.gcd(lcm, a[i])

if lcm > m:
  ans = 0
else:
  m //= lcm
  ans = (m+1) // 2
print(ans)

### FIXED CODE ###

import sys

def f(x):
  cnt = 0
  while x%2 == 0:
    x /= 2
    cnt += 1
  return cnt

def gcd(x, y):
  if y:
    return gcd(y, x%y)
  else:
    return x

def lcm(x, y):
  return (x * y) // gcd(x, y)


n, m = map(int, input().split())
a = list(map(int, input().split()))
a = [i//2 for i in a]

t = f(a[0])
for i in range(n):
  if f(a[i]) != t:
    print(0)
    sys.exit()
  a[i] >>= t
m >>= t

l = 1
for i in range(n):
  l = lcm(l, a[i])
  if l > m:
    print(0)
    sys.exit()

m //= l
ans = (m+1) // 2
print(ans)
N= int(input())

MP=[list(map(int,input().split())) for i in range(N)]
MP2=[]
for li in MP:
    MP2.append(li.copy())

MP3=[[-1]*N for _ in range(N)]

# ワーシャルフロイド
for k in range(N):
    for i in range(N):
        for j in range(N):
            cand = MP2[i][k] + MP2[k][j]
            if cand <= MP2[i][j]:
                MP2[i][j] = cand
                if (i != k and j != k):
                    MP3[i][j] = k

for i in range(N):
    for j in range(N):
        if MP[i][j] != MP2[i][j]:
            print(-1)
            exit()

checked=set()

res = set()
def dfs(i,j):
    k = MP3[i][j]
    if k == -1:
        k = i
    if (i,j) in checked:
        return
    checked.add((i,j))
    if (i == k or j == k):
        if i < j:
            res.add((i,j))
    else:
        dfs(i,k)
        dfs(k,j)

for i in range(N):
    for j in range(N):
        dfs(i,j)

ressum = 0
for i,j in res:
    ressum += MP[i][j]

# for li in MP3:
#     print(li)
# print(res)
print(ressum)


### FIXED CODE ###

N=int(input())
MP=[list(map(int,input().split())) for i in range(N)]
MP2=[]
for li in MP:
    MP2.append([i for i in li])

MP3=[[-1]*N for _ in range(N)]

# ワーシャルフロイド
for k in range(N):
    for i in range(N):
        for j in range(N):
            cand = MP2[i][k] + MP2[k][j]
            if cand <= MP2[i][j]:
                MP2[i][j] = cand
                if (i != k and j != k):
                    MP3[i][j] = k

for i in range(N):
    for j in range(N):
        if MP[i][j] != MP2[i][j]:
            print(-1)
            exit()

checked=set()

res = set()
def dfs(i,j):
    k = MP3[i][j]
    if k == -1:
        k = i
    if (i,j) in checked:
        return
    checked.add((i,j))
    if (i == k or j == k):
        if i < j:
            res.add((i,j))
    else:
        dfs(i,k)
        dfs(k,j)

for i in range(N):
    for j in range(N):
        dfs(i,j)

ressum = 0
for i,j in res:
    ressum += MP[i][j]

# for li in MP3:
#     print(li)
# print(res)
print(ressum)
a = [int(input()) for _ in range(n)]
a.sort(reverse = True)
print(len(list(set(a))))

### FIXED CODE ###

n = int(input())
a = [0]*n
for i in range(n):
    a[i] = int(input())
a.sort(reverse = True)

s = set(a)
a_list = list(s)
print(len(a_list))
def f(s):
  m,y = int(s[:2]), int(s[2:])
  return 0< m <= 12:

def g(s):
  y,m = int(s[:2]), int(s[2:])
  return 0< m <= 12:
    
s = raw_input()
p,q = f(s), g(s)

if p and q:
  print 'AMBIGUOUS'
elif p and not(q):
  print 'MMYY'
elif q and not(p):
  print 'YYMM'
else:
  print 'NA'

### FIXED CODE ###

def f(s):
  m,y = int(s[:2]), int(s[2:])
  return 0< m <= 12

def g(s):
  y,m = int(s[:2]), int(s[2:])
  return 0< m <= 12
    
s = raw_input()
p,q = f(s), g(s)

if p and q:
  print 'AMBIGUOUS'
elif p and not(q):
  print 'MMYY'
elif q and not(p):
  print 'YYMM'
else:
  print 'NA'
import numpy as np

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

K_str = format(K, 'b')
max_order = len(K_str)

B = np.array([list(format(a, '0{}b'.format(max_order)))
              for a in A]
             ).astype('i')[:, :max_order]
B = B.sum(axis=0)
B = np.where(B < N/2, 1, 0)

X_str = ''.join(map(str, B))

for i in range(max_order):
    if K_str[i] < X_str[i]:
        X_str[i] = 0

X = int(X_str, 2)

print(sum(map(lambda a: X ^ a, A)))

### FIXED CODE ###

import numpy as np

N, K = [int(a) for a in input().split()]
A = [int(a) for a in input().split()]

K = format(K, 'b')
B = [format(a, 'b') for a in A]
max_order = len(max(B + [K], key=len))

K = K.zfill(max_order)
B = np.array([list(b.zfill(max_order)) for b in B], dtype='i')
B = B.sum(axis=0)
B = np.where(B < N/2, '1', '0')

for i, k, b in zip(range(max_order), K, B):
    if k < b:
        B[i] = '0'
    elif k > b:
        break

X = int(''.join(map(str, B)), 2)

print(sum(map(lambda a: X ^ a, A)))
import sys
 
N = int(input())
seq = list(map(int, input().rstrip().split(' ')))

odd = [0] * int(1e5)
even = [0] * int(1e5)

for i in range(0, N, 2):
    even[seq[i]] += 1
    
for i in range(1, N, 2):
    odd[seq[i]] += 1

type_number = 0
for i in range(0, int(1e5)):
    if odd[i] + even[i] > 0:
        type_number += 1

max_even = max(even)
max_odd = max(odd)

count = 0
count += N // 2 - max_even
count += N // 2 - max_odd

if type_number == 1:
    print(N // 2)
else:
    print(count)

### FIXED CODE ###


N = int(input())
seq = list(map(int, input().rstrip().split(' ')))

odd = [[0, i] for i in range(int(1e5 + 1))]
even = [[0, i] for i in range(int(1e5 + 1))]

for i in range(0, N, 2):
    even[seq[i]][0] += 1
    
for i in range(1, N, 2):
    odd[seq[i]][0] += 1

sorted_even = sorted(even, key=lambda x: x[0])[::-1]
sorted_odd = sorted(odd, key=lambda x: x[0])[::-1]

if sorted_even[0][1] == sorted_odd[0][1]:
    if sorted_even[0][0] + sorted_odd[1][0] > sorted_even[1][0] + sorted_odd[0][0]:
        max_even = sorted_even[0][0]
        max_odd = sorted_odd[1][0]
    else:
        max_even = sorted_even[1][0]
        max_odd = sorted_odd[0][0]
else:
    max_even = sorted_even[0][0]
    max_odd = sorted_odd[0][0]
 
count = 0
count += N // 2 - max_even
count += N // 2 - max_odd

print(count)
import sys
from bisect import bisect_right
input = sys.stdin.readline().strip()
A, B, Q = map(int, input().split())
INF = 10 ** 18
s = [-INF] + [int(input()) for i in range(A)] + [INF]
t = [-INF] + [int(input()) for i in range(B)] + [INF]
xs = [int(input()) for i in range(Q)]
for x in xs:
    b, d = bisect_right(s, x), bisect_right(t, x)
    res = INF
    for S in [s[b - 1], s[b]]:
        for T in [t[d - 1], t[d]]:
            d1, d2 = abs(S - x) + abs(T - S), abs(T - x) + abs(S - T)
            res = min(res, d1, d2)
    print(res)

### FIXED CODE ###

import sys
from bisect import bisect_right
input = sys.stdin.readline
A, B, Q = map(int, input().split())
INF = 10 ** 18
s = [-INF] + [int(input()) for i in range(A)] + [INF]
t = [-INF] + [int(input()) for i in range(B)] + [INF]
xs = [int(input()) for i in range(Q)]
for x in xs:
    b, d = bisect_right(s, x), bisect_right(t, x)
    res = INF
    for S in [s[b - 1], s[b]]:
        for T in [t[d - 1], t[d]]:
            d1, d2 = abs(S - x) + abs(T - S), abs(T - x) + abs(S - T)
            res = min(res, d1, d2)
    print(res)
n = int(input())
a = [int(i) for i in input().split()]
table = [True for _ in range(10 ** 6)]
a.sort()
ans = 0
for i in range(n):
    if table[a[i]]:
        for j in range(a[i], 10 ** 6, a[i]):
            table[j] = False
        if i + 1 < n:
            if a[i + 1] != a[i]:
                ans += 1
        elif i + 1 == n:
            ans += 1
print(ans)

### FIXED CODE ###

n = int(input())
a = [int(i) for i in input().split()]
table = [True for _ in range(2 * (10 ** 6))]
a.sort()
ans = 0
for i in range(n):
    if table[a[i]]:
        for j in range(a[i], 2 * (10 ** 6), a[i]):
            table[j] = False
        if i + 1 < n:
            if a[i + 1] != a[i]:
                ans += 1
        elif i + 1 == n:
            ans += 1
print(ans)
import math
a,b = input(),input()
c = int(a+b)
d = math.sqrt(c)
if c / d == d:
  print("Yes")


### FIXED CODE ###

a,b = input().split()
c = int(a + b)
d = []
for i in range(400):
  d.append(i**2)
if c in d:
  print("Yes")
else:
  print("No")
def main():
    N, M, K = map(int, input().split())
    *A, = map(int, input().split())
    *B, = map(int, input().split())

    ai = 0
    t = 0
    cnt = 0
    while True:
        if ai < len(A) and t + A[ai] <= K:
            t += A[ai]
            ai += 1
            cnt += 1
            continue
        break

    ans = cnt
    bi = 0
    while True:
        if bi < len(B):
            while ai >= 0 and t + B[bi] > K:
                t -= A[ai]
                ai -= 1
                cnt -= 1
            if t + B[bi] <= K:
                t += B[bi]
                bi += 1
                cnt += 1
                ans = max(ans, cnt)
                continue
        break

    print(ans)


if __name__ == '__main__':
    main()


### FIXED CODE ###

def main():
    N, M, K = map(int, input().split())
    *A, = map(int, input().split())
    *B, = map(int, input().split())

    def accumulate(a):
        s = 0
        yield s
        for x in a:
            s += x
            yield s

    *P, = accumulate(A)
    *Q, = accumulate(B)

    ans = 0
    j = len(Q) - 1
    for i, x in enumerate(P):
        while j > 0 and x + Q[j] > K:
            j -= 1
        if x + Q[j] <= K:
            ans = max(ans, i + j)
    print(ans)


if __name__ == '__main__':
    main()
import numpy as np
import sys
input = sys.stdin.readline


def main():
    n = int(input())
    A = np.array([int(i) for i in input().split()])

    A.sort()
    max_dp = A[-1]
    A = np.append(A, 10 ** 6 + 2)

    dp = np.ones(max_dp + 1, dtype=bool)

    if A[0] == A[1]:
        ans = 1

    ans = 0
    for i in range(n):
        if A[i] == A[i + 1] or not dp[A[i]]:
            continue
        # print(f"{i = }, {max_dp = }\n{dp = }")
        a = A[i]
        fancy = np.arange(a, max_dp + 2, a)
        dp[fancy] &= False

        ans += 1

    print(ans)


if __name__ == '__main__':
    main()

### FIXED CODE ###

import numpy as np
import sys
input = sys.stdin.readline


def main():
    n = int(input())
    A = np.array([int(i) for i in input().split()])

    max_dp = np.max(A) + 1
    dp = np.zeros(max_dp, dtype="int32")

    for a in A:
        if dp[a] >= 2:
            continue
        fancy = np.arange(a, max_dp, a)
        dp[fancy] += 2
        dp[a] -= 1
    print(np.sum(dp == 1))


if __name__ == '__main__':
    main()
import math
n = int(input())
lr = [None]*10000
BT = False
rmax = 0
for i in range(n):
    lr[i]= list(map(int,input().split()))
    if lr[i][1] > rmax:
        rmax = lr[i][1]

p = [1]*(rmax+1)
p[0]=0
p[1]=0
        

for j in range(2,int(math.sqrt(rmax)+1)):
    if p[j] == 0:
        continue
    for i in range(2,rmax+1):
        if i!=j and i%j == 0:
            p[i] = 0
for i in range(rmax, 1,-2):
    if p[(i+1)//2] == 0:
        p[i] = 0
for i in range(2,rmax):
    p[i+1] +=p[i]
  

for i in range(n):
    print(p[lr[i][1]] - p[lr[i][0]-1])

### FIXED CODE ###

import math
n = int(input())
lr = [None]*100000
rmax = 0
for i in range(n):
    lr[i]= list(map(int,input().split()))
    if lr[i][1] > rmax:
        rmax = lr[i][1]

p = [1]*(rmax+1)
p[0]=0
p[1]=0
        

for j in range(2,int(math.sqrt(rmax)+1)):
    if p[j] == 0:
        continue
    for i in range(2,rmax+1):
        if i!=j and i%j == 0:
            p[i] = 0
for i in range(rmax, 1,-2):
    if p[int((i+1)/2)] == 0:
        p[i] = 0
p[2] = 0
for i in range(2,rmax):
    p[i+1] += p[i]  

for i in range(n):
    print(p[lr[i][1]] - p[lr[i][0]-1])
while True:
    try:
        a,b=map(int,raw_input().split())
        print a-b

### FIXED CODE ###

while True:
    try:
        a,b=map(int,raw_input().split())
        print a-b
    except:
        break
# encoding: utf-8
N, M = list(map(int, input().split()))

d_sym = {}
sym = 0

# refresh

for A in map(int, input().split()):
    sym = (sym + A) % M
    if str(sym) in d_sym: d_sym[str(sym)] += 1
    else: d_sym[str(sym)] = 1

print(int(d_sym["0"] + sum([val * (val - 1) / 2 for val in d_sym.values()])))

### FIXED CODE ###

# encoding: utf-8
N, M = list(map(int, input().split()))

d_sym = {}
sym = 0

# refresh

ans = 0
for A in map(int, input().split()):
    sym = (sym + A) % M
    #
    if sym == 0: ans += 1
    # 
    if str(sym) in d_sym.keys(): d_sym[str(sym)] += 1
    else: d_sym[str(sym)] = 1

print(int(ans + sum([val * (val - 1) / 2 for val in d_sym.values()])))
import heapq


def dijkstra_heap(s):
    d = [float("inf")] * n
    prev = [float("inf")] * n
    d[s] = 0
    edgelist = [[d[s], s]]
    heapq.heapify(edgelist)

    while edgelist:
        dis, v = heapq.heappop(edgelist)
        if d[v] < dis:
            continue

        for e in edge[v]:
            if d[e] > dis + 1:
                d[e] = dis + 1
                heapq.heappush(edgelist, [dis + 1, e])
                prev[e] = v
    return d, prev


n, w = map(int, input().split())

edge = [[] for i in range(w)]
for i in range(w):
    x, y = map(int, input().split())
    x -= 1
    y -= 1
    edge[x].append(y)
    edge[y].append(x)
d, prev = dijkstra_heap(0)

if float('inf') in prev[1:]:
    print('No')
else:
    print('Yes')
    for i, j in enumerate(prev[1:]):
        print(j + 1)


### FIXED CODE ###

import heapq


def dijkstra_heap(s):
    d = [float("inf")] * n
    prev = [float("inf")] * n
    d[s] = 0
    edgelist = [[d[s], s]]
    heapq.heapify(edgelist)

    while edgelist:
        dis, v = heapq.heappop(edgelist)
        if d[v] < dis:
            continue

        for e in edge[v]:
            if d[e] > dis + 1:
                d[e] = dis + 1
                heapq.heappush(edgelist, [dis + 1, e])
                prev[e] = v
    return d, prev


n, w = map(int, input().split())

edge = [[] for i in range(n)]
for i in range(w):
    x, y = map(int, input().split())
    x -= 1
    y -= 1
    edge[x].append(y)
    edge[y].append(x)
d, prev = dijkstra_heap(0)

if float('inf') in prev[1:]:
    print('No')
else:
    print('Yes')
    for i in prev[1:]:
        print(i + 1)
S,T = map(str,input.split())
A,B = map(int,input.split())
u = str(input())
if s == u:
    a -= 1
else :
    b -= 1
print("{0} {1}".format(a,b))

### FIXED CODE ###

S, T = map(str,input().split())
A, B = map(int,input().split())
U = input()
 
if S == U: A -= 1
if T == U: B -= 1
print("{0} {1}".format(A,B))
s = raw_input()
def test(s):

	res = 0
	aAdd = 0
	last = ''
	s1 = s
	tmp = ''
	for i in xrange(len(s)-2):
		if tmp and tmp > i:
			continue
		if s1[i] == 'A' and (not last or last == 'A'):
			aAdd += 1
		else:
			aAdd = 0
			last = s1[i]

		if s1[i:i+3] == 'ABC':
			print s1
			print aAdd
			res = res + aAdd
			last = 'A'
			aAdd -= 1
			tmp = i + 2
			s1 = s1[:i] + 'BCA' + s1[i+3:]

	return res
print test(s)

### FIXED CODE ###

def test(s):

	res = 0
	aAdd = 0
	last = ''
	tmp = ''
	for i in xrange(len(s)):
		if tmp and tmp > i:
			continue
		if s[i] == 'A':
			aAdd += 1
		elif s[i:i+2] == 'BC':
			# print aAdd
			res = res + aAdd
			tmp = i + 2
		else:
			aAdd = 0
			last = s[i]


	return res
s=raw_input()
print test(s)
S = input()
s1 = '0'
s2 = '1'
c1 = 0
c2 = 0

for i in range(len(S)):
    if i == 0:
        s1 = '0'
        s2 = '1'
    elif i % 2 == 1:
        s1 += 1
        s2 += 0
    else:
        s1 += 0
        s2 += 1

for i in range(len(S)):
    if S[i] == s1[i]:
        c2 += 1
    else:
        c1 += 1

print(min(c1, c2))

### FIXED CODE ###

S = input()
c1 = 0
c2 = 0

for i in range(len(S)):
    if i == 0:
        s1 = '0'
        s2 = '1'
    elif i % 2 == 1:
        s1 += '1'
        s2 += '0'
    else:
        s1 += '0'
        s2 += '1'

for i in range(len(S)):
    if S[i] == s1[i]:
        c2 += 1
    else:
        c1 += 1

print(min(c1, c2))
N = int(input())
A = list(map(int,input().split()))
from collections import Counter
AA = Counter(A)
B = []
C = []
for k,v in AA.items():
    if v>=2:
        B.append(k)
    if v>=4:
        C.append(k)
B.sort(reverse=True)
C.sort(reverse=True)
if len(B)<=1 and len(C)==0:
    print(0)
else:
    if len(B)<=1:
        print(C[0]*C[0])
    else:
        print(max(B[0]*B[1],C[0]*C[0]))

### FIXED CODE ###

N = int(input())
A = list(map(int,input().split()))
from collections import Counter
AA = Counter(A)
B = []
C = []
for k,v in AA.items():
    if v>=2:
        B.append(k)
    if v>=4:
        C.append(k)
B.sort(reverse=True)
C.sort(reverse=True)
if len(B)<=1 and len(C)==0:
    print(0)
else:
    if len(B)<=1:
        print(C[0]*C[0])
    elif len(C)==0:
        print(B[0]*B[1])
    else:
        print(max(B[0]*B[1],C[0]*C[0]))
import itertools
n = int(input())
k = int(input())
l = list(range(n+1))
ad = 0
for i in list(range(k,n+2)):
        l2 = list(itertools.combinations(l,r=i))
        se = set([sum(j) for j in l2])
        ad += len(se)
print(ad)


### FIXED CODE ###

N,K = map(int,input().split())
ad = 0
mod = 10 **9 + 7
for k in range(K,N+2):
  ma = (N*(N+1) - (N-k)*(N-k+1))//2
  mi = (k-1)*k//2
  ad += (ma - mi+1)
print(ad%mod)
Number = int(input())
tresure_value = list(map(int , input().split()))
cost = list(map(int , input().split()))
cnt = 0
 
for i in range(len(tresure_value)):
  benefit = tresure_value[i] - cost[i]
  if benefit  > 0:
    count = count + benefit 
    
print(cnt)


### FIXED CODE ###

Number = int(input())
tresure_value = list(map(int , input().split()))
cost = list(map(int , input().split()))
cnt = 0
 
for i in range(len(tresure_value)):
  benefit = tresure_value[i] - cost[i]
  if benefit  > 0:
    cnt = cnt + benefit 
    
print(cnt)
a

### FIXED CODE ###

a,b=map(int,raw_input().split())
x=a+b
y=a-b
z=a*b
if x<y:
  x=y
if x<z:
  x=z
print x
# -*- coding: utf-8 -*-
l = map(int, raw_input().split())
n = l[0]
t = l[1]

"""
x = []
for i in range(n):
  x.append(map(int, raw_input().split()))
print(x)
"""

lst = [map(int, raw_input().split()) for i in range(n)]
#print(lst)

"""
minc = x[0]
mint = t

for j in range(n):
  if x[j][1] <= mint:
    mint = x[j][1]
    minc = x[j][0]
    #print("mint updated")
  else:
    continue

if mint < t:
  print(minc)
else:
  print("TLE")
"""

#sort_using lambda
lst = sorted(lst, key = lambda x:x[1])
#print(lst)

maxt = t
minc = 9999

for j in range(n + 10):
  if lst[j][1] <= maxt and lst[j][0] <= minc:
    minc = lst[j][0]
  else:
    break

"""
if maxt <= t:
  print(minc)
else:
  print("TLE")
"""

if minc == 9999:
  print("TLE")
else:
  print(minc)


### FIXED CODE ###

lst = []
n = input()
if n == 1:
  print('Hello World')

else:
  for i in range(2):
    lst.append(input())
  print(lst[0] + lst[1])
x,n=map(int,input().split())

p=set(map(int,input().split()))

n=set(n for n in range(-100,101))

pd=list(n-p)

min1=1000

for i in range(len(pd)):
    if abs(pd[i]-x)<abs(min1-x):
        min1=pd[i]
    elif abs(pd[i]-x)==abs(min1-x):
        min1=min(pd[i],min1)
print(min1)

### FIXED CODE ###

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

for i in range(5):
    if x[i]==0:
        print(i+1)
        break
def main():
  n=int(input())
  l=list(map(int,input().split()))
  k=[0]*n
  for i in range(1,n+1):
    k[i-1]=str(l.index(i)+1)
    print(" ".join(k))

main()

### FIXED CODE ###

def main():
  n=int(input())
  l=list(map(int,input().split()))
  k=[0]*n
  for i in range(1,n+1):
    k[l[i-1]-1]=str(i)
  print(" ".join(k))


if __name__ == '__main__':
    main()
def main():
    _, _ = map(int, input().split())
    L = list(map(int, input().split()))
    R = list(map(int, input().split()))
    lcnt = [0] * 31
    rcnt = [0] * 31
    for l in L:
        lcnt[l-10] += 1
    for r in R:
        rcnt[r-10] += 1
    ans = sum(map(min, zip(lcnt, rcnt)))
    print(ans)


if __name__ == "__main__":
    main()


### FIXED CODE ###

import numpy as np

def main():
    A, B, C, K = map(int, input().split())
    if K == 0:
        print(A-B)
        return
    base = np.matrix([[0, 1, 1], [1, 0, 1], [1 ,1 ,0]])
    X = base ** K
    result = np.matrix([[A, B, C]]) \
        .dot(X) \
        .dot(np.matrix([[1], [-1], [0]]))
    ans = result[0, 0]
    if ans > 10**18:
        print("Unfair")
    else:
        print(ans)

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

for i in sys.stdin:
  inl=i.split()
  a=inl[0]+inl[1]
  time=0
  for n in a
    time+=1
  print tie

### FIXED CODE ###

import sys

a = []
for line in sys.stdin:
    a.append(line)

for n in a:
    inl=n.split()
    num=int(inl[0])+int(inl[1])
    l=list(str(num))
    time=0
    for i in l:
        time+=1
    print time