peterverebics/CodeNet_Python_118 huggingface dataset:
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())
nb=int(input())
s = []
while nb>0:
  nb-=1
  s.append(chr(ord("a")+nb%26))
  nb//=26
roger = "".join(s)
print(roger[::-1])
n = int(input())
ans = ''
while n != 0:
    s = n % 26
    if s == 0:
        ans += 'z'
        n = n //26 - 1
    else:
        ans += chr(s + 96)
        n //= 26
print(ans[::-1])
import bisect
N = int(input())
D = [0]*12
SD = [0]*12
tmp = 26
for i in range(1, 12):
    D[i] = tmp
    SD[i] = SD[i-1] + D[i]
    if SD[i] > 1000000000000001:
        break
    tmp *= 26


L = bisect.bisect_left(SD, N)
alpha = 'abcdefghijklmnopqrstuvwxyz'
ans = []
N -= SD[L-1] + 1
for i in range(L):
    ans.append(alpha[N % 26])
    N //= 26


print("".join(ans[::-1]))
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())
cha = "abcdefghijklmnopqrstuvwxyz"
ans = []
while n >= 1:
    mod = (n - 1) % 26
    ans.append(mod)
    n = (n - 1) // 26
    
ans_s = ''
for tmp in reversed(ans):
    ans_s += cha[tmp]
print(ans_s)
def main():
    #N,K=map(int,input().split())
    #p=list(map(int,input().split()))
    N=int(input())
    ans=""
    while N!=0:
        tmp=N%26
        N//=26
        if tmp==0:
            ans="z"+ans
            N-=1
        else:
            ans=chr(tmp-1+ord("a"))+ans
    print(ans)

main()
def solve(N):
    if N < 26:
        return chr(ord('a') + (N) % 26)
    else:
        return solve(N // 26 - 1) + chr(ord('a') + N % 26)

print(solve(int(input()) - 1))
n=int(input())
ans=""
while n>0:
    
    c=chr((n-1)%26 + 97)
    ans = c+ans
    n = (n-1)//26
    
print(ans)
# import sys
# readline = sys.stdin.readline
# generator = (readline().strip() for _ in range(N))

# N, M = map(int, input().split())
# As = list(map(int, input().split()))
# queries = (input() for _ in range(N))


def solve():
    N = int(input())
    v = N

    ans = ''

    while v > 0:
        d, m = divmod(v, 26)
        if m == 0:
            d -= 1
            m = 26
        ans = chr(m + 96) + ans
        v = d

    return ans


def main():
    print(solve())


if __name__ == "__main__":
    main()
N=int(input())
alpha='abcdefghijklmnopqrstuvwxyz'
 
ans=''
while 26<N:
    s=(N-1)%26
    ans=alpha[s]+ans
    N=int(N-1)//26
ans=alpha[N-1]+ans
print(ans)
from bisect import bisect_left
n = int(input())
lis = [0]*13
for i in range(1,13):
   lis[i] = 26**i + lis[i-1]
#print(lis)
num = bisect_left(lis,n)
n -= lis[num-1]
n -= 1
ans = ''
for i in range(num):
   i = num-i-1
   ans += chr(n//(26**i) +97)
   n %= 26**i
print(ans)
N, ans = int(input()), []
while N > 0:
    N = N - 1
    ans.append(chr(N % 26 + ord('a')))
    N = (N - N % 26) // 26
print(''.join(ans[::-1]))
N = int(input())

ans = ""

digit_count = 1
check = 26

while N > check:
    digit_count += 1
    check += 26 ** digit_count

offset = check - 26 ** digit_count

N -= offset + 1

while digit_count > 0:
    ans = "" + chr(ord("a") + N % 26) + ans
    N //= 26
    digit_count -= 1

print(ans)
n = int(input())
a = 26
keta = 1
nn = 0
while n > 0:
    if n > a:
        keta += 1
        n -= a
        a *= 26
    else:
        nn = n - 1
        n -= a
#nnを桁数をketaとして26進法で表す
l = []
for i in range(keta):
    amari = nn % 26
    nn = nn // 26
    l.append(amari)
revl = []
for i in range(len(l)-1,-1,-1):
    revl.append(l[i]+97)
ansl = []
for i in revl:
    ansl.append(chr(i))
print("".join(ansl))
n=int(input())

a="abcdefghijklmnopqrstuvwxyz"
aa=list(a)

stra=""
kk=n
for i in range(15):
    ki=(kk-1)%26+1
    if ki!=0:
        stra=aa[ki-1]+stra    
    else:
        stra=aa[25]+stra    
    kk=(kk-ki)//26
#    print(kk,ki,stra)
    if kk==0:
        break
    
print(stra)
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())
#N=1000000000000001
ans=''
alp=list('abcdefghijklmnopqrstuvwxyz')

while N != 0:
  N,mod=divmod(N-1,26)
  ans=alp[mod]+ans
print(ans)
#27 -> aa  26 + 1
n = int(input())


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


print(num2alpha(n))
N = int(input())
lis = [0,26]
num = 26
n = 1
while lis[-1]<N:
    num *= 26
    lis.append(lis[-1]+num)
    n += 1
c = N-lis[-2]-1
ans = ''
for i in range(n):
    ans = chr(c%26+ord('a')) + ans
    c //= 26
print(ans)
def main():
    n = int(input())

    chars = 'zabcdefghijklmnopqrstuvwxy'

    st = ''
    while True:
        a = n % 26
        st += chars[a]
        n = n // 26
        if n == 0 or (a == 0 and n == 1):
            break
        elif a == 0:
            n -= 1


    res = ''.join(list(reversed(st)))
    print(res)


main()
# abc171_c.py
import math
N = int(input())
ans=[]
while N > 0:
    ans.append(N%26)
    N = math.floor((N-1)/26)
alphabet = 'abcdefghijklmnopqrstuvwxyz'
ans = reversed(ans)
for i in ans:
    print(alphabet[i-1],end="")
# NK=list(map(int,input().split()))
N = int(input())
'''
An = list(map(int,input().split()))
Q = int(input())
Bn = [0] * Q
Cn = [0] * Q
for c in range(Q):
    Bn[c], Cn[c] = map(int, input().split())
'''

alphabet = ["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"]

columnName = ""
modulo =0

while N>0:
    modulo = (N-1)%26
    columnName = alphabet[modulo]+columnName
    N = int((N-modulo)/26)


print(columnName)
n = int(input())
def solve(n): 

    string = ""
    i = 0
    while n > 0: 
        rem = n % 26
        if rem == 0: 
            string += 'z'
            i += 1
            n = (n // 26) - 1
        else: 
            string += str(chr((rem - 1) + ord('a')))
            i += 1
            n = n // 26
    string = string[::-1] 
    print(string)

solve(n)
n = int(input())-1

ans = []
while n >= 0:
    n, y = divmod(n, 26)
    ans.append(y)
    n -= 1
ans.reverse()


def to_alpha(x):
    return chr(x+ord('a'))


print(''.join(map(to_alpha, ans)))
import string


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

    alphabets = string.ascii_lowercase
    base_number = 26

    ans = ''
    while N > 0:
        N -= 1
        ans += alphabets[N % base_number]
        N = N // base_number

    print(ans[::-1])


resolve()
N = int(input())
alp_list = ['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']
ans = []
 
for i in range(1,12):
  if N <= 26 ** i:
    N -= 1
    for j in range(i):
      ans += alp_list[N % 26]
      N  = N // 26
    break
  else:
    N -= 26 ** i
ans.reverse()
print("".join(ans))
n = int(input())
kouho = [chr(i) for i in range(97, 97+26)]
ans = []
while n>0:
    n-=1
    ans.append(kouho[n%26])
    n = n//26
ans.reverse()
print(''.join(ans))
N = int(input())
ans = ''
while N >0:
    N -=1
    ans += chr(ord('a') + N%26)
    N //=26

print(ans[::-1])
n = int(input())
num = 26
arr = []
ans = ""
moji = "abcdefghijklmnopqrstuvwxyz"
flg = False

ar = []
n = n - 1
for i in range(10000):
    arr.append(n % num)
    n = n // num - 1
    if n < 0:
        break

arr.reverse()

ans = ""

for i in arr:
    ans +=moji[i]
print(ans)
n=int(input())
def num2(num):
    if num<=26:
        return chr(num+96)
    elif num%26==0:
        return num2(num//26-1)+chr(122)
    else:
        return num2(num//26)+chr(96+num%26)
print(num2(n))
# coding:utf-8
n = int(input())
name = ''
count = 0

while n > 0:
    n -= 1
    mod = n % 26
    name += chr(97 + mod)
    n = n // 26


print(name[::-1])
import string

N = int(input()) - 1
ss = string.ascii_lowercase

ans = ""

while N >= 0:
  ans += ss[N % 26]
  N = N // 26 - 1
  if N < 0:
    break

print(ans[::-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)

print(num2alpha(n).lower())
N = int(input())
ans = ""
while(N > 0):
    N -= 1
    ch = N % 26
    ans = chr(97 + ch) + ans
    N //= 26
print(ans)
n = int(input())
alp = "abcdefghijklmnopqrstuvwxyz"
def solve(n):
    if n<26:
        return [alp[n]]

    ans=[alp[(n%26)]]

    ans.extend(solve((n//26)-1))
    return ans


ans=solve(n-1)
ans.reverse()
print(*ans,sep="")
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)
kou=N
a= num2alpha(kou)   

print(a.lower())
from collections import defaultdict as dd
from collections import deque
import bisect
import heapq

def ri():
    return int(input())

def rl():
    return list(map(int, input().split()))


def solve():
    n = ri()
    n -= 1
    out = ""
    while n >= 0:
        n, r = divmod(n, 26)
        n -= 1
        out = chr(ord('a') + r) + out
    print (out)






mode = 's'

if mode == 'T':
    t = ri()
    for i in range(t):
        solve()
else:
    solve()
N = int(input())
import math

num2alpha = lambda c: chr(c)
tmp_N = N
result = ''
while (tmp_N / 26) > 1.0:
    k = int(tmp_N / 26)
    res = tmp_N % 26
    if res == 0:
        res = 26
        k -= 1
    result += num2alpha(res+64).lower()
    tmp_N = k
res = tmp_N % 26
if res == 0:
    res = 26
    k -= 1
result += num2alpha(res+64).lower()
new_str = ''.join(list(reversed(result)))
print(new_str)
n=int(input())
alphabet = [chr(i) for i in range(97, 97+26)]

ans=[]
while n>0:
    n-=1
    ans.append(alphabet[n%26])
    n//=26
ans.reverse()
print(''.join(ans))
alp=[chr(i) for i in range(97,123)]
n=int(input())

for i in range(1,12):
    if n>26**i:
        n-=26**i
    else:
        keta=i
        break
#その桁数の名前のなかでn番目
n-=1
lst=[]
#このnを26進数で表し、0~25にa~zをあてはめる
for i in range(keta):
    p,n=divmod(n,26**(keta-i-1))
    lst.append(alp[p])
    
print("".join(lst))
n=int(input())

s = ''
for i in range(11):
  if n != 0:
    n -= 1
    s += chr(ord('a') + n % 26)
    n //= 26
print(s[::-1])
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())
ans = num2alpha(n).lower()
print(ans)
n = int(input())
x = 0
l = 0
while x < n:
    l += 1
    x += 26**l
for i in range(1,l):
    n -= 26**i
n -= 1
ans = ""
while len(ans) < l:
    ans += chr(ord("a")+n%26)
    n //= 26
print(ans[::-1])
n=int(input())-1
m=n;i=0;lst=[]
while m>=0:
    i+=1;k=m;m-=26**i
    k
while k>0:
    lst.append(k%26)
    k//=26
for j in range(i-len(lst)):
    lst.append(0)
print(''.join([chr(b+97) for b in lst][::-1]))
N = int(input())

ans = ' '
while N>0:
    N -= 1
    ans += chr(ord('a')+N%26)
    N = int(N/26)
    
print(ans[::-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)

print(num2alpha(N).lower())
n=int(input())

ans = ''
while n:
    tmp = (n-1)%26
    ans += chr(ord('a')+tmp)
    n-=1
    n//=26
print(ans[::-1])
entierAConvertir = int(input())
baseArrivee= 26 
sortie = []
while entierAConvertir>0:
  reste = entierAConvertir % baseArrivee
  if reste==0:
    reste = 26
  sortie.append(reste)
  entierAConvertir-=reste
  entierAConvertir = (entierAConvertir//baseArrivee)
for i in range(len(sortie)):
  print(chr(sortie[len(sortie)-1-i]+ord('a')-1),end="")
n = int(input())

alpha = 'abcdefghijklmnopqrstuvwxyz'

out = ''
while n != 0:
    out = alpha[(n % 26) - 1] + out
    n = int((n-1) // 26)
print(out)
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())
s = "abcdefghijklmnopqrstuvwxyz"
ans = ""
while True:
    a = n % 26
    if a == 0:
        n = n//26 - 1
    else:
        n //= 26
    ans = s[a-1] + ans
    if n == 0:
        break
print(ans)
import string
a2z = string.ascii_lowercase

def routine(X, n):
   div = X//n if X % n > 0 else X//n - 1
   if div:
      return routine(div, n)+a2z[X%n-1]
   return a2z[X%n-1]

print(routine(int(input()), 26))
n=int(input())-1
radix=26
ord_a=97

ans=""
while n>=0:
  n,m=divmod(n,radix)
  ans=chr(m+ord_a)+ans
  n-=1
print(ans)
n = int(input())
ans=""
while(n):
    n-=1
    ans += chr(ord('a')+(n%26))
    n = n//26

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

chars = "Xabcdefghijklmnopqrstuvwxyz"
result = ""
n_1 = N

while True:
    x = n_1 % 26

    if x == 0:
        x = 26

    result += chars[x]
    n_1 -= x
    if n_1 == 0:
        break

    n_1 //= 26

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

alphabet = [chr(i) for i in range(ord('a'), ord('z')+1)]

ans = ''
while n > 0:
    n -= 1
    ans += alphabet[n%26]
    n = n//26

print(ans[::-1])
n = int(input())
name = ''
while n>0:
    n -= 1
    name += chr(ord('a') + n%26)
    n//=26
print(name[::-1])
def main():
    n = int(input())
    n -= 1
    
    s = []
    for _ in range(15):
        # print(n)
        s.append(chr(ord('a')+(n%26)))
        n = int(n / 26)
        if n==0:
            break
        n -= 1
    s.reverse()
    print(''.join(s))

    pass

main()
import sys
import math
def II():
	return int(sys.stdin.readline())

def LI():
	return list(map(int, sys.stdin.readline().split()))

def MI():
	return map(int, sys.stdin.readline().split())

def SI():
	return sys.stdin.readline().strip()
n = II()
ans = ""
while(n>0):
	ans+=chr(96+n%26) if n%26>0 else 'z'
	if n%26 == 0:
		n//=26
		n-=1
	else:
		n//=26
print(ans[:][::-1])
n = int(input())
ans = ''
while n > 0:
    n -= 1
    ans += chr(ord('a') + n % 26)
    n //= 26
print(ans[::-1])
n = int(input())

a = "abcdefghijklmnopqrstuvwxyz"
s = ""

while n > 0:
    if n%26 == 0:
        s = a[n%26-1] + s
        n //= 26
        n -= 1
    else:
        s = a[n%26-1] + s
        n //= 26
    
print(s)
_dog_no = int(input())
_letter = [chr(i) for i in range(97,97+26)]
_dog_name = ""
for _i in range(11):
  _dog_no -= 1
  _dog_name = _letter[_dog_no % 26] + _dog_name
  _dog_no = _dog_no // 26
  if _dog_no < 1:
    break
print(_dog_name)
s = 'abcdefghijklmnopqrstuvwxyz'
n = int(input())

num = 0
cnt = 1
while((num+pow(26,cnt)) < n):
    num += pow(26,cnt)
    cnt += 1

n -= num
n -= 1

ans = ""
while(cnt > 0):
    a = n // pow(26,cnt-1)
    n -= (pow(26,cnt-1)*a)
    cnt -= 1
    ans = ans + s[a]
print(ans)
N = int(input())
N -= 1

alp = "abcdefghijklmnopqrstuvwxyz"



ans = ''
while N >= 0:
    j = N % 26
    if N == 0:
        ans += alp[j]
        break
    else:
        N = N // 26 - 1
        ans += alp[j]

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

keta = 1
for i in range(1, 18):
    t = 26*(26**i-1)//25
    if n <= t:
        break
    else:
        keta += 1

n -= 26*(26**(keta-1)-1)//25
n -= 1

ans = ""
for i in range(keta):
    t = 26**i
    ans = chr(ord('a')+(n//t)%26)+ans
print(ans)
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=""

for _ in range(10**5):
	N-=1
	ans+=chr(ord("a")+(N%26))
	N=N//26
	if N<=0:
		break

print(ans[::-1])
N = int(input())
for d in range(64):
  if N < (26**(d+1)-1)//(26-1):
    N = N-(26**d-1)//(26-1)
    break
#print(d, N)
L = []
for i in range(d):
  n = N%26
  c = "abcdefghijklmnopqrstuvwxyz"[n]
  L.append(c)
  N = N//26
r = "".join(reversed(L))
print(r)
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())
T='abcdefghijklmnopqrstuvwxyz'
s=''
while n>0:
    sn=n%26
    if sn>0:
        s=T[sn-1]+s
        n//=26
    else:
        s=T[25]+s

        n=n//26-1

print(s)
n = int(input())
s = "abcdefghijklmnopqrstuvwxyz"

l = [26]
for i in range(2, 14):
    a = 26 ** (i) + l[i-2]
    l.append(a)

idx = 0
while True:
    if n <= l[idx]:
        break
    idx += 1

if idx == 0:
    print(s[n-1])
    exit()

q = n - l[idx-1] - 1

ll = []
for j in range(idx+1):
    q, mod = divmod(q, 26)
    ll.append(mod)

ll.reverse()
ans = ""
for e in ll:
    ans += s[e]

print(ans)
n = int(input())
#a, b, h, m = map(int, input().split())
#al = list(map(int, input().split()))
#al=[list(input()) for i in range(h)]

l = 1
total = 26

while n > total:
    l += 1
    total += 26**l

last = total-26**l
v = n-last-1

ans = ''
# 26進数だと見立てて計算
for i in range(l):
    c = v % 26
    ans += chr(ord('a')+c)
    v = v//26
print("".join(ans[::-1]))
s = int(input())
ans = ""
while (s > 0):
    s -= 1
    ans += chr((s % 26) + ord("a"))
    s //= 26

print(ans[::-1])
n = int(input()) - 1
ans = ""
for _ in range(13):
    ans += chr(ord("a") + (n%26))
    n //= 26
    if n == 0:
        break
    n -= 1
print(ans[::-1])
n = int(input())
ans=''
while(n>0):
     n -= 1
     ans += chr(ord('a')+n%26)
     n //= 26
print(ans[::-1])
import math
from collections import defaultdict
ml=lambda:map(int,input().split())
ll=lambda:list(map(int,input().split()))
ii=lambda:int(input())
ip=lambda:list(input())
ips=lambda:input().split()

"""========main code==============="""

n=ii()
s="abcdefghijklmnopqrstuvwxyz"
ans=""
while(n>0):
    n-=1
    ans+=s[n%26]
    n//=26
print(ans[::-1])
import string
str_map = {num+1: item for num, item in enumerate(string.ascii_lowercase)}
def main():
	n = int(input())
	ans = []
	while n > 26:
		tmp = 26 if n%26 == 0 else n%26
		ans.append(str_map[tmp])
		n = (n-1) // 26
	ans.append(str_map[n])
	ans_str = ''.join(ans)
	print(ans_str[::-1])
	return

if __name__ == "__main__":
	main()
def get_char(x):
    return chr(ord('a') + x)


def submit():
    n = int(input())
    n -= 1

    ans = []
    while True:
        r, q = divmod(n, 26)
        c = get_char(q)
        ans.append(c)
        if r == 0:
            break
        n -= q
        n //= 26
        n -= 1
    
    print("".join(reversed(ans)))
    

submit()
n=int(input())
ans=''
check='abcdefghijklmnopqrstuvwxyz'
while n!=0:
  n-=1
  ans+=check[n%26]
  n//=26
print(ans[::-1])
def main():
    N = int(input())

    orda = ord('a')
    ans = ''
    
    while N:
        N -= 1
        N, Nmod = divmod(N, 26)
        ans = chr(orda + Nmod) + ans

    print(ans)


if __name__ == '__main__':
	main()

exit()
N = int(input())
k = 1
while 26**k <= N:
    N -= 26**k
    k += 1

def itoc(i):
    return chr(ord('a') + i)

N -= 1
ans = ''
for _ in range(k):
    N,i = divmod(N,26)
    ans += itoc(i)

if all(c=='z' for c in ans):
    print(ans[:-1])
else:
    print(ans[::-1])
import sys
sys.setrecursionlimit(10 ** 5 + 10)
def input(): return sys.stdin.readline().strip()

def resolve():
    
    n=int(input())
    ans=''
    
    while n>0:
        n-=1
        a,b=divmod(n,26)
        n//=26
        ans+=chr(ord('a')+b)
    for i in ans[::-1]:
        print(i,end='')
    print()
        

    
resolve()
N = int(input())
alp = "abcdefghijklmnopqrstuvwxyz"
output = ""
while N>0:
  N -= 1
  output += alp[N%26]
  N = N//26
  
print(output[::-1])
n = int(input())
alphabet = list("abcdefghijklmnopqrstuvwxyz")
if n <= 26:
    print(alphabet[n-1])
else:
    ans = ""
    while(True):
        q, mod = divmod(n, 26)
        if mod == 0:
            q -= 1
            ans = "z" + ans
        else:
            ans = alphabet[mod-1] + ans
        if q < 1:
            break
        n = q
    print(ans)
import sys
from string import ascii_lowercase

read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
MOD = 1000000007


def main():
    N = int(readline())
    
    ans = []
    while N:
        N, r = divmod(N, 26)
        if r == 0:
            r = 26
            N -= 1
        ans.append(ascii_lowercase[r-1])
    
    print(''.join(reversed(ans)))
    return


if __name__ == '__main__':
    main()
n=int(input())
a="zabcdefghijklmnopqrstuvwxy"
b=""
while n/26>0:
  b=a[n%26]+b
  n=(n-1)//26
print(b)
answer = ""
num = int(input())
j = 0
while(num > 0):
    j = num % 26
    num = num // 26
    if j == 0:
        answer += 'z'
        num -= 1
    else:
        answer += chr(96+j)

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

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


k=0
while N>=0:
    N -= 26**k
    k += 1

A = []
k -= 1
len_k = k
while k >= 0:
    A.append(N//(26**k))
    N %= (26**k)
    k -= 1

res = []
for i in A[-len_k:]:
    res.append(alpha[i])

print("".join(res))
n=int(input())
alphabet="abcdefghijklmnopqrstuvwxyz"
ans=[]
while n>0:
    n-=1
    ans.append(alphabet[n%26])
    n=n//26
ans.reverse()
print("".join(ans))
#!/usr/bin/env python3
ALPHABET = "abcdefghijklmnopqrstuvwxyz"
n = int(input()) - 1
ans = ""
while True:
    ans += ALPHABET[n % 26]
    n //= 26
    n -= 1
    if n < 0:
        break
print(ans[::-1])
n=int(input())
alpha=[chr(i) for i in range(97,97+26)]
def test(x,t):
  if x//t>0:
    return test(x//t-1,t)+alpha[x%t]
  return alpha[x%t]
print(test(n-1,26))
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 //= 26
    break
  else:
    N -= 26 ** i

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

keta = 1
now_26 = 26
while N > now_26:
  keta += 1
  now_26 += 26 ** keta

num = N - int(now_26 - 26 ** keta) -1

answer = ""
for i in range(keta):
  answer += chr(97 + num % 26)
  num = num // 26

print(answer[::-1])
def main():
    N = int(input()) - 1
    digit = 1
    while N >= 26 ** digit:
        N -= 26 ** digit
        digit += 1
    buf = []
    a = ord("a")
    for i in range(digit):
        buf.append(chr(a + (N % 26)))
        N //= 26
    ans = "".join(buf[::-1])
    print(ans)


if __name__ == "__main__":
    main()
N = int(input())
if N<=26:
    print(chr(N+96))
else:
    s = ''
    tmp = N
    while True:
        ttmp = tmp%26
        if ttmp==0:
            ttmp = 26
        s = chr(ttmp+96)+s
        if tmp<=26:
            break
        tmp = (tmp-ttmp)//26
    print(s)
n= (int)(input())
ans = ""
count = 0

if n % 26 != 0:
    ans += chr(n % 26 + 96)
    n -= n % 26
else:
    ans += 'z'
    n -= 26

for i in range(1, 11):
    n = n // 26
    if n == 0:
        break
    if n % 26 != 0:
        ans = chr(n % 26 + 96) + ans
        n -= n % 26
    else:
        ans = 'z' + ans
        n -= 26
    
print(ans)
N = int(input())
alphabets = {i: chr(i + 96) for i in range(1, 26)}
alphabets[0] = 'z'

queue = []

while N > 0:
    queue.insert(0, alphabets[N % 26])
    N -= 1
    N //= 26

print(''.join(queue))
N = int(input())-1
az = "abcdefghijklmnopqrstuvwxyz"
ans = []
while N >= 0:
    ans.append(az[N % 26])
    N //= 26
    N -= 1
ans.reverse()
print("".join(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=num2alpha(int(input()))
n=str(n.lower())
print(n)
import sys
from collections import deque

sys.setrecursionlimit(10 ** 6)
INF = float("inf")
MOD = 10 ** 9 + 7


def input():
    return sys.stdin.readline().strip()


def main():
    N = int(input())
    alpahbet = [chr(ord("a") + i) for i in range(26)]

    ans = []
    while N:
        N -= 1
        ans.append(alpahbet[N % 26])
        N //= 26

    print(*ans[::-1], sep="")


if __name__ == "__main__":
    main()
import math
n = int(input())
ls = "abcdefghijklmnopqrstuvwxyz"
cnt = 0
base = 26
while n >= base ** cnt:
    n -= base ** cnt
    cnt += 1
ans = ""
#print(cnt, n)
for i in range(cnt-1, -1, -1):
    res = n // (base ** i)
    ans += ls[res]
    n -= base ** i * res
print(ans)