Harryxun/stf_run huggingface dataset:
n=int(input())
t,a=map(int,input().split())
h = list(map(int,input().split()))
minimu = 1234567890
for i in range(n):
  if( minimu > abs(h[i]*0.006-t):
     minimu=abs(h[i]*0.006-t)
     ans = i+1
print(ans)

### FIXED CODE ###

n=int(input())
t,a=map(int,input().split())
h = list(map(int,input().split()))
minimu = 1234567890

for i in range(n):
        if( minimu > abs(t-h[i]*0.006-a)):
                minimu=abs(t-h[i]*0.006-a)
                ans = i+1
print(ans)
n=input()
if n=="1":
  print("Hello World")
elif:
  print(int(input())+int(input()))

### FIXED CODE ###

n=input()
if n=="1":
    print("Hello World")
else:
    print(int(input())+int(input()))
S = input()
if S[0] != S[1] && S[1] != S[2] && S[2] != S[0]:
    print("Yes")
else:
    print("No")


### FIXED CODE ###

S = input()
if (S[0] == S[1]) or (S[1] == S[2]) or (S[2] == S[0]):
    print("No")
else:
    print("Yes")
from collections import Counter
N = int(input())
s = list(map(int,input().split()))
c = Counter(src)
ans = 0
for i,j in c.items():
    ans += j if j<i else j-i
print(ans)

### FIXED CODE ###

from collections import Counter
N = int(input())
s = list(map(int,input().split()))
c = Counter(s)
ans = 0
for i,j in c.items():
    ans += j if j<i else j-i
print(ans)
n = int(input())
s = input()
print(s if s >= 3200 else "red")

### FIXED CODE ###

n = int(input())
s = input()
print(s if n >= 3200 else "red")
N = len(S)
num_one = S.count('1')
num_zero = S.count('0')
print(N - abs(num_one - num_zero))

### FIXED CODE ###

S = list(map(str, input().strip()))
num_of_zero = S.count('0')
num_of_one = S.count('1')
if num_of_zero <=  num_of_one:
    delete_num = 2 * num_of_zero
else:
    delete_num = 2 * num_of_one
print(delete_num)
import sys
sys.setrecursionlimit(10*7)

def dfs(now):
    for to,dis in G[now]:#next_v[0]=次の頂点、[1]=次までの距離
        if color[to]==-1:
            color[to]= (color[now] + dis) % 2
            dfs(to)

N = int(input())
G = [[] for _ in range(N)]
color = [-1] * N
color[0] = 1 #偶数=０

for i in range(N-1):
    a,b,c = map(int,input().split())
    a -= 1
    b -= 1
    G[a].append([b,c%2])
    G[b].append([a,c%2])

#print(G)    
dfs(0)
print(*color,sep="\n")


### FIXED CODE ###

import sys
sys.setrecursionlimit(10**9)

def dfs(now):
    for to,dis in G[now]:
        if color[to] == -1:
            color[to] = (color[now] + dis) % 2
            dfs(to)

N = int(input())
G = [[] for _ in range(N)]
color = [-1] * N
color[0] = 0 #偶数=0

for i in range(N-1):
    a,b,c = map(int,input().split())
    a -= 1
    b -= 1
    G[a].append([b,c%2])
    G[b].append([a,c%2])

#print(G)    
dfs(0)
print(*color,sep="\n")
N = input()
flag = False
for i in range(N//4):
    for j in range(N//7):
        if 4 * i + 7 * j == N:
            flag = True
if flag:
    print("Yes")
else:
    print("No")

### FIXED CODE ###

N = int(input())
flag = False
for i in range(N//4+1):
    for j in range(N//7+1):
        if 4 * i + 7 * j == N:
            flag = True
if flag:
    print("Yes")
else:
    print("No")
A,B =map(int,input().split())
if A-B == 0:
    print(A+"=="+B)
elif A >= B:
    print(A+">"+B)
else:
    print(A+"<"+B)


### FIXED CODE ###

A,B =map(int,input().split())
if A-B == 0:
    print("a == b")
elif A >= B:
    print("a > b")
else:
    print("a < b")
import sys, re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, tan, asin, acos, atan, radians, degrees, log2, gcd
from itertools import accumulate, permutations, combinations, combinations_with_replacement, product, groupby
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from bisect import bisect, bisect_left, insort, insort_left
from heapq import heappush, heappop
from functools import reduce
def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
def ZIP(n): return zip(*(MAP() for _ in range(n)))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7 
#mod = 998244353
from decimal import *
#import numpy as np
#decimal.getcontext().prec = 10

		
#階乗#
lim = 2*10**5   #必要そうな階乗の限界を入力
fact = [1] * (lim+1)
for n in range(1, lim+1):
	fact[n] = n * fact[n-1] % mod

#階乗の逆元#
fact_inv = [1]*(lim+1)
fact_inv[lim] = pow(fact[lim], mod-2, mod)
for n in range(lim, 0, -1):
	fact_inv[n-1] = n*fact_inv[n]%mod

def C(n, r):
	if n < r:
		return 0
	else:
		return (fact[n]*fact_inv[r]%mod)*fact_inv[n-r]%mod


N = INT()
A = [0] + LIST()

A = list(accumulate(A))
dic = Counter(A)

ans = 0
for x in list(dic.values()):
	ans += C(x, 2)

print(ans)

### FIXED CODE ###

import sys, re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, tan, asin, acos, atan, radians, degrees, log2, gcd
from itertools import accumulate, permutations, combinations, combinations_with_replacement, product, groupby
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from bisect import bisect, bisect_left, insort, insort_left
from heapq import heappush, heappop
from functools import reduce
def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
def ZIP(n): return zip(*(MAP() for _ in range(n)))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7 
#mod = 998244353
from decimal import *
#import numpy as np
#decimal.getcontext().prec = 10

N = INT()
A = [0] + LIST()

A = list(accumulate(A))
dic = Counter(A)

ans = 0
for x in dic.values():
	ans += x*(x-1)//2

print(ans)
pi = 3.14159265359
r = int(input())

print(f"{r*r*pi:.6f} {2*r*pi:.6f}")


### FIXED CODE ###

import math
n = float(input())
area = "%.6f" % float(n **2 *  math.pi)
circ = "%.6f" % float(n * 2 * math.pi)
print(area, circ)
n,k=map(int,input().split())
l=list(map(int,input().split()))
#print(l)
s=collections.Counter(l)
s=s.most_common()
#print(s)
a=0
for i in range(k,len(s)):
    a+=s[i][1]
print(a)

### FIXED CODE ###

import collections
import sys
input=sys.stdin.readline

n,k=map(int,input().split())
l=list(map(int,input().split()))
#print(l)
s=collections.Counter(l)
s=s.most_common()
#print(s)
a=0
for i in range(k,len(s)):
    a+=s[i][1]
print(a)
N,W = list(map(int, input().split()))
w = []
v = []
for _ in range(N):
    a,b = list(map(int, input().split()))
    w.append(a)
    v.append(b)

dp = [[0]*(W+1) for _ in range(N+1)]

for i in range(N):
    for j in range(W+1):
        if j - w[i] < 0:
            dp[i+1][j] = dp[i][j]
        else:
            dp[i+1][j] = max(dp[i][j],dp[i][j-w[i]] + v[i])

print(max(max(dp)))

### FIXED CODE ###

N,W = list(map(int, input().split()))
w_0 = []
w_1 = []
w_2 = []
w_3 = []
v = []
w = 0
w_count = [0]*4
for _ in range(N):
    a,b = list(map(int, input().split()))
    if w == 0:
        w = a
        w_0.append(b)
    else:
        if a == w:
            w_0.append(b)
        elif a == w+1:
            w_1.append(b)
        elif a == w+2:
            w_2.append(b)
        elif a == w+3:
            w_3.append(b)
    w_count[a-w] += 1

w_0.sort(reverse=True)
w_1.sort(reverse=True)
w_2.sort(reverse=True)
w_3.sort(reverse=True)
ans = 0

for i in range(w_count[0]+1):
    for j in range(w_count[1]+1):
        for k in range(w_count[2]+1):
            for l in range(w_count[3]+1):
                if W >= w * i + (w+1) * j + (w+2) * k + (w+3) * l:
                  
                    S = sum(w_0[:i])+sum(w_1[:j])+sum(w_2[:k])+sum(w_3[:l])
                    ans = max(ans,S)

print(ans)




# dp = [[0]*(W+1) for _ in range(N+1)]

# for i in range(N):
#     for j in range(W+1):
#         if j - w[i] < 0:
#             dp[i+1][j] = dp[i][j]
#         else:
#             dp[i+1][j] = max(dp[i][j],dp[i][j-w[i]] + v[i])

# k = max(dp)
# print(max(k))
n = int(input())
a = -(-n//111)
if a = 10:
    print(1111)
else:
    print(a*111)

### FIXED CODE ###

n = int(input())
a = -(-n//111)
if a == 10:
    print(1111)
else:
    print(a*111)
from collections import Counter
N = int(input())
A = list(map(int, input().split()))

if N % 3 != 0:
    ans = "Yes" if sum(A) == 0 else "No"
else:
    B = Counter(A)
    keys = tuple(B.keys())
    vals = tuple(B.values())
    if len(B) == 3:  # 3種類ならa^b^cかつNa==Nb==NCでおけ
        a, b, c = keys
        Na, Nb, Nc = vals
        if Na == Nb and Nb == Nc:
            a, b, c = keys
            ans = "No" if a ^ b ^ c else "Yes"
        else:
            ans = "No"
    elif len(B) == 2:  # 2種類なら、a^a==0かつb==0かつNa==2Nbでおけ
        a, b = keys
        Na, Nb = vals
        if a == 0:
            ans = "Yes" if Na == 2*Nb else "No"
        elif b == 0:
            ans = "Yes" if 2*Na == Nb else "No"
        else:
            ans = "No"
    elif len(B) == 1:
        a = keys[0]
        ans == "Yes" if a == 0 else "No"


print(ans)


### FIXED CODE ###

from collections import Counter
N = int(input())
A = list(map(int, input().split()))


def xor_circle(N, A):
    if sum(A) == 0:
        return "Yes"
    if N % 3 != 0:
        return "No"

    B = Counter(A)
    if len(B) == 3:
        a, b, c = B.keys()
        Na, Nb, Nc = B.values()
        if a ^ b ^ c == 0 and Na == Nb == Nc:
            return "Yes"
        else:
            return "No"
    elif len(B) == 2:
        a, b = B.keys()
        Na, Nb = B.values()
        if a == 0 and 2*Na == Nb:
            return "Yes"
        elif b == 0 and Na == 2*Nb:
            return "Yes"
        else:
            return "No"
    else:
        return "No"


ans = xor_circle(N, A)
print(ans)
n = int(input())
print((n//1000+1)*1000-n))

### FIXED CODE ###

n = int(input())
if n%1000==0:
    print(0)
else:
    print((n//1000+1)*1000-n)
s=input()
flag = True
for i in range(len(s)):
  if (i % 2 == 0 and s[i] == 'L') or (i % 2 == 1 and s[i] == 'R')
    flag = False
if flag:
  print("Yes")
else:
  print("No")

### FIXED CODE ###

s = input()
flag = True
for i in range(len(s)):
    if (i % 2 == 0 and s[i] == 'L') or (i % 2 == 1 and s[i] == 'R'):
        flag = False
if flag:
    print("Yes")
else:
    print("No")
n,k=map(int,input().split())
m=[]
for _ in range(2*k):
  d=int(input())
  a=list(map(int,input().split()))
  for i in a:
    if i not in m:
      m.append(i)
mx=max(m)
c=0
for i in range(1,n+1):
  if(i not in m):
    c+=1
print(c)    

### FIXED CODE ###

n,k=map(int,input().split())
m=[]
for _ in range(k):
  d=int(input())
  a=list(map(int,input().split()))
  for i in a:
    if i not in m:
      m.append(i)
mx=max(m)
c=0
for i in range(1,n+1):
  if(i not in m):
    c+=1
print(c)
a = int(input())

if a%2 ==0 :
  print("0.5000000000") 
else  :
  temp = n//2 +1 
  temp = temp/n 
  print(temp)

### FIXED CODE ###

a = int(input())

if a%2 == 0 :
  print("0.5000000000") 
else  :
  temp = a//2 +1 
  temp = temp/a 
  print(temp)
a=int(input())
s=input()

if a=>3200:
    print(s)
else:
    print("red")

### FIXED CODE ###

a=int(input())
s=input()

if a >= 3200:
    print(s)
else:
    print("red")
x=map(int,input().split())

s1=x//100
s2=x//10%10
s3=x%10

print(s1+s2+s3)

### FIXED CODE ###

x=int(input())

s1=x//100
s2=x//10%10
s3=x%10

print(s1+s2+s3)
import math
r = int(input())

area = r * r * math.pi
length = r * 2 * math.pi

print("{0:.6f}".format(area),end=' ')
print("{0:.6f}".format(length))

### FIXED CODE ###

import math
r = float(input())

area = r * r * math.pi
length = r * 2 * math.pi

print("{0:.6f}".format(area),end=' ')
print("{0:.6f}".format(length))
import math
A, B = input().split()
A = int(A)
B = int(B.replace('.', ''))
 
print(A*B//100))

### FIXED CODE ###

A, B = [int(_) for _ in input().split()]
print(A*B)
n=int(input())
a=map(int,input().split())
asdf =  0
for i in range(n):
  asdf += 1/a[i]
print(1/asdf)

### FIXED CODE ###

n=int(input())
a=list(map(int,input().split()))
asdf =  0
for i in range(n):
  asdf += 1/a[i]
print(1/asdf)
n = int(input())

a = []
m = 0
for i in range(1, n):
    if m >= n: break
    a.append(i)
    m += i

if m == n:
    print(*a)
else:
    a.pop(m-n)
    print(*a)


### FIXED CODE ###

n = int(input())

a = []
m = 0
for i in range(n):
    if m >= n: break
    a.append(i+1)
    m += i+1
    
if m == n:
    print(*a)
else:
    a.remove(m-n)
    print(*a)
import sys
def input(): return sys.stdin.readline().rstrip()
from bisect import bisect_left,bisect_right
def main():
    x,n=map(int,input().split())
    PP=list(map(int,input().split()))
    P=[]
    for xx in range(101):
        if xx in PP:continue
        P.append(xx)
    P_left=P[bisect_left(P,x)-1]
    P_right=P[bisect_left(P,x)]
    if abs(P_left-x)<=abs(P_right-x):
        print(P_left)
    else:
        print(P_right)

if __name__=='__main__':
    main()

### FIXED CODE ###

import sys
def input(): return sys.stdin.readline().rstrip()
def main():
    x,n=map(int,input().split())
    P = list(map(int,input().split()))
    n_lis = [0]*102
    for p in P:
        n_lis[p] += 1
    dis = 0
    while 1:
        if n_lis[x-dis] == 0:
            print(x-dis)
            break
        elif n_lis[x+dis] == 0:
            print(x+dis)
            break
        dis += 1

if __name__=='__main__':
    main()
#a,b,c = map(int,input().split())
a = int(input())
b = input()
c = s[:a//2]
d = s[a//2:a]
print("No" if c == d else "Yes")



### FIXED CODE ###

#a,b,c = map(int,input().split())
a = int(input())
b = input()
c = b[:a//2]
d = b[a//2:a]
print("Yes" if c == d else "No")
from collections import defaultdict

N, M = map(int, input().split())
xy = [list(map(int, input().split())) for _ in range(M)]

g = defaultdict(list)
done = [0] * (N+50)
memo = [0] * (N+50)
for x, y in xy:
    g[x].append(y)

def dp(v):
    max_len = 0
    if done[v] == 1:
        return memo[v]
    else:
        for to in g[v]:
            max_len = max(max_len, dp(to)+1)
        done[v] = 1
        memo[v] = max_len
        return max_len

ans = 0
for v in range(1, N+1):
    ans = max(ans, dp(v))
print(ans)

### FIXED CODE ###

from collections import defaultdict, deque

def topological_sort(vertex:list, edge:list):
    graph = {i: [] for i in vertex}
    for i, j in edge:
        graph[i].append(j)
        
    inp_cnt = defaultdict(int)
    outs = defaultdict(list)
    for inp, out in edge:
        inp_cnt[out] += 1
        outs[inp].append(out)

    result = []
    queue = deque([i for i in vertex if inp_cnt[i]==0])
    while queue:
        v = queue.popleft()
        result.append(v)
        for v2 in outs[v]:
            inp_cnt[v2] -= 1
            if inp_cnt[v2] == 0:
                queue.append(v2)
    return result

N, M = map(int, input().split())
vertex = list(range(1, N+1))
edge = [list(map(int, input().split())) for _ in range(M)]
graph = {i: [] for i in vertex}
for i, j in edge:
    graph[i].append(j)

sorted_vertecies = topological_sort(vertex, edge)
dp = [0] * (N+1)
for i in sorted_vertecies:
    ends = graph[i]
    for j in ends:
        dp[j] = max(dp[j], dp[i] + 1)
print(max(dp))
#ABC132 D
import math
def cmb(n, r):
    s = math.factorial(n) // (math.factorial(n - r) * math.factorial(r))
    return s
N, K = map(int, input().split())
for i in range(K):
    print(cmb(N - K + 1, i + 1) % ((10 ** 9) + 7) * cmb(K - 1, i))

### FIXED CODE ###

#ABC132 D
import math
def cmb(n, r):
    return math.factorial(n) // (math.factorial(n - r) * math.factorial(r))
N, K = map(int, input().split())
for i in range(K):
    try:
        print((cmb(N - K + 1, i + 1) * cmb(K - 1, i)) % ((10 ** 9) + 7))
    except:
        print(0)
s = (1, 1, 1, 2, 1, 2, 1, 5, 2, 2, 1, 5, 1, 2, 1, 14, 1, 5, 1, 5, 2, 2, 1, 15, 2, 2, 5, 4, 1, 4, 1, 51)
s[input()-1]

### FIXED CODE ###

s=[1, 1, 1, 2, 1, 2, 1, 5, 2, 2, 1, 5, 1, 2, 1, 14, 1, 5, 1, 5, 2, 2, 1, 15, 2, 2, 5, 4, 1, 4, 1, 51]
print(s[int(input())-1])
N, K = map(int, input().split())
V = list(map(int, input().split()))

def calc(l, r, d):
    hold = []
    for i in range(l):
        hold.append(V[i])
    for i in range(N-1, N-1-r, -1):
        hold.append(V[i])
    hold.sort()
    return 0 if d >= len(hold) else sum(hold[d:]) 

ret = 0
for l in range(K+1):
    for r in range(K+1-l):
        d = max(K - l - r, 0)
        ret = max(ret, calc(l, r, d))
print(ret)

### FIXED CODE ###

N, K = map(int, input().split())
V = list(map(int, input().split()))
U = V[::-1]
ret = 0

m = min(N, K)
for l in range(m+1):
    for r in range(m+1-l):
        hold = V[:l] + U[:r]
        hold.sort()
        for d in range(K+1-l-r):
            ret = max(ret, sum(hold[d:]))

print(ret)
n = int(input())
h = list(map(int, input().split()))
a = []
ans = []
b = set(h)
if len(b) == 1:
  print(len(h))
else:


  for i in range(n-1):
    if h[i] < h[i+1]:
      a.append(i+1)

  

  ans.append(a[0]-1)
  for i in range(len(a)-1):
    ans.append((a[i+1] - a[i])-1)
  ans.append((len(h) - a[len(a)-1])-1)
  if ans == []:
    print(0)
  else:
    print(max(ans))

### FIXED CODE ###

n = int(input())
h = list(map(int, input().split()))
a = []
ans = []
b = set(h)
if n == 0:
  print(0)
elif len(b) == 1:
  print(len(h)-1)
else:


  for i in range(n-1):
    if h[i] < h[i+1]:
      a.append(i+1)

  
  if a == []:
    print(len(h)-1)
  else:
    ans.append(a[0])
    ans[0] -= 1
    for i in range(len(a)-1):
      ans.append((a[i+1] - a[i])-1)
    ans.append((len(h) - a[len(a)-1])-1)
    if ans == []:
      print(0)
    else:
      print(max(ans))
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**6)
n,m=map(int,input().split())

a=[int(input()) for i in range(m)]

def fib(n):
    if n==1:
        return 1
    if n==2:
        return 2
    return fib(n-1)+fib(n-2)

ans=0
check=0
for i in a:
    if i-check==1:
        ans=0
        break
    ans+= fib(i-check-1)
    check=i
if ans!=0:
    ans+=fib(n-check-1)
print(ans%(10**+7))

### FIXED CODE ###

n,m=map(int,input().split())
mod=10**9+7

    
dp=[0]*(n+1)
dp[0]=1

a=set(int(input()) for i in range(m))

for i in range(1,n+1):
    if i in a:
        continue
    x=dp[i-1]
    if i>1:
        x+=dp[i-2]
    dp[i]=x%mod
print(dp[-1])
n=int(input())
s=str(n)
if s[-1] == 2 or 4 or 5 or 7 or 9:
  print("hon")
else if s[-1] == 3:
  print("bon")
else:
  print("pon")

### FIXED CODE ###

S = str(input())[-1]
tmp = ['0', '1', '6', '8']
if S == '3':
    print('bon')
elif S in tmp:
    print('pon')
else:
    print('hon')
import math
R = int(input())
L = math.pi*2*R
print(L)

### FIXED CODE ###

N , M = map(int,input().split())
A = list(map(int,input().split()))
S = sum(A)
print(max(-1, N-S))
def dfs(v, p, dist):
    for u, w in tree[v]:
        if u == p:
            continue
        else:
            dist[u] = dist[v] + w
            dfs(u, v, dist)
 
 
n = int(input())
tree = [[] for _ in range(n)]
for _ in range(n - 1):
    u, v, w = map(int, input().split())
    tree[u - 1].append((v - 1, w))
    tree[v - 1].append((u - 1, w))
 
dist = [0 for _ in range(n)]
dfs(0, -1, dist)
 
for i in dist:
    if i % 2 == 0:
        print(0)
    else:
        print(1)

### FIXED CODE ###

import sys
sys.setrecursionlimit(10 ** 7)

def dfs(v, p, dist):
    for u, w in tree[v]:
        if u == p:
            continue
        else:
            dist[u] = dist[v] + w
            dfs(u, v, dist)
 
 
n = int(input())
tree = [[] for _ in range(n)]
for _ in range(n - 1):
    u, v, w = map(int, input().split())
    tree[u - 1].append((v - 1, w))
    tree[v - 1].append((u - 1, w))
 
dist = [0 for _ in range(n)]
dfs(0, -1, dist)
 
for i in dist:
    if i % 2 == 0:
        print(0)
    else:
        print(1)
n = int(input())
a = list(map(int, input().split()))

def multi_lst(lst):
    ans = lst[0]
    for i in range(1, len(lst)):
        ans *= lst[i]
    
    return ans
if a.index(0):
    print(0)
    exit()
else:
    ans = multi_lst(a)

if ans <= 10**18:
    print(ans)
else:
    print('-1')

### FIXED CODE ###

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

try:
    idx = a.index(0)
    print(0)

except ValueError:

    ans = a[0]
    for i in range(1, len(a)):
        ans *= a[i]
        if ans > 10**18:
            print('-1')
            exit()

    print(ans)
n = int(input())
x = list(map(int,input().split()))
lst = [0]*(x[-1]-x[0]+1)
for i in range(n):
    for j in range(x[0],x[-1]+1):
        lst[j-x[0]] += (x[i]-j)**2
print(min(lst))

### FIXED CODE ###

n = int(input())
x = list(map(int,input().split()))
lst = [0]*(max(x)-min(x)+1)
for j in range(min(x),max(x)+1):
    for i in range(n):
        lst[j-x[0]] += (x[i]-j)**2
print(min(lst))
a = x*x*x
 print "%d" & "a"

### FIXED CODE ###

x = input()
ans = x**3
print ans
17 19 22 26 55 2802

### FIXED CODE ###

A,B,C,D,E,F = (int(i) for i in input().split())

water_list = []
suger_list = []

for i in range(F):
  if 100*A*i <= F:
    for j in range(F):
      if 100*B*j <= F:
        if 100*A*i + 100*B*j <= F:
          water_list.append(100*A*i + 100*B*j)
        else:
          break
      else:
        break
  else:
    break

for i in range(F):
  if C*i <= F:
    for j in range(F):
      if D*j <= F:
        if C*i + D*i <= F:
          suger_list.append(C*i+D*j)
        else:
          break
      else:
        break
  else:
    break

ans = 0
ans_list = []

for water in water_list:
  for suger in suger_list:
    if water != 0 and suger != 0:
      if suger/(water + suger) >= ans and water+suger <= F and suger <= (water/100)*E:
        ans = suger/(water + suger)
        ans_list = [water,suger]

if ans != 0:
  print(str(ans_list[0]+ans_list[1]) + " " + str(ans_list[1]))
else:
  print(str(A*100) + " 0")
from collections import deque
import sys
sys.setrecursionlimit(2000000)
N, M = map(int, input().split())
graph = [[] for j in range(M)]
q = deque([])
depth_array = [-1 for i in range(N)]

for i in range(M):
    a, b = map(int, input().split())
    graph[a-1].append(b-1)
    graph[b-1].append(a-1)

def bfs(graph, q, depth_array):
    # 終了条件
    if len(q) == 0:
        return depth_array

    cur_room = q.popleft()

    # キューに追加
    for r in graph[cur_room]:
        if depth_array[r] == -1: #未訪問なら
            q.append(r)
            depth_array[r] = depth_array[cur_room] + 1

    return bfs(graph, q, depth_array)
    
# init
q.append(0)
depth_array[0] = 0
depth_array = bfs(graph, q, depth_array)

mark_array = [-1 for i in range(N)]
#print(depth_array)




### FIXED CODE ###

s = input()
t = s[-1]
if t == '2' or t == '4' or t == '5' or  t == '7' or t == '9':
    print("hon")
if t == '0' or t == '1' or t== '6' or t == '8':
    print("pon")
if t == '3':
    print("bon")
a, b = input().split()

A = int(a * int(b))
B = int(b + int(a))

if A > B:
  print(A)
else:
  print(B)

### FIXED CODE ###

a, b = map(str, input().split())

A = int(a * int(b))
B = int(b * int(a))

if A > B:
  print(A)
else:
  print(B)
N = int(input())
ans = ''
 
while N > 0:
	N -= 1
	ans += chr(ord('a') + N % 26).lower()
	N = N // 26
    print(ans[::-1])

### FIXED CODE ###

def main():
    N = int(input())
    ans = ''
 
    while N > 0:
        N -= 1
        ans += chr(ord('a') + N % 26).lower()
        N = N // 26
    print(ans[::-1])
 
 
if __name__ == "__main__":
    main()
from operator import itemgetter

N, M = map(int, input().split())
pairs = [tuple(map(int, input().split())) for _ in range(N)]
pairs.sort(key = itemgetter(1), reverse = True)

A_max = M
schedule = [0] * (M+1)
for A, B in pairs:
    for i in range(A, A_max+1):
        if schedule[i] == 0:
            schedule[i] = B
            break
    else:
        A_max = A
    


print(sum(schedule))            


### FIXED CODE ###

from operator import itemgetter
import heapq

N, M = map(int, input().split())
pairs = [tuple(map(int, input().split())) for _ in range(N)]
pairs.sort(key = itemgetter(0))

heap = []
reward = 0
index_of_pairs = 0   
for i in range(1, M+1):
    while index_of_pairs < N and pairs[index_of_pairs][0] <= i:
        heapq.heappush(heap, -pairs[index_of_pairs][1])
        index_of_pairs += 1
    if heap:
        reward -= heapq.heappop(heap)

print(reward)
a, b = map(int, raw_input().split())

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'