peterverebics/CodeNet_Python_118 huggingface dataset:
n = int(input())
  
moji = [chr(i) for i in range(97, 97+26)]

name = ''
while n >=1 and n <=1000000000000001:
  name += moji[(n%26)-1]
  n = n // 26


if ( n > 0 ):
  name += moji[(n%26)-1]


new_str = name[::-1]
print(new_str)
def main():
    N = int(input())
    digits = []

    while True:
        a, b = N // 26, N % 26
        digits.append(b)
        if a == 0:
            break
        N = a

    digits.reverse()
    chars = map(to_alphabet, digits)
    print(''.join(chars))


def to_alphabet(x: int):
    return chr(64 + x).lower()


if __name__ == "__main__":
    main()
def _main(n):
    codes = "abcdefghijklmnopqrstuvwxyz"
    b = len(codes)
    values = ""
    while True:
        values += codes[int(n % b) - 1]
        n, mod = divmod(n, b)
        if n == 0 or (n == 1 and mod == 0):
            print(values[::-1])
            break


def _entry():
    n = int(input())
    _main(n)


if __name__ == "__main__":
    _entry()
#!/usr/bin/env python3

char_list = [ chr(ord('a')+num) for num in range( 26 ) ]
N = int(input())

def Base_10_to_n(X, n):
    if (int(X/n)):
        return Base_10_to_n(int(X/n), n)+str(char_list[(X%n)-1])
    return str(char_list[(X%n)-1])
print(Base_10_to_n(N,26))
def base10to(n, b):
    if (int(n/b)):
        return base10to(int(n/b), b) + ' '+ str(n%b)
    return str(n%b)

n = int(input())
al = 'abcdefghijklmnopqrstuvwxyz'
ans = ''
count = 26

if n <= count:
    print(al[n-1])
    exit()
else:
    a = list(map(int, base10to(n,26).split()))
    ans = ''
    for i in a:
        ans += al[i-1]
    print(ans)
N = int(input())

F = False
g1 = 0
g2 = 0
for i in range(1, 15):
    g1 += 26**i - 26**(i-1)
    g2 += 26**i
    if i > 1 and g1 < N <= g2:
        F = True

ALPHABET = "abcdefghijklmnopqrstuvwxyzz"
S = ""
X = ""
while N > 0:
    Q, M = divmod(N, 26)
    S = ALPHABET[M - 1] + S
    N = Q

if F:
    S = S[1:]
print(S)
# coding: utf-8
N = int(input())
A = []
alp = [chr(i) for i in range(97, 97+26)]
for i in range(100,-1,-1):
    A.append(N//26**i)
    N %= 26**i

for i in range(101):
    if A[i] != 0:
        k = i
        #print(k)
        break
A = A[k:]
#print(A)
ans = ""
if A[-1]==0:
    ans = "z" * (len(A)-1)
else:
    for a in A:
        ans += alp[a-1]
print(ans)
from collections import defaultdict

n = int(input()) - 1

ans = defaultdict(str)
for i in range(26):
    ans[i] = chr(ord('a') + i)

res = []
while True:
    if n:
        res.append(n%26)
        n //= 26
    else:
        break

res.reverse()
for i, v in enumerate(res):
    if i < len(res)-1:
        print(ans[v-1], end='')
    else:
        print(ans[v])
def main():
    N = int(input())
    lowercase = 'abcdefghijklmnopqrstuvwxyz'
    ans = ''
    for i in range(len(str(N))):
        j = N // 26**i % 26 - 1
        if j < 0:
            break
        ans = lowercase[j] + ans
    print(ans)

if __name__ == '__main__':
    main()
n = int(input())
ans = []
while n > 0:
    ans.append(chr(96 + (n % 26)))
    n //= 26
print(*ans[::-1], sep = '')
a_list = [chr(ord('a') + i) for i in range(26)]
n = int(input())

l_list = []
ans = ''
while n > 0:
    
    if n % 26 == 0:
        l_list.append(25)
        n = n // 26 - 1
    else:
        l_list.append(n%26)
        n = n // 26
l_list = l_list[::-1]
for i in l_list:
    ans += a_list[i]
print(ans)
n = int(input())

num2alpha = lambda c : chr(c+96)

name = num2alpha(n%26)

while n > 26:
  n = n//26
  name = num2alpha(n%26) + name

print(name)
n = int(input())

final = ""
while n > 0:
    final += chr(((n - 1) % 26) + 97)

    n = int(n/26)

print(final)
n=int(input())
alph='abcdefghijklmnopqrstuvwxyz'
s=[]

while n>0:
    s.append(n%26)
    n=n//26
ans=''
cnt=0
for i in range(len(s)):
    if s[i]==0:
        cnt=1
        if s[i+1]!=1:
            ans+='z'
            cnt=0
            s[i+1]-=1
        continue
    ans+=alph[s[i]-1-cnt]
print(''.join(list(reversed(ans))))
#C
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']
Name=[]
for i in reversed(range(11)):
    if N/(26**i) >=1:
        alp_index=N//(26**i)-1 if N//(26**(i-1))!=26 else 25
        Name.append(alp[alp_index])
    N=N%(26**i)
print(''.join(Name))
N = int(input())
L = list('0abcdefghijklmnopqrstuvwxyz')
ans_l = []


while (True):
    syou = N // 26
    amari = N % 26
    if syou == 0:
        ans_l.append(L[amari])
        break

    ans_l.append(L[amari])
    N = syou
ans_l = ans_l[::-1]
print(*ans_l, sep="")
n = int(input())
ans = ""
for i in range(14):
    if n == 0:
        break
    else:
        ans += chr(ord("a") + (n-1) % 26)
        n = n//26

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

alpha = 'abcdefghijklmnopqrstuvwxyz'

out = ''
while n != 0:
    out = alpha[(n % 26) - 1] + out
    n = int(n // 26)
print(out)
n=int(input())
ans=''
while n>0:
    x=n%26
    ans+=chr(x+96)
    n=n//26
print(ans[::-1])
N = int(input())
out_ans = []
while N > 26:
    out_ans.append(int(N % 26))
    N = (N // 26)
out_ans.append(int(N))
out_dic = ['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(len(out_ans)-1, -1, -1):
    ans = ans + (out_dic[out_ans[i] - 1])
print(ans)
N = int(input(""))

Q = [N]
R = [ ]

i = 1
while (26**i <= N ):
    Q.append(Q[i-1] // 26)
    R.append(Q[i-1] % 26) 
    i += 1
# print(Q)
# print(R)
R.reverse()
L = [i for i in "abcdefghijklmnopqrstuvwxyz"]

for i in R:
    if (i != R[-1]):
        print(L[i-1],end='')
    else:
        print(L[i-1])
n = int( input() )
 
l = []
a = 97
alp = 26
k = 1
n2 = n
while n >= k + 1:
  l.append( ( n2 - 1 ) % alp  )
  n2 = ( n2 - ( n2 - 1 ) % alp ) // alp
  k *= alp
ret = ""
for c in reversed( l ):
  ret += chr( a + c )
print( ret )
N = int(input())

ans = ""
while N != 0:
    ans += chr(ord('a') + (N % 26 + 25) % 26)

    N //= 26

print(ans[::-1])
import string
alphabets = "abcdefghijklmnopqrstuvwxyz"
n = 26

ans = ''
tmp = int(input())
while tmp >= n:
    tmp -= 1
    idx = tmp % n
    ans = alphabets[idx] + ans
    tmp //= n
print(ans)
def findNum(n):
    num = []
    while n > 0:
        num.append(n % 26 - 1)
        n //= 26
    return num

n = int(input())
l = [chr(i) for i in range(97, 97+26)]
array = findNum(n)
ans = ""
for i in array:
    ans += l[i]
print(ans)
import sys
import math
import collections
import decimal
import itertools
from collections import deque
from functools import reduce
import heapq
n = int(input())
#n, k = map(int, sys.stdin.readline().split())
#s = input()
#p = list(map(int, sys.stdin.readline().split()))

x = [chr(ord('a') + i) for i in range(26)]
ans = []
while (n != 0):
    p = n // 26
    q = n % 26
    ans.append(x[q-1])
    n = p


for i in range(len(ans)):
    print(ans[-i-1], end="")
sys.exit()
def solve() :
    n = int(input()) - 1
    d = []
    x = 1 

    if n < 26 :
        print(chr((n)+97))
        return None

    while n >= 26 :
        d.append(n % 26)
        n = n // 26

    print(chr((n)+96), end="")

    d.reverse()

    for i in d :
        if i == 0 :
            print(chr((i)+97), end="")
        else :
            print(chr((i)+96), end="")

if __name__ == "__main__":
    solve()
n=int(input())
m=1
a=[]
while n>26:
  n,mod=divmod(n,26)
  a.append(mod)
  m+=1
a.append(n)
s="abcdefghijklmnopqrstuvwxyz"
ans=""
for i in range(m-1,-1,-1):
  ans+=s[a[i]-1]
print(ans)
N = int(input())
n = 1
cnt = 0
while n < N:
    cnt += 1
    n *= 26
# print(cnt)
ans = []
while True:
    if cnt == 0:
        # print(N%26-1)
        ans.append(chr(ord("a") + N%(26)-1))
        break
    elif N//(26**cnt):
        # print(N//(26**cnt)-1)
        ans.append(chr(ord("a") + N//(26**cnt)-1))
        N %= 26**cnt
    cnt -= 1
    # print("N", N)

print("".join(ans))
N = int(input())

a = list()
sho = N
alpha = [i for i in 'abcdefghijklmnopqrstuvwxyz']
while sho != 0:
    sho = N // 26
    amari = N % 26
    a.append(alpha[amari-1])
    N = N // 26

a.reverse()
print(''.join(a))
N = int(input())
ans = []
while N // 26 >= 1:
    ans.insert(0, N % 26)
    N = N // 26
ans.insert(0, N)
print(ans)
for i in range(len(ans) -1):
    print(chr(96 + ans[i]), end="")

print(chr(96 + ans[-1]))
n = int(input())
name = ""
r = 1
while(n > 0 and r > 0):
	r = n % 26 # あまり
	n = n // 26 # 商
	if r is 0:
		name = 'z' + name
	else:
		name = chr(r+96) + name
print(name)
N = int(input())

keta = 0
max = 0
while True:
    keta += 1
    max += 26 ** keta
    if max >= N:
        break

# print(keta)

result = []
while keta >= 1:
    if N // 26 ** (keta-1) > 26:
        v = 26
    else:
        v = N // (26 ** (keta-1))

    N = N - (26 ** (keta-1)) * v
    # print(v, N)
    result.append(v)

    keta -= 1

# print(result)

a_z_list = [chr(ord('a') + i) for i in range(26)]
for v in result:
    print(a_z_list[v-1], end='')

# print('')
N=int(input())
ans=''
alf='aabcdefghijklmnopqrstuvwxyz'

while 1:
  l = N%27
  N = N//27
  ans+=alf[l]
  if N==0:
    break
print(ans[::-1])
n=int(input())
import math
k=math.ceil(math.log(n,26))
s=""
al=["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']
for i in range(k):
  s=al[n%26]+s
  n=n//26
print(s)
n = int(input())

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']

ans = ''
while True:
    # print(n)
    # print(n % 26)
    ans += alphabet[n % 26 - 1]
    n -= n % 26
    n = n // 26
    if n == 0:
        break

print(ans[::-1])
a=int(input())
K = 0
b = 0
List = [27]*13
res = ""
for i in range(12):
  K = a % 26
  List[i] = int(K)
  b = a-K
  if b >26:
    a = b/26
  else:
    break
for i in range(13):
  if List[12-i] ==27:
    pass
  elif List[12-i] ==0:
    res += chr(26+96)
  else:
    res += chr(List[12-i]+96)
print(List,res)
alp = 'abcdefghijklmnopqrstuvwxyz'
n = int(input())
keta = 0
a = 0
answer = ''
while a < n:
    keta += 1
    a = 26**keta
for i in range(keta-1):
    sear = n // (26**(keta-i-1))
    n = n % (26**(keta-i-1))
    answer += alp[sear-1]
answer += alp[n-1]
print(answer)
# -*- coding: utf-8 -*-
N = int(input())
# 26 ** 9 < 1000000000000001 < 26 ** 10 なので最大でも(9+1)桁の文字
index = [None] * 10

m = N
for i in range(9, -1, -1):
  print("i: " + str(i))
  x = 26 ** i
  if m >= x:
    index[i] = m // x
    m -= index[i] * x

print(index)
str = ''
for i in index:
  if i:
    str += chr(ord('a') + i - 1)
print(str[::-1])
n = int(input())
ans = []
asc = 'zabcdefghijklmnopqrstuvwxy'


while n > 0:
    s = (n % 26)
    ans.append(s)
    n = int(n / 26)

ans2 = []
for i in ans:
    ans2.append(asc[i])

ans2[0], ans2[-1] = ans2[-1], ans2[0]
test = ''.join(ans2)
print(test)
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"]
N=int(input())
li=[]
while N>=0:
    na=N%26
    li.append(alp[na])
    if N<=26:
        break
    else:
        N=N//26
ans=""
for i in range(len(li)):
    ans+=li[i]
print(ans[::-1])
def solve():
    N = int(input())

    ans = []


    while True:
        a,b = divmod(N, 26)
        ans.append(b)
        N = a
        if a==0:
            break

    trueans = []
    for i in ans:
        trueans.append(chr(96+i))


    print("".join(reversed(trueans)))




if __name__ == "__main__":
    solve()
n = int(input())
ans = ''
while n!=0:
    r = n%26
    ans += chr(96+r)
    n=n//26
print(ans[::-1])
n = int(input())

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']
ln = []

while True:
    n -= 1
    b = n % 26
    ln.append(alphabet[b])

    if n <= 26:
        break

    a = n//26
    n = a

ln.reverse()
ln=''.join(ln)
print(ln)
n = int(input())
alpha = [chr(x) for x in range(ord('a'), ord('z')+1)]
name = ''
while n:
  n -= 1
  r = int(n%26)
  n = n // 26
  print(n, r)
  name += alpha[r]
print(name[::-1])
import sys
import numpy as np
import math
from collections import deque 
from functools import reduce

n = int(input())
az = "zabcdefghijklmnopqrstuvwxy"
cnt = 12
ret = []
ama = n % 26
na = n
for i in range(12, 0, -1):
    if 26**(i-1) > n:
        continue
    sho = na // (26**i)
    if sho > 0:
        ret.append(az[sho])
    na -= sho * (26**i)
if ama > 0:
    ret.append(az[ama])
if (ret[0] == 'z'):
    del ret[0]
re = "".join(ret)
print(re)
n = int(input())
ans = list()
while n>0:
    x = n % 26
    ans.append(x)
    n = int(n / 26)

str_ans = ""
for x in ans[::-1]:
    str_ans += chr(x+96)

print(str_ans.replace("a`", "z"))
n = int(input())
al = 'abcdefghijklmnopqrstuvwxyz'
num = []
while True:
    if n//26 == 0:
        num.append(n)
        break
    else:
        amari = n%26
        n = n//26
        num.append(amari)
num.reverse()
for nums in num:
    print(al[nums-1],end = "")
import math
N = int(input())
char = [chr(i) for i in range(97, 97+26)]
K = math.floor(math.log(N , 26))
s = ''
mod = 26**K
for i in range(K+1):
  a = N//(mod)
  N = N % mod
  mod = int(mod/26)
  s += char[a-1]
print(s)
N=int(input())
alpha=list("abcdefghijklmnopqrstuvwxyz")

ans=""
while N>=26:
  a=N%26
  N=N//26
  ans=alpha[a-1]+ans
ans=alpha[N-1]+ans
print(ans)
number   = int(input())
alphabet = [chr(i) for i in range(97, 97+26)]
name_tag = []

while number != 0:
  a      = number % 26
  number = number // 26
  name_tag.append(a)
  
reverse_name_tag = reversed(name_tag)
for i in reverse_name_tag:
  print(alphabet[i-1], end="")
n = int(input())
k = 3670344486987776
keta = [3670344486987776]
while(k>1):
    k/= 26
    keta.append(int(k))
    # print(k)
# print(keta)
sin26 = []
f = 0
for i in range(1,12):
    # print(keta[i-1],n,keta[i],i)
    if(keta[i-1] > n and n >= keta[i]):
        f = 0
        c = n//keta[i]
        sin26.append(chr(c+ord("a")-1))
        n %= keta[i]
    elif(f == 1):
        sin26.append("a")

print("".join(sin26))
def Quadrillion():

    Num = int(input())

    if Num<=26:
        moji = chr(96+Num)
    elif Num%26==0:
        moji = num2alpha(Num//26-1)+chr(96)
    else:
        moji = num2alpha(Num//26)+chr(96+Num%26)

    print(moji)

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

if __name__ == '__main__':
    Quadrillion()
N = int(input())
mapping = 'zabcdefghijklmnopqrstuvwxy'
res = []
for i in range(1, 99):
    if N <= 26 ** i:
        for j in range(i):
            res.append(mapping[N % 26])
            N //= 26
        break
    else:
        N -= 26 ** i
print(''.join(res))
N = int(input())
L = list('zabcdefghijklmnopqrstuvwxy')
L_2 = list('abcdefghijklmnopqrstuvwxyz')
ans_l = []

if N <= 26:
    print(L_2[N - 1])
    exit()



while (N >= 26):
    syou = N // 26
    amari = N % 26
    ans_l.append(L[amari])
    if amari == 0:
        N = syou - 1
    else:
        N = syou

if amari != 0: ans_l.append(L[amari])

ans_l = ans_l[::-1]
print(*ans_l, sep="")
n = int(input())

buf = []
while True:
    if n > 26:
        tp = n%26
        buf.append(tp)
        n = n//26
    else:
        buf.append(n)
        break

# print(buf)
buf.reverse()

ans = ""
for b in buf:
    ans += chr(b+96)

print(ans)
n = int(input())

# n // 26  # 答え
# n % 26 # あまり

res = []
amari = 0
while n > 0:
  res.append(n % 26)
  n = n // 26
  
key = ["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"]
for i in res[::-1]:
  print(key[i - 1], end="")
import sys
sys.setrecursionlimit(10 ** 5 + 10)
def input(): return sys.stdin.readline().strip()

def resolve():
    
    n=int(input())
    alp=list(chr(ord('a')+i) for i in range(26))
    ans=[]
    
    while n>0:
        a,b=divmod(n,26)
        n//=26
        ans.append(alp[b-1])
    print(''.join(ans[::-1]).replace('az','z'))
        

    
resolve()
n = int(input())

alphabet = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'n', 'm', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z']

ans = []
while True:
    mod = n % 26
    if mod != 0:
        ans.append(mod)
    n = n // 26
    if n < 26:
        ans.append(n)
        break
ans_s = ''
for tmp in reversed(ans):
    ans_s += alphabet[tmp - 1]
print(ans_s)
N = int(input())


keta_num = 1
tmp_num = 0
while N > tmp_num + (26 ** keta_num):
    tmp_num += 26 ** keta_num
    keta_num += 1

# keta_num -= 1
# print(keta_num, tmp_num)

names = []

alphabets = list('abcdefghijklmnopqrstuvwxyz')


for keta in range(keta_num, 0, -1):
    # print(N, tmp_num)
    name = (N - tmp_num) % 26
    # print(name)
    names.append(alphabets[name - 1])
    N -= tmp_num
    tmp_num = tmp_num - (26**(keta - 1))
# print(names)
print(''.join(names))
n = int(input())
alphabet = 'abcdefghijklmnopqrstuvwxyz'
ans = ''

while n >= 26:
    n,mod = divmod(n, 26)
    ans += alphabet[mod-1]
ans += alphabet[n-1]
reverse_ans = ''.join(list(reversed(ans)))
print(reverse_ans)
# coding: utf-8

N = int(input())

def num_to_alpha(num):
    return str(chr(num + 64))

def ten_to_26_sin(ten, acc):
    if ten < 26:
        acc.append(ten)
        return acc
    acc.append(ten % 26)
    return ten_to_26_sin(ten // 26, acc)


tmp = list(reversed(list(map(num_to_alpha, ten_to_26_sin(N, [])))))

print("".join(tmp).lower())
n = int(input())
s = ""

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

tmp=0
for ll in range(1,11):
  tmp+=26**ll
  if n<=tmp:
    break

s=chr((n-1)%26+ord("a")) ##一文字目
for i in range(1,ll):
  n-=26**i
  n-=1
##  print(n//26)
  s+=chr(n//26%26+ord("a")) 
  n+=1

print(s[::-1])
from decimal import Decimal
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']
S=""
n=Decimal(input())
for i in range(0, 11):
    if int(n//(26**i))<27:
        S+=abc[int(n//(26**i))]
        n-=(n//26**i)*(26**i)
    else:
        S+=abc[int((n-(n//(26**(i+1))*(26**(i+1))))//(26**i))]
        n-=int((n-(n//(26**(i+1))*(26**(i+1))))//(26**i))
        
print(S[::-1])
n=int(input())
ans=''
while n:
  ans+=chr((n-1)%26+ord('a'))
  n//=26
print(ans[::-1])
n = int(input())

for index in range(1, 11):
  if n > 26*(1 - 26**(index - 1))/(1 - 26) and n <= 26*(1 - 26**index)/(1 - 26):
    break

# index: how long is the word
# it can not be over 11
n -= 26*(1 - 26**(index - 1))/(1 - 26) + 1
name = []
for i in range(index):
  name.append(chr(ord('a') + int(n % 26)))
  n = int(n / 26)

print(''.join(name[::-1]))
N=int(input())
alpha=[chr(ord('a') + i) for i in range(26)]
S=""
i=0
while(N>=1):
  S+=alpha[(N-1)%26]
  N=N//26
print(S[::-1])
n = int(input())

res = ''
while 0 < n:
    r = n % 26
    res += chr(r+ord('a')-1)
    n //= 26

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

alp = 'zabcdefghijklmnopqrstuvwxy'

name = []

while n > 0:
    n -= 1
    name.append(alp[n % 26])
    n //= 26

name.reverse()

print(*name,sep='')
N = int(input())
ans = ''
while N > 0:
  N -= 1
  ans += chr(ord('a') + N % 26)
  N //= 26
  print(ans[::-1])
n = int(input())
n_list = []
num_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 = ''
while n >= 26:
    m = n % 26
    n = n // 26
    n_list.append(m)
n_list.append(n)
n_list.reverse()
for i in range(len(n_list)):
    n_list[i]= num_list[n_list[i] - 1]
    ans = ans + n_list[i]
print(ans)
import string
from decimal import Decimal, getcontext

getcontext().prec = 99
characters = string.ascii_lowercase
base_number = Decimal(26)


def convert_base_number(tmp, result):
    idx = (Decimal(tmp) % base_number) - 1
    return characters[int(idx)] + result


def resolve():
    tmp = Decimal(input())

    result = ''
    while tmp >= base_number:
        result = convert_base_number(tmp, result)
        tmp = Decimal(tmp) / base_number

    result = convert_base_number(tmp, result)
    print(result)


resolve()
import string

characters = '0' + string.ascii_lowercase
base_number = 26


def get_result(tmp, result):
    idx = (tmp % base_number)
    return characters[int(idx)] + result


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

    result = ''
    while tmp >= base_number:
        result = get_result(tmp, result)
        tmp = tmp / base_number

    print(get_result(tmp, result))


resolve()
n = int(input())
 
an =[]
while n!=0:
    n,q=divmod(n,26)
    an.append(chr(q+96))
an.reverse()    
print(''.join(an))
N = int(input())
ans = ''
alp = 'abcdefghijklmnopqrstuvwxyz'
q, mod = divmod(N, 26)
while True:
    if q == 0:
        ans += alp[mod-1]
        break
    else:
        ans += alp[mod-1]
    q, mod = divmod(q, 26)
print(ans[::-1])
import string

# 1千兆 + 1
N = int(input())
n_digits = len(str(1000000000000001))
letters = string.ascii_lowercase

x = N
ans = []
while True:
    x -= 1
    mod = x % 26
    ans = [ mod ] + ans
    x = x // 26
    if x <= 0:
        break

print(ans)
print("".join([ letters[v] for v in ans ]))
import string
N = int(input())
strings = string.ascii_letters
ans = ""
while True:
    M = N % 26
    N = N // 26

    ans += strings[M-1]

    if N == 0:
        break
print(ans[::-1])
import sys
sys.setrecursionlimit(4100000)
import math
INF = 10**9

def main():
    n = int(input())

    a = int(math.log(n,26))
    a2 = n - 26**a
    ans = ''
    b = n
    for i in range(a+1):
        if b % 26:
            ans += chr(ord('a')+int(b//(26**(a-i))))
        else:
            ans += chr(ord('a')-1+int(b//(26**(a-i))))
        b -= 26**(a-i)*(b//(26**(a-i)))
    print(ans)


if __name__ == '__main__':
    main()
n = int(input())
c = 0
n1 = 0
n1 += n
for i in range(1,12):
    a = n1 - 26**(i)
    c += 1
    if a <= 0:
        break
    n1 = n1 - 26**(i)
a = ""
for i in range(c):
    if n // 26**(c-i-1) >= 26:
        alpha = 26
        n = n - 26**(c-i)
    else:
        alpha = n // 26**(c-i-1)
        n = n % 26**(c-i-1)
    a += chr(96 + alpha)
print(a)
n = int(input())

def toa(n):
    return chr((ord('a')+(n)))

temp = 1
digit = 1
while temp+26**digit <= n:
    temp+=26**digit
    digit+=1

ans = ''
for i in range(digit, 0, -1):
    for j in range(27):
        if 26**(i-1) < n:
            n-=26**(i-1)
        else:
            if i==1:
                ans+=toa(j)
            else:
                ans+=toa(j-1)
            break
print(ans)
N = int(input())
namelist = []
num2alpha = lambda c: chr(c+64)
for i in range(20):
    if N <= 26:
        namelist.append(num2alpha(N))
        break
    q = N//26
    mod = N%26
    N = q
    namelist.append(num2alpha(mod))
    

namelist.reverse()
ans = ''.join(namelist)

print(ans.lower())
a=int(input())
s=0
si=[]
while a!=0:
    b=a%26
    si.append(b)
    a=a//26

c=""
for i in si:
    c+=chr(i+96)
c=c[::-1]
print(c)
n = int(input())
alpha_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 = ''


while(n > 0):
  ans += alpha_list[(n % 26) - 1]
  n = int(n // 26)
  
print(ans[::-1])
l = [chr(ord('a')+i) for i in range(26)]
n = int(input())
res = ""
while n > 0:
    s = l[n%26-1]
    n = int(n/26)
    res = res+s
print("".join(reversed(res)))
N = int(input())
if 1<= N <= 1000000000000001:
    moji = list('abcdefghijklmnopqrstuvwxyz')
    amari = N
    syo = 0
    kai = ""
    lis = []
    for i in range(12,0,-1):
        syo = amari // (26 ** i)
        amari = amari % (26 ** i)
        if syo >0:
            kai += moji[(syo - 1)]
            
    kai += moji[(amari - 1)]
    print(kai)
        
else:
    print("")
n = int(input())
a = [chr(i) for i in range(97, 97+26)]
ans = []
while n>0:
    ans.insert(0,a[n%26-1])
    n = n // 26
print(''.join(ans))
n=int(input())
out=""
while(1):
    asc=n%26
    if(asc==0):
        asc=26
    asc=97+asc-1
    out+=chr(asc)
    n=n//26
    if(n<=0):
        break

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

while N > 0:
    N, i = divmod(N, 26)
    x.append(chr(i + 96))
print(''.join(x))
N = int(input())
ans = ''
while True:
    ans = ans+chr(ord('a')+N%26-1)
    N = N//26
    if N == 0:
        break
print(ans[::-1])
N = int(input())

res = []
while N != 0:
    p = N % 26
    N = N // 26
    res.append(chr(p + 96))

res.reverse()
result = ''.join(res)
print(result)