peterverebics/CodeNet_Python_118 huggingface dataset:
def henkan(num):
    if num <= 26:
        return chr(64 + num)
    elif num % 26 == 0:
        return henkan(num // 26 - 1) + chr(90)
    else:
        return henkan(num // 26) + chr(64 + num % 26)


n = int(input())
print(str(henkan(n)).lower())
n = int(input())
lis = []
while n != 0:
    if n%26 == 0:
        lis.append(int(0))
        n -= 26
        n /= 26
    else:
        lis.append(int(n%26))
        n -= n%26
        n /= 26
alp = ["z","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"]
st = ""
for i in range(len(lis),0,-1):
    st += alp[lis[i-1]]
print(st)
#!/usr/bin/env python3
from collections import deque, Counter
from heapq import heappop, heappush
from bisect import bisect_right

def main():
    N = int(input())
    a = 'zabcdefghijklmnopqrstuvwxy'
    ans = ''
    i = 0
    while N > 0:
        ans += a[N%26]
        N =  (N-1)//26
        # print(N)
    print(ans[::-1])

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

q = int(sys.stdin.readline())
chars = []
while True:
    q, mod = divmod(q-1, 26)
    chars.append(chr(mod+97))
    if q < 1:
        break
chars.reverse()
print("".join(chars))
N = int(input())
alphas = [ chr(i) for i in range(ord("a"), ord("z")+1)]

res = ""
while N != 0:
  ch = N % 26
  if ch==0:
    res += alphas[-1]
    N = N//26
    N -= 1
  else:
    res += alphas[ch-1]
    N = N//26

print(res[::-1])
n = int(input())
alp = "abcdefghijklmnopqrstuvwxyz"
name = ""
while n > 0:
    name += alp[n%26-1]
    n = (n-1)//26
print(name[::-1])
N = int(input())


BASE_CHR = 96
# chr(97) # a

result = ""

while True:
    temp = N % 26
    flag = False
    if temp == 0:
        result += "z"
        flag = True
    else:
        result += chr(BASE_CHR+temp)

    N = N // 26

    if flag:
        N -= 1

    if N == 0 :
        break

print(result[::-1])
n = int(input())
ans = ""
while n > 0 :
    n -= 1
    ans += chr(ord("a") + n%26)
    n = n//26
print(ans[::-1])
N = int(input())
lst = []
for i in range(1,12):
    if N <= 26 :
        lst.append(N % 26)
        break
    lst.append(N % 26)
    if N % 26 == 0:
        N = N // 26 - 1
    else:
        N = N // 26

chr = 'abcdefghijklmnopqrstuvwxyz'
res = ""
for j in lst:
    res = chr[j-1] + res
print(res)
s = 'abcdefghijklmnopqrstuvwxyz'
n = int(input()) - 1
ans = ''
while n > 25:
    ans += s[(n % 26)]
    n = n // 26 - 1
ans += s[n%26]
print(ans[::-1])
def II(): return int(input())
ans=''
N=II()
N-=1
i=1
while N-26**i>=0:  
  N-=26**i
  i+=1#26のべき乗倍を引いてからインクリメント
for j in range(i):
  div,mod=divmod(N,26)
  ans+=chr(mod+ord('a'))
  N=div
ans=ans[::-1]
print(ans)
n = int(input())

i = 1
ans = ""
while n != 0:
    p = n%26 if n%26 != 0 else 26
    ans  = chr(p + 96) + ans

    n = n-p
    n = n//26
    i += 1

print(ans)
N = int(input())
ans = ''

BASE=26
for i in range(12,-1,-1):
    tmp = pow(BASE,i)
    if tmp > N:
        continue
    
    N-=1
    ans += chr(ord('a') + N % 26)
    N //= 26
print(ans[::-1])
n=int(input())
def alpha2num(alpha):
    if alpha<=26:
        return chr(64+alpha)
    elif alpha%26==0:
        return alpha2num(alpha//26-1)+chr(90)
    else:
        return alpha2num(alpha//26)+chr(64+alpha%26)
print(alpha2num(n).lower())
def solve():
    def num2alpha(num):
        if num <= 26:
            return chr(64 + num)
        elif num % 26 == 0:
            return num2alpha(num // 26 - 1) + chr(90)
        else:
            return num2alpha(num // 26) + chr(64 + num % 26)
    print(num2alpha(N).lower())

if __name__ == "__main__":
    N = int(input())
    solve()
def resolve():
    n = int(input())

    ans = ''
    while n > 0:
        t = n % 26
        t = 26 if t == 0 else t
        ans = chr(t + 96) + ans
        n = (n - 1) // 26
    print(ans)


if 'unittest' not in globals():
    resolve()
n = int(input())
amari = 0
name = []
a = "abcdefghijklmnopqrstuvwxyz"

while n >= 1 :
    amari = n % 26    
    if amari == 0:
        amari = 26
    name.insert(0, a[int(amari-1)])
    n = (n - amari) / 26

ans = ''.join(name)
print(ans)
N = int(input())
ans = ''
while N > 0:
    N -= 1
    ans += chr(ord('a') + N % 26)
    N //= 26
ans = ans[::-1]
print(ans)
def resolve():
    n = int(input())
    name = []
    while n > 0:
        c = n % 26
        n //= 26
        if c == 0:
            name.append('z')
            n -= 1
        else:
            name.append(chr(c + 96))

    name.reverse()
    ans = ''.join(name)
    print(ans)

resolve()
N=int(input())
START = 96
ALP = 26
ans = []
while True:
  if N <= ALP:
    ans.append(chr(START + N)) 
    break
  p = N % ALP
  if p == 0:
    ans.append(chr(START + ALP))
  else:
    ans.append(chr(START + p))
  if p == 0:
    N -= 1
  N = N // ALP
print(''.join(ans[::-1]))
num = int(input())

def conv(num):
    if num <= 26:
        return chr(96 + num)
    elif num % 26 == 0:
        return conv(num//26-1) + chr(96 + 26)
    else:
        return conv(num//26) + chr(96 + num%26)

print(conv(num))
def num2alpha(num):
    if num<=26:
        return chr(64+num)
    elif num%26==0:
        return num2alpha(num//26-1)+chr(90)
    else:
        return num2alpha(num//26)+chr(64+num%26)
N =int(input())
NN=num2alpha(N)
print(NN.lower())
def num2alpha(num):
    if num<=26:
        return chr(64+num)
    elif num%26==0:
        return num2alpha(num//26-1)+chr(90)
    else:
        return num2alpha(num//26)+chr(64+num%26)
      
n = int(input())
print(num2alpha(n).lower())
import sys

n = int(sys.stdin.read())
n -= 1
s = 'abcdefghijklmnopqrstuvwxyz'
write = sys.stdout.write
a = []
append = a.append
while n >= 26:
  n, v = divmod(n, 26)
  n -= 1
  append(s[v])
append(s[n])
a.reverse()
print(''.join(a))
n=int(input())
s=''
while True:
  n-=1
  s+=chr(n%26+65)
  if n<=25:
    break
  n//=26
  n+1
s=''.join(reversed(s))
s=s.lower()
print(s)
n = int(input())

ans = []
while n > 0:
    n -= 1 # これが必要
    ans.append(chr(ord('a') + n % 26))
    n //= 26

print(''.join(ans[::-1]))
n = int(input())
r = []
while (True):
    n = n - 1
    r.append(chr(n % 26 + ord("a")))
    n = n // 26
    if n == 0:
        break
print("".join(reversed(r)))
def sep():
    return map(int,input().strip().split(" "))
def lis():
    return list(sep())

n=int(input())
k=n
s=""
while(k>0):
    t=k%26
    if t==0:
        t=26
        k-=26
    s+=chr(t+96)
    k//=26
print(s[::-1])
N = int(input())
result = ""
while N >= 1:
  result = chr(((int(N) -1) % 26) + ord('a')) + result
  N = (N-1) / 26
print(result)
n = int(input())
m = n
keta = 0
for i in range(1, 12):
    m -= 26 ** i
    if m <= 0:
        keta = i
        break

alpha = "abcdefghijklmnopqrstuvwxyz"

ans = str()
for j in range(keta):
    n -= 1
    ans += alpha[n % 26]
    n //= 26

print(ans[::-1])
N = int(input())

div = 26
ans = []

while 1:
    if N % 26 == 0:
        ans.append(26)
        N = N // div - 1
    else:
        amari = N % div
        ans.append(amari)
        N //= div
    if N == 0:
        break

ans.reverse()
name = []

for i in ans:
    name.append(chr(i+96))

print(''.join(name))
N = int(input())

def num2alpha(num):
    if num<=26:
        return chr(96+num)
    elif num%26==0:
        return num2alpha(num//26-1)+chr(122)
    else:
        return num2alpha(num//26)+chr(96+num%26)

print(num2alpha(N))
n=int(input())
#x,n=map(int,input().split())
#pl=list(map(int,input().split()))
#l=[list(map(int,input().split())) for i in range(n)]

res=''
#res+=chr(ord("a")+n%26-1)
#n//=26
while n>0:
    n-=1
    res+=chr(ord("a")+n%26)
    n//=26
print(res[::-1])
N = int(input())
n = N

L = str()

alpha = [chr(i) for i in range(97,97+26)]

i = 0
while n > 0:
    i += 1
    n -= 26 ** i


N -= 26 * (26 ** (i - 1) - 1) // 25

while i > 0:
    code = (N - 1) // (26 ** (i - 1))
    L += alpha[code]
    N -= code * (26 ** (i -1))
    i -= 1

print(L)
n = int(input())
l = 1
while n-26**l > 0:
    n -= 26**l
    l += 1
else:
    n -= 1
    res = ""
    for i in range(l):
        n,r = divmod(n,26)
        res += chr(ord("a")+r)
    ans = res[::-1]
print(ans)
import math

def main():
    N = int(input())
    lowercase = 'abcdefghijklmnopqrstuvwxyz'
    ans = ''
    for i in range(len(str(N))):
        j = N % 26
        if N == 0:
            break
        if j == 0:
            N = N // 26 - 1
        else:
            N = N // 26
        ans = lowercase[j-1] + ans
        # print(N, j-1, ans)
    print(ans)

if __name__ == '__main__':
    main()
n=int(input())
ans = ''
while n>0:
        n = n-1
        ans += chr(ord('a') + (n)% 26)
        n//=26
ans = ans[::-1]
print(ans)
N = int(input())
s = list("abcdefghijklmnopqrstuvwxyz")
ans=[]

while 1<=N:
    N -= 1    ####
    ans.insert(0, s[N%26])
    N //= 26

ans="".join(ans)
print(ans)
N=int(input())
l = int(N**(1/26))
name = ''
while N >0:
    N -= 1
    r = N%26
    N = N//26
    name += chr(ord('a')+r)
print(name[::-1])
n=int(input())
keta=[26]
t=2
while keta[-1]<10**15+1:
    keta.append(keta[-1]+26**t)
    t+=1
#print(keta)

import bisect,sys
nagasa=bisect.bisect_left(keta,n)+1
#print(nagasa)

alpha='abcdefghijklmnopqrstuvwxyza'
if nagasa==1:
    print(alpha[n-1])
    sys.exit()

n-=keta[nagasa-2]
n-=1

ans=''
L=[]
while n>0:
    L.append(n%26)
    n//=26
while len(L)<nagasa:
    L.append(0)
for i in L:
    ans+=alpha[i]
print(ans[::-1])
from collections import deque
def add(x):
    return x+97

N = int(input())
i = 1
while N > 26**i:
    N = N - 26**i
    i += 1
    
N -= 1
shinsu = deque([])
for j in range(i):
    shinsu.appendleft(N%26)
    N //= 26

shinsu = list(map(add, shinsu))
ans = list(map(chr, shinsu))
print(''.join(ans))
N = int(input())
alph = {key + 1: val for key, val in enumerate('abcdefghijklmnopqrstuvwxyz')}
alph[0] = 'z'
answer = ''
while N >= 1:
  answer = alph[N % 26] + answer
  if N == 26:
    break
  N = (N - 1) // 26

print(answer)
n = int(input())
kouho = []
alphabet = []
for i in range(26):
    alphabet.append(chr(ord("a") + i))
ans = []
while n > 0:
    p = (n) % 26
    q = n // 26
    if p == 0:
        p += 26
        q -= 1
    ans.append(alphabet[p - 1])
    n = q

print(*ans[::-1], sep="")
n=int(input())
a=[]
while n:
    a+=n%26,
    n//=26
a=a[::-1]
for i in range(len(a)-1,0,-1):
    if a[i]<1:
        a[i]+=26
        a[i-1]-=1
print(''.join(chr(c+96)for c in a[not a[0]:]))
n=int(input())
def num2alpha(num):
    if num<=26:
        return chr(64+num)
    elif num%26==0:
        return num2alpha(num//26-1)+chr(90)
    else:
        return num2alpha(num//26)+chr(64+num%26)
print(num2alpha(n).lower())
n=int(input())
p=1000000000000001
n2a = lambda c: chr(c+65).lower()
# 何桁か計算
cnt=0
keta=0
while cnt+pow(26,keta)<=n:
  cnt+=pow(26,keta)
  keta+=1
#print(cnt,keta)
n-=cnt
# cnt桁のn番目の数字
ans=['a']*keta
for i in range(keta):
  ans[-i-1]=n2a(n%26)
  n//=26
#ans.reverse()
print(''.join(ans))
n = int(input())
alph = "abcdefghijklmnopqrstuvwxyz"

ans = ""
while n >= 1:
    n -= 1
    div, mod = divmod(n, 26)
    ans += alph[mod]
    n = div
print(ans[::-1])
#c
M = int(input())
s=''
a=['z','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']
while M>0:
    s+=a[M%26]
    if M%26==0:
        M=int((M-1)/26)
    else:
        M=int(M/26)
print(s[::-1])
n = int(input())
s = ""

while n > 0:
    n -= 1
    s += chr( n % 26 + ord('a') )
    n //= 26
        
print(s[::-1])
N=int(input())
name=""
while N>0:
    N-=1
    name=chr(ord("a")+N%26)+name
    N//=26
print(name)
from collections import defaultdict
it = lambda: list(map(int, input().strip().split()))
INF = float('inf')


if __name__ == '__main__':
    N = int(input())
    ans = ''
    while N:
        if N % 26 == 0:
            ans = chr(ord('a') + 25) + ans
            N //= 26
            N -= 1
        else:
            ans = chr(ord('a') + N % 26 - 1) + ans
            N //= 26
    print(ans)
def num2alpha(num):
    if num<=26:
        return chr(64+num)
    elif num%26==0:
        return num2alpha(num//26-1)+chr(90)
    else:
        return num2alpha(num//26)+chr(64+num%26)
      
n=int(input())
print(num2alpha(n).lower())
n=int(input())
a=["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","z"]
x=n
b=1
z=a[x%26-1]
x=x-26
while x>0:
    i=(x-1)//(26**b)
    y=i%26
    z+=a[y]
    b+=1
    x=x-(26**b)
t=z[::-1]
print(t)
n = int(input())
a = []
while n > 0:
    n -= 1
    a.append(n%26)
    n = n // 26
ans = ""
for i in range(len(a)):
    ans += chr(ord("a")+a[(-1)*(i+1)])
print(ans)
import math
n = int(input())
name = ""

while n >= 1 / 26:
    div = n % 26
    if div == 0:
        div = 26
    name = chr(div + 64) + name
    n = math.floor((n - div) / 26)
print(name.lower())
import string

def main():
  N = int(input())
  az = string.ascii_lowercase
  d = 26
  ans = ""

  while(N > 0):
    m = (N-1) % d
    ans = az[m] + ans
    N = (N-1) // d
    
  print(ans)


if __name__ == "__main__":
  main()
ini = lambda : int(input())
inm = lambda : map(int,input().split())
inl = lambda : list(map(int,input().split()))
gcd = lambda x,y : gcd(y,x%y) if x%y else y
n = ini()
b = ''
while n > 0:
        n -= 1
        b += chr(ord('a') + n%26)
        n = n//26
print(b[::-1])
import math
N_MAX = 1 ** 15
letters=list("abcdefghijklmnopqrstuvwxyz")
A_TO_Z = len(letters)
N = int(input())

temp = N
cnt = 1
while temp - A_TO_Z ** cnt > 0:
  temp -= A_TO_Z ** cnt
  cnt += 1
r = [0] * cnt
  
q = temp - 1
while q > 0:
  r[cnt-1] = q % A_TO_Z
  cnt -= 1
  q = q // A_TO_Z
for i in r:
  print(letters[i],end="")
import sys
INF = 1 << 60
MOD = 10**9 + 7 # 998244353
sys.setrecursionlimit(2147483647)
input = lambda:sys.stdin.readline().rstrip()
def resolve():
    n = int(input()) - 1
    res = []
    while 1:
        res.append(chr(ord('a') + n % 26))
        n = n // 26 - 1
        if n == -1:
            break

    res.reverse()
    print(''.join(res))
resolve()
def main():
	N = int(input())
	a = ord('a')
	ans = ''
	while N!=0:
		N -= 1
		ans = chr(a + N % 26) + ans
		N //= 26
	print(ans)

main()
n=int(input())
def num2alpha(num):
  if num<=26:
    return chr(64+num)
  elif num%26==0:
    return num2alpha(num//26-1)+chr(90)
  else:
    return num2alpha(num//26)+chr(64+num%26)
print(num2alpha(n).lower())
N = int(input())
ans = ''
while N != 0:
    N -= 1
    ans += chr(ord('a') + N%26)
    N //= 26
print(ans[::-1])
import sys
import math

input = sys.stdin.readline
sys.setrecursionlimit(10 ** 5)


def main():
    N = int(input())
    name = ""
    while N:
        N, mod = divmod(N, 26)
        if mod ==0:
            name +="z"
            N-=1
        else:
            name += chr(96+mod)

    print(name[::-1])

if __name__ == "__main__":
    main()
import sys
import os
import itertools
import numpy as np
from collections import deque

def main():
    if os.getenv("ENV")=='LOCAL':
        sys.stdin = open(os.path.dirname(__file__)+'/input.txt', 'r')

    N=int(input())

    name=[]

    while N > 0:
        N-=1
        name.append(N%26)
        N//=26

    # print(len(alphabet))
    # print(name)
    ans=""
    for n in name:
        ans+=chr(ord('a')+n)


    print(ans[::-1])

if __name__ == '__main__':
    main()
n = int(input())-1
y = 26
idx = []

c = [chr(i + ord("a")) for i in range(26)]

while True:
    idx.append(n % y)
    n //= y
    if n <= 0:
        break
    n -= 1

idx.reverse()
ans = []
for i in idx:
    ans.append(c[i])
print("".join(ans))
N = int(input())
ans = ""
for i in range(1, 99):
    if N <= 26 ** i:
        N -= 1
        for j in range(i):
            ans += chr(ord("a") + N % 26)
            N = N // 26
        break
    else:
        N -= 26 ** i
print(ans[::-1])
num=int(input())

def num2alpha(num):
    if num<=26:
        return chr(64+num)
    elif num%26==0:
        return num2alpha(num//26-1)+chr(90)
    else:
        return num2alpha(num//26)+chr(64+num%26)
print(num2alpha(num).lower())
n=int(input())
L=[chr(i) for i in range(97, 97+26)]


temp=26
count=1
while True:
    if n<=temp:
        break
    else:
        count+=1
        temp+=26**count

unthink=temp-26**count
think=n-unthink

ans=''
think-=1
for i in range(count)[::-1]:
    now=think//(26**i)
    ans+=L[now]
    think=think%(26**i)

print(ans)
#<C>(17+)
n = int(input())
t = []
while n > 0:
    n -= 1
    t.append(chr(n % 26 + ord("a")))
    n //= 26
print("".join(t[::-1]))
N = int(input())
def num2alpha(num):
    if num<=26:
        return chr(64+num)
    elif num%26==0:
        return num2alpha(num//26-1)+chr(90)
    else:
        return num2alpha(num//26)+chr(64+num%26)

ans2 = num2alpha(N)
print(ans2.lower())
arphaList = 'abcdefghijklmnopqrstuvwxyz'
result = ""
N = int(input())

while N != 0:
  arpha = arphaList[(N + 25) % 26]
  result += arpha
  N = N // 26
  if arpha == "z":
    N -= 1
print(result[::-1])
def num2alpha(num):
    if num<=26:
        return chr(96+num)
    elif num%26==0:
        return num2alpha(num//26-1)+chr(122)
    else:
        return num2alpha(num//26)+chr(96+num%26)

n = int(input())
print(num2alpha(n))
from string import ascii_lowercase as alph
N = int(input())
A = list(alph)

ans = []

def sol(n):
    global ans

    q, r = divmod(n, 26)
    ans.append(A[r])
    if q > 0:
        sol(q - 1)

sol(N - 1)
print(''.join(ans[::-1]))
N = int(input())
arr = []
while 0 < N:
    N -= 1
    arr.append(N % 26)
    N //= 26
ans = ''
for a in reversed(arr):
    ans += chr(ord('a')+a)
print(ans)
n = int(input())
abc = ['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']
res = []
ans = ''
while n:
    res.append((n-1)%26)
    n = (n-1)//26

#print(res[::-1])


for i in range(len(res)):
    ans += abc[res[i]]

print(ans[::-1])
n = int(input())

cnt = 0
digits = 0
for i in range(1, 12):
    cnt += pow(26, i)
    if n <= cnt:
        digits = i
        break

k = n - cnt + pow(26, digits) - 1
#digits桁の中で何番目か

alf = 'abcdefghijklmnopqrstuvwxyz'
ans = ''

for i in range(digits):
    q = k // 26
    r = k%26
    ans = alf[r] + ans
    k = q
print(ans)
num = int(input())
def num2alpha(num):
  if num<=26:
    return chr(64+num)
  elif num%26==0:
      return num2alpha(num//26-1)+chr(90)
  else:
      return num2alpha(num//26)+chr(64+num%26)
print(num2alpha(num).lower())
borders = []
n = 0
for i in range(1, 12):
    n += 26 ** i
    borders.append(n)
borders.sort(reverse=True)
chars = [chr(97 + i) for i in range(26)]

N = n = int(open(0).read())
keta = {}
for i, b in enumerate(borders):
    j = 0
    k = 26 ** (11 - i)
    while n > b:
        n -= k
        j += 1
    if j > 0:
        keta[11 - i] = chars[j - 1]
if n > 0:
    keta[0] = chars[n - 1]
ret = [keta[i] if i in keta else '_' for i in range(12, -1, -1)]
print("".join(ret[12 - max(keta.keys()):]))
def toString(n):
    if n <= 26:
        return chr(64 + n)
    elif n % 26 == 0:
        return toString(n // 26-1) + chr(90)
    else:
        return toString(n // 26) + chr(64 + n % 26)

N = int(input())
Alpha = toString(N)
alpha = Alpha.lower()
print(alpha)
n = int(input())
a = ['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']
b = ''
def Base_10_to_n(X, n):
    X_dumy = X
    out = ''
    while X_dumy>0:
        out = a[X_dumy%n-1]+out
        if a[X_dumy%n-1] == 'z':
          X_dumy -= 26
        X_dumy = X_dumy//n
    return out
 
z = Base_10_to_n(n, 26)
print(z)
N=int(input())
alp=["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=""
while N>0:
  Q=N%26
  if Q==0:
    N=N//26-1
  else:
    N=N//26
  S+=alp[Q-1]
print(S[::-1])
def alpha(n):
    if n<=26:
        return chr(96+n)
    elif n%26==0:
        return alpha(n//26-1)+chr(122)
    else:
        return alpha(n//26)+chr(96+n%26)
n=int(input())
print(alpha(n))
n = int(input())
m = n
a = 1
count = 1
while a <= n:
    if a*26 >= m:
        break
    a*= 26
    m -= a
    count+=1
m -= 1
ans = []
for i in range(count):
    ans.append(m%26)
    m //= 26
ansa = ""
for i in ans:
    ansa += chr(97+i)
print(ansa[::-1])
import numpy as np
N=int(input())
N-=1
s ='abcdefghijklmnopqrstuvwxyz'
b = []
while True:
    a = N % 26
    b.append(s[a])
    N = N // 26
    if N == 0:
        break
    N -= 1
for i in range(len(b)):
    a = len(b)-i-1
    print(b[a], end='')
n = int(input())

c = ord("a")
l = ""
while not n < 26:
    b = n//26
    a = n-26*b
    n = b
    l = l+chr(c+a-1)
l = l+chr(c+n-1)
print(l[::-1])
alphabet = [chr(i) for i in range(97, 97+26)]
n = int(input())
keta = 0
while True:
    if n <= 26 ** keta:
        break
    keta += 1
ans = ''
for i in range(keta-1,-1,-1):
    num = 1
    while (num+1) * 26**(i) <= n:
        num+= 1
    # この時点でnumは、26**iをいくつまで含むことができるか？という数
    ans += alphabet[num-1]
    n -= num * 26**i

print(ans)
N = int(input())
ans = []

while N != 0:
    sup = N % 26
    ans.append(chr(96 + sup))
    N = N // 26

ans = ''.join(reversed(ans))
print(ans)
n = int(input())
a = 26
c = 1
res =""
t = ""

num2alpha = lambda c: chr(c+64)

while True:
    if n <= a:
        break
    a *= 26
    c += 1

for i in range(c):
    t = num2alpha(int(n % 26))
    if t == "@":
        t = "z"
    res = t + res
    n = n / 26

print(str.lower(res))
n = int(input())-1
a = "abcdefghijklmnopqrstuvwxyz"
s = a[n % 26]
n = n//26
while n:
    s = s + a[n % 26-1]
    n = n // 26
print(s[::-1])
def func(tmp):
  print(tmp)
  ans = ''
  sub_ans = tmp/26
  if sub_ans >0:
    ans += func(int(sub_ans))

  ans += chr(96 + int(tmp)%26)
    
  return ans

  
tmp = int(input())
print(func(tmp)[1:])
alp = [chr(i) for i in range(97, 97+26)]
N = int(input())
q = N
s = ""
while True:
  q,m = divmod(q,26)
  s = alp[m - 1] + s
  if q == 0:
    break
print(s)
from string import ascii_lowercase
N = int(input())
def base(n):
    l = []
    p = int(n / 26)
    q = n % 26 - 1
    if p != 0:
        l = [*l, *base(p)]
    return [*l, ascii_lowercase[q]]
print(''.join(base(N)))
n = 123456789

m = {}
for i in range(0,26):
  m[i] = chr(97+i)

ans = ''
while 1:

  n -= 1

  x = n // 26
  y = n % 26

  ans = m[y] + ans

  n = x
  if n == 0:
    break

print(ans)
N = int(input())


def base10to(n, b):
    if n // b:
        return base10to(n // b - 1, b) + ',' + str(n % b)
    return str(n % b)

res_26 = base10to(N - 1, 26)
print(res_26)

res = []
for s in res_26.split(','):
    res.append(chr(97 + int(s)))

print(''.join(res))
n=int(input())

cnt=1##文字数
tmp=26

while n>tmp:
    cnt+=1
    tmp+=26**cnt
 
num=n-(tmp//26)
 
alp=["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"]
 
if n<=26:
    ans=alp[n-1]
    print(ans)
else:
    ans=["0"]*cnt
    for i in range(cnt):
        j=num%26
        ans[-i-1]=alp[j]
        num//=26
    
    print(ans)
def main():
    n = int(input())
    alp = "zabcdefghijklmnopqrstuvwxy"
    res = ""
    for i in range(1,100):
        if(n<=26**i):
            for j in range(i):
                res+=chr(ord("a")+n%26)
                n//=26

            break
        else:
            n-=26**i
    print(res[::-1])

if __name__ == '__main__':
    main()
import sys
def input(): return sys.stdin.readline().strip()
def mapint(): return map(int, input().split())
sys.setrecursionlimit(10**9)

N = int(input())
ans = []
char = ['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']

while N:
    i = N%26
    ans.append(char[i-1])
    N //= 26
print(''.join(ans[::-1]))
N = int(input())

ascii_lowercase = 'abcdefghijklmnopqrstuvwxyz'
ans = []
c = 0
while N>0:
    n = N%26
    ans.append(n)
    N //= 26

ans.reverse()
o = []
for a in ans:
    s = ascii_lowercase[a-1]
    o.append(s)

print(''.join(o))
OFFSET = 96
def main():
    n = int(input())
    ans = []
    while n!=0:
        n,mod = divmod(n,26)
        ans.append(chr(mod+OFFSET))
    print(''.join(ans)[::-1])
    return

if __name__ == '__main__':
    main()
# coding: utf-8
import sys
from math import log

stdin = sys.stdin
ns = lambda: stdin.readline().rstrip() # ignore trailing spaces
ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))


def main():
    ascii_lowercase = 'abcdefghijklmnopqrstuvwxyz'
    n = ni()
    m = int(log(n,26))
    ans = ''
    for i in range(m+1):
        ans += ascii_lowercase[n%26-1]
        n //= 26
    print(ans[::-1])
    return


if __name__ == '__main__':
    main()