CodeEff/ECCO huggingface dataset:
# Original solution


# def base_10_to_n(X, n):
#     if (int(X/n)):
#         return base_10_to_n(int(X/n), n)+str(X%n)
#     return str(X%n)



# def main():

#     alp = 'abcdefghijklmnopqrstuvwxyz'
#     n = int(input())

#     s = base_10_to_n(n-1,26)
#     print(s)


# if __name__ == "__main__":
#     main()

alp = 'abcdefghijklmnopqrstuvwxyz'
n = int(eval(input()))
for i in range(10):
    ind1 = 26*(pow(26,i-1)-1)//25 + 1
    ind2 = 26*(pow(26,i)-1)//25 + 1
    if ind1 <= n < ind2:
        n_len = i

# print(n_len)

n = n
ans = ''
for i in range(20,1,-1):
    curr_a = n%26
    ind = curr_a -1
    if ind == -1: ind = 25
    ans += alp[ind]
    if n < 26:
        break
    n = n//26
    if ind == 25: 
        n=n-1
        if n <= 0:break

print((ans[::-1]))

# Optimized solution
alps = 'abcdefghijklmnopqrstuvwxyz'

n = int(eval(input()))
if n == 1:
    print('a')
    exit()

ansl = []
curr_n = n
for i in range(15, -1, -1):
    if n <= pow(26,i):
        continue
    val = curr_n//pow(26,i)
    ansl.append(val)
    curr_n -= val*pow(26,i)


for j in range(100):
    for i in range(len(ansl)-1):
        if ansl[i+1] == 0:
            ansl[i+1] = 26
            ansl[i] -= 1

ans = ''
for a in ansl:
    if a == 0: continue
    ans += alps[a-1]

print(ans)
# Original solution
def II(): return int(eval(input()))
N=II()
N-=1
ans=''
for l in range(1,15):
  if N>=26**l:
    N-=26**l
    continue
  for i in range(l):
    d=N%26
    ans+=chr(d+ord('a'))
    N//=26
  ans=ans[::-1]
  break
print(ans)

# Optimized solution
def II(): return int(eval(input()))
def MI(): return list(map(int, input().split()))
def LI(): return list(map(int, input().split()))
ans=''
N=II()
N-=1
for l in range(1,15):
  if N>=26**l:
    N-=26**l
    continue
  for i in range(l):
    d=N%26
    ans+=chr(d+ord('a'))
    N//=26
  ans=ans[::-1]
  break
print(ans)
# Original solution
def II(): return int(eval(input()))
def MI(): return list(map(int, input().split()))
def LI(): return list(map(int, input().split()))
ans=''
N=II()
N-=1
for l in range(1,15):
  if N>=26**l:
    N-=26**l
    continue
  for i in range(l):
    d=N%26
    ans+=chr(d+ord('a'))
    N//=26
  ans=ans[::-1]
  break
print(ans)


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

# Optimized solution
def II(): return int(eval(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)
# Original solution
def II(): return int(eval(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)

# Optimized solution
def II(): return int(eval(input()))
N=II()
N-=1
i=1
ans=''
while N-26**i>=0:
  N-=26**i
  i+=1
for j in range(i):
  div,mod=divmod(N,26)
  ans+=chr(mod+ord('a'))
  N=div
ans=ans[::-1]
print(ans)
# Original solution
from collections import deque
import math


def main():
    n = int(input())
    if n == 1:
        print('a')
        return
    digits = deque()
    alpha = ord('a') - 1
    maxex = int(math.log(n-1, 26))
    ex = 1
    for ex in range(1, maxex + 2):
        bb = pow(26, ex - 1)
        aa = bb * 26
        rem = n % aa // bb
        n -= bb * rem
        if rem == 0:
            if n == 0:
                break
            rem += 26
            n -= aa
        digits.appendleft(chr(alpha + rem))

    [print(d, end='') for d in digits]
    print()


if __name__ == '__main__':
    main()


# Optimized solution
from collections import deque


def main():
    n = int(eval(input()))
    base = 26
    orig = ord('a')
    ans = deque()
    for exp in range(1, 12):
        if (tmp := pow(base, exp)) >= n:
            n -= 1  # zero_indexed for ASCII mod
            for digit in range(exp):
                ans.appendleft(chr(orig + n % base))
                n //= base
            break
        else:
            n -= tmp
    print((''.join(ans)))


if __name__ == '__main__':
    main()
# Original solution
from collections import deque


def main():
    n = int(eval(input()))
    base = 26
    orig = ord('a')
    ans = deque()
    for exp in range(1, 12):
        if (tmp := pow(base, exp)) >= n:
            n -= 1  # zero_indexed for ASCII mod
            for digit in range(exp):
                ans.appendleft(chr(orig + n % base))
                n //= base
            break
        else:
            n -= tmp
    print((''.join(ans)))


if __name__ == '__main__':
    main()


# Optimized solution
def main():
    n = int(eval(input()))
    base = 26
    orig = ord('a')
    ans = ''
    for exp in range(1, 12):
        if (tmp := pow(base, exp)) >= n:
            n -= 1  # zero_indexed for ASCII mod
            for digit in range(exp):
                ans += (chr(orig + n % base))
                n //= base
            break
        else:
            n -= tmp
    print((ans[::-1]))


if __name__ == '__main__':
    main()
# Original solution
N = int(eval(input()))

ans = ""

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

# Optimized solution
N = int(eval(input()))
s = ""
while N != 0:
    N -= 1
    r = N % 26
    s += chr(ord('a') + r)
    N //= 26

print((s[::-1]))
# Original solution
import sys 
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
N = int(readline())
A = []
while(N>26):
    s = N % 26
    if s == 0:
      A.append(26)
      N = (N-26) // 26
    else:
      A.append(s)
      N = (N-s) // 26
A.append(N)
A = A[::-1]
ans = ''
d = ['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 A:
  ans += d[i-1]
print(ans)

# Optimized solution
import sys 
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
N = int(readline())
res = ''
while(N):
    N -= 1
    res += chr(ord('a') + N % 26)
    N //= 26
print((res[::-1]))
# Original solution
n = int(eval(input()))
a = 'abcdefghijklmnopqrstuvwxyz'
ans = ''
while n > 0:
    n, r = divmod(n-1, 26)
    ans = a[r] + ans
print(ans)


# Optimized solution
n = int(eval(input()))
ans = ''
while n > 0:
    n, r = divmod(n-1, 26)
    ans = chr(r+ord('a')) + ans
print(ans)
# Original solution
N = int(eval(input()))
name = []
while N > 0:
    name.append((N - 1) % 26)
    N -= 1
    N //= 26
name.reverse()
ans = "".join(chr(ord("a") + x) for x in name)
print(ans)

# Optimized solution
N = int(eval(input()))
c = []
while N > 0:
    N -= 1
    c.append(N % 26)
    N //= 26
c.reverse()
ans = "".join(chr(ord("a") + x) for x in c)
print(ans)
# Original solution
n = int(eval(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()))

# Optimized solution
n = int(eval(input()))
def sinsu(num):
  if num <= 26:
    return chr(64+num)
  elif num%26 == 0:
    return sinsu(num//26-1) + chr(90)
  else:
    return sinsu(num//26)+chr(64+num%26)
print((sinsu(n).lower()))
# Original solution
import math

# one = 1000000000000001
dict={1:"a",2:"b",3:"c",4:"d",5:"e",6:"f",7:"g",8:"h",9:"i",10:"j",
        11:"k",12:"l",13:"m",14:"n",15:"o",16:"p",17:"q",18:"r",19:"s",20:"t",
        21:"u",22:"v",23:"w",24:"x",25:"y",26:"z"}

n=int(eval(input()))

ans = str(dict[(n-1)%26+1])

n=(n-1)//26
while n:
    ans = str(dict[(n-1)%26+1]) + ans
    n=(n-1)//26

print(ans)


# Optimized solution
import math

# one = 1000000000000001
dict={1:"a",2:"b",3:"c",4:"d",5:"e",6:"f",7:"g",8:"h",9:"i",10:"j",
        11:"k",12:"l",13:"m",14:"n",15:"o",16:"p",17:"q",18:"r",19:"s",20:"t",
        21:"u",22:"v",23:"w",24:"x",25:"y",26:"z"}

n=int(eval(input()))
ans = ""

while n:
    ans = str(dict[(n-1)%26+1]) + ans
    n=(n-1)//26

print(ans)
# Original solution
n = int(eval(input()))
chars = "Xabcdefghijklmnopqrstuvwxyz"  

n_rem = n  
res = ""

while True:
    x = n_rem % 26
   
    if x == 0:
        x = 26
    res += chars[x]

    
    n_rem -= x

    
    if n_rem == 0:
        break

    n_rem //= 26


print((res[::-1]))

# Optimized solution
N = int(eval(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]))
# Original solution
import sys
sys.setrecursionlimit(10000000)
MOD = 10 ** 9 + 7
INF = 10 ** 15

def main():
    N = int(eval(input()))
    num = []
    now = 0
    for i in range(12):
        now += pow(26,i + 1)
        num.append(now)
    #print(num)
    for i in range(12):
        if num[i] >= N:
            length = i
            break
    #print(length)
    ans = ''
    if length > 0:
        N -= num[length - 1]
    N -= 1
    
    #print(N)
    now = pow(26,length)
    for j in range(length + 1):
        x = N//now
        ans += chr(x + 97)
        N %= now
        now //=26
        #print(ans)
    
    print(ans)
if __name__ == '__main__':
    main()

# Optimized solution
import sys
sys.setrecursionlimit(10000000)
MOD = 10 ** 9 + 7
INF = 10 ** 15

def main():
    N = int(eval(input()))
    ans = []
    while N:
        N -= 1
        ans.append(chr(N%26 + 97))
        N //= 26
    print((''.join(map(str,ans[::-1]))))
if __name__ == '__main__':
    main()
# Original solution
def main():
    from string import ascii_lowercase

    N = int(eval(input()))

    def rec(n):
        if n == 0: return ''
        n -= 1
        n, r = divmod(n, 26)
        return rec(n) + ascii_lowercase[r]

    print((rec(N)))


if __name__ == '__main__':
    main()


# Optimized solution
def main():
    from string import ascii_lowercase
    N = int(eval(input()))

    ans = []
    while N > 0:
        N -= 1
        N, i = divmod(N, 26)
        ans.append(ascii_lowercase[i])

    ans = ''.join(reversed(ans))

    print(ans)


if __name__ == '__main__':
    main()
# Original solution
alphabet='abcdefghijklmnopqrstuvwxyz'
N=int(eval(input()))
r=[]
while N>26:    
  x=N%26
  N=N//26
  if x==0:
    N-=1
    x=26
  r.append(x)
r.append(N)
name=[alphabet[i-1] for i in r]
name.reverse()
name=''.join(name)
print(name)

# Optimized solution
alphabet='abcdefghijklmnopqrstuvwxyz'
N=int(eval(input()))
name=''
while N>0:
  N-=1
  name+=alphabet[N%26]
  N//=26
print((name[::-1]))
# Original solution
# coding: utf-8
N = int(eval(input()))
S = "abcdefghijklmnopqrstuvwxyz"
ans = ""
while N > 0:
    N -= 1
    ans += chr(ord("a") + N % 26)
    N //= 26
print((ans[::-1]))

# Optimized solution
# coding: utf-8
N = int(eval(input()))
S = "abcdefghijklmnopqrstuvwxyz"
ans = ""
while N > 0:
    N -= 1
    ans += S[N % 26]
    N //= 26
print((ans[::-1]))
# Original solution
def base_k(n, k=26):
    ret = []
    ny = n
    while ny:

        ret.append(ny % k)
        ny //= k
    return ret[::-1]


def letter(i):
    return chr(i+97)


def solve(n):
    check = 26
    cnt = 1
    k = n
    while True:
        if n <= check:
            break
        check *= 26
        check += 26
        cnt += 1
    k -= check//26 - 1
    t = base_k(k-1)
    ans = ""
    if not t:
        ans = "a" * cnt
    else:
        for _ in range(cnt):
            if not t:
                ans += "a"
                continue
            ans += letter(t.pop())

    return ans[::-1]


n = int(eval(input()))
print((solve(n)))


# Optimized solution
def answer(n):
    if n <= 26:
        return chr(n-1 + 97)
    r = n % 26 - 1
    if r == -1:
        r += 26
    return answer((n-r) // 26) + chr(r + 97)


n = int(eval(input()))
print((answer(n)))
# Original solution
def main():
    #input
    N=int(eval(input()))
    l=list("zabcdefghijklmnopqrstuvwxy")
    if N<26:
        print((l[N]))
    else:
        name=[]
        n=N
        while n>=26:
            mod=n%26
            if mod!=0:
                n//=26
            else:
                n//=26
                n-=1
            name.append(l[mod])
        if n!=0:
            name.append(l[n])
        name=[name[n] for n in reversed(list(range(len(name))))]
        print(("".join(name)))

if __name__=="__main__":
    main()
    

# Optimized solution
def main():#やり直し
    #input
    N=int(eval(input()))
    l=list("abcdefghijklmnopqrstuvwxyz")
    n=N
    name=""
    while n>=26:
        n-=1
        name+=l[n%26]
        n//=26
    if n!=0:
        name+=l[n-1]
    print((name[::-1]))

if __name__=="__main__":
    main()
# Original solution
n=int(eval(input()))

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

rest=[]
while n!=0:
    rest.append(n%26)
    n = n // 26
rest.reverse()

for i in range(len(rest)-1):
    if rest[len(rest)-1-i]<=0:
        rest[len(rest)-1-i]+=26
        rest[len(rest)-2-i]-=1
if rest[0]<=0:
    rest=rest[1:]

ans=''
for i in range(len(rest)):
    ans+=alphabet[rest[i]]
print(ans)


# Optimized solution
n=int(eval(input()))

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

ans=''
while n>0:
    n-=1
    ans+=alphabet[n%26]
    n //= 26
print((ans[::-1]))
# Original solution
import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines

def main():
    N = int(readline())
    
    ans = ''
    while N:
        if N % 26 == 0:
            ans += "z"
            N -= 1
            N //= 26
        else:
            ans += chr((N % 26) -1  + 97)
            N //= 26

    print((ans[::-1]))

if __name__ == "__main__":
    main()


# Optimized solution
import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines

def main():
    N = int(readline())
    
    ans = ''
    while N:
        N -= 1
        ans += chr((N % 26) + 97)
        N //= 26

    print((ans[::-1]))

if __name__ == "__main__":
    main()
# Original solution
import sys, collections, bisect, itertools, heapq, math, copy, string
input = lambda: sys.stdin.readline().rstrip() 
sys.setrecursionlimit(10**7)
INF = float('inf')
def I(): return int(eval(input()))
def F(): return float(eval(input()))
def SS(): return eval(input())
def LI(): return [int(x) for x in input().split()]
def LI_(): return [int(x)-1 for x in input().split()]
def LF(): return [float(x) for x in input().split()]
def LSS(): return input().split()

def resolve():
    N = I() - 1

    ans = ''
    while N >= 26:
        ans += string.ascii_lowercase[N%26]
        N = N // 26 - 1
    ans += string.ascii_lowercase[N%26]

    print((ans[::-1]))

if __name__ == '__main__':
    resolve()


# Optimized solution
import sys, collections, bisect, itertools, heapq, math, copy, string
input = lambda: sys.stdin.readline().rstrip() 
sys.setrecursionlimit(10**7)
INF = float('inf')
def I(): return int(eval(input()))
def F(): return float(eval(input()))
def SS(): return eval(input())
def LI(): return [int(x) for x in input().split()]
def LI_(): return [int(x)-1 for x in input().split()]
def LF(): return [float(x) for x in input().split()]
def LSS(): return input().split()

def resolve():
    N = I()

    ans = ''
    radix = 26
    while N > 0:
        ans += string.ascii_lowercase[N%radix-1]
        N = (N - 1) // radix

    print((ans[::-1]))

if __name__ == '__main__':
    resolve()
# Original solution
n = int(eval(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]))

# Optimized solution
n = int(eval(input()))
ans = ''
while n>0:
    n -= 1
    ans += chr(ord('a') + n%26)
    n //= 26
print((ans[::-1]))
# Original solution
N = int(eval(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)

# Optimized solution
def solve():
  N = int(eval(input()))
  k = 1
  while N>pow(26,k):
    N -= pow(26,k)
    k += 1
  ans = ''
  N -= 1
  for i in range(k,0,-1):
    if i>1:
      ans += chr(ord('a')+N//pow(26,i-1))
    else:
      ans += chr(ord('a')+N%pow(26,i))
    N%=pow(26,i-1)
  return ans
print((solve()))
# Original solution
n = int(eval(input()))

ans = []
for i in range(1, 99): # 99は適当
    if n <= 26**i:
        n -= 1 # これが必要
        for j in range(i):
            ans.append(chr(ord('a') + n % 26))
            n //= 26
        break
    else:
        n -= 26**i

print((''.join(ans[::-1])))

# Optimized solution
n = int(eval(input()))

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

print((''.join(ans[::-1])))
# Original solution
n = int(eval(input()))

#26進数
dim = []
while n>0:
    q,r = divmod(n-1, 26)
    dim.append(r)
    n=q

import string
dic = {i:l for i,l in enumerate(string.ascii_lowercase)}

print((''.join([dic[d] for d in reversed(dim)])))
    

# Optimized solution
import string
n = int(eval(input()))

#26進数
ans = []
while n>0:
    q,r = divmod(n-1, 26)
    ans.append(r)
    n=q

print((''.join([string.ascii_lowercase[bit] for bit in reversed(ans)])))
# Original solution
N = int(eval(input()))
ans = ""

while N>0:
  N -= 1
  num = N%26
  ans += chr(ord("a")+num)
  N //= 26
  
print((ans[::-1]))

# Optimized solution
N = int(eval(input()))
ans = ""

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

y = int(eval(input()))

ans = []
while y > 26:
    res = y%26
    if res == 0:
        ans.append(25)
        y = y//26 - 1
    else:
        ans.append(y%26 - 1)
        y = y // 26
ans.append(y - 1)
ans = ans[::-1]
S = ''
for i in range(len(ans)):
    S += alp[ans[i]]
print(S)

# Optimized solution
N = int(eval(input()))
alp = [chr(i) for i in range(ord('a'), ord('z')+1)]
ans = []

while N > 0:
    res = N % 26
    ans.append(alp[res - 1])
    N //= 26
    if res == 0:
        N -= 1

ans = ans[::-1]
print((''.join(ans)))
# Original solution
N,a=int(eval(input())),''
while 0<N:N-=1;a+=chr(ord('a')+N%26);N//=26
print((a[::-1]))

# Optimized solution
N,a=int(eval(input())),''
while 0<N:N-=1;a+=chr(97+N%26);N//=26
print((a[::-1]))
# Original solution
N = int(eval(input()))
string = ""
while N > 0:
    N, remainder = divmod(N - 1, 26)
    string = chr(65 + remainder) + string
print((string.lower()))

# Optimized solution
N = int(eval(input()))
string = ""
while N > 0:
    N, remainder = divmod(N - 1, 26)
    string = chr(97 + remainder) + string
print(string)
# Original solution
N = int(eval(input()))

# 桁数を決める
tmp = 0
digit = 1
tmp += pow(26, digit)
while N > tmp:
    digit += 1
    tmp += pow(26, digit)

order = N - (tmp - pow(26, digit)) - 1
X = [0] * digit
cur = digit - 1
while order > 0:
    X[cur] = order % 26
    order //= 26
    cur -= 1

# X = list(reversed(X))
# print(X)

a = ord('a')
ans = []
for x in X:
    c = chr(a + x)
    ans.append(c)

print((''.join(ans)))


# Optimized solution
N = int(eval(input()))

# 桁数を決める
digit = 1  # 桁数
num = pow(26, digit) # その桁数での最大番号
while num < N:
    digit += 1
    num += pow(26, digit)

# その桁数内でのNの順番を0-indexで求める.
# (つまり, 2桁であれば'aa' -> 0, 'zz' -> 675 となる.)
order = N - (num - pow(26, digit)) - 1

# orderを26進数表記する.
# 例えば, 3桁でorder=28のとき, X = [0, 1, 2]
X = [0] * digit
cur = digit - 1
while order > 0:
    X[cur] = order % 26
    order //= 26
    cur -= 1

# 各桁の文字は'a' + Xiとなる
ans = []
a = ord('a')
for x in X:
    c = chr(a + x)
    ans.append(c)

print((''.join(ans)))
# Original solution
def solve():
    n = int(eval(input()))
    a = 97
    tmp = 0
    index = 0
    ans = []
    for i in range(1, 12):
        pre = tmp
        tmp += 26 ** i
        if n <= tmp:
            index = i
            n = n - pre
            break
    n = n - 1
    for _ in range(0, index)[::-1]:
        ans.append(chr((n % 26) + a))
        n = n // 26
    print((''.join(ans[::-1])))








if __name__ == '__main__':
    solve()


# Optimized solution
def solve():
    n = int(eval(input()))
    l = 0
    ans = ''
    for i in range(1, 12):
        if n <= 26 ** i:
            l = i
            break
        n = n - 26 ** i
    k = n - 1
    for i in range(l):
        ans = chr(k % 26 + 97) + ans
        k = k // 26

    print(ans)











if __name__ == '__main__':
    solve()
# Original solution
n = int(eval(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))))

# Optimized solution
n = int(eval(input()))-1

ans = []
while n >= 0:
    n, y = divmod(n, 26)
    ans.append(y)
    n -= 1
print((''.join([chr(x+ord('a')) for x in ans[::-1]])))
# Original solution
n = int(eval(input()))
alph = "zabcdefghijklmnopqrstuvwxy"


ans = ""
while n >= 1:
    div, mod = divmod(n, 26)
    ans += alph[mod]
    n = div
    if mod == 0:
        n -= 1
print((ans[::-1]))

# Optimized solution
n = int(eval(input()))
alph = "abcdefghijklmnopqrstuvwxyz"

ans = ""
while n >= 1:
    n -= 1
    div, mod = divmod(n, 26)
    ans += alph[mod]
    n = div
print((ans[::-1]))
# Original solution
# import sys
# import math #sqrt,gcd,pi
# import decimal
# import queue # queue
# import bisect
# import heapq # priolity-queue
# import time
# from itertools import product,permutations,\
#     combinations,combinations_with_replacement
# 重複あり順列、順列、組み合わせ、重複あり組み合わせ
# import collections # deque
# from operator import itemgetter,mul
# from fractions import Fraction
# from functools import reduce

mod = int(1e9+7)
# mod = 998244353
INF = 1<<50

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

def main():
    n = int(eval(input()))
    s = []
    while n!=0:
        if n<=26:
            s.append(n)
            n = 0
        else:
            x = n % 26
            if x==0:
                x = 26
            s.append(x)
            n = (n-1) // 26
    t = []
    for i in range(len(s)-1,-1,-1):
        t.append(chr(s[i]+96))
    print((''.join(t)))
    return

if __name__=='__main__':
    main()


# Optimized solution
n = int(eval(input()))
s = []
while n!=0:
    if n<=26:
        s.append(n)
        n = 0
    else:
        x = n % 26
        if not x:
            x = 26
        s.append(x)
        n = (n - 1) // 26
t = []
for i in range(len(s)-1,-1,-1):
    t.append(chr(s[i]+96))
print((''.join(t)))
# Original solution
import sys
input = lambda: sys.stdin.readline().rstrip()

ans = ""
N = int(eval(input()))
while N > 0:
    tmp = N % 26
    if tmp == 0:
        ans += chr(26+96)
        if N == 26:
            break
        N //= 26
        N -= 1
        
    else:    
        ans += chr(tmp+96)
        N //= 26

print((ans[::-1]))

# Optimized solution
N = int(eval(input()))
ans = ''
while N > 0:
    N -= 1  
    ans += chr(ord('a') + N % 26)
    N //= 26
print((ans[::-1]))
# Original solution
N = int(input())

s = []
a = 26
tmp = 1
for i in range(20):
    s.append(tmp)
    tmp += a
    a *= 26
    if tmp > 100000000000000000:
        break

for i in range(len(s)):
    if N >= s[i]:
        continue
    else:
        size = i 
        break

b = N - s[size-1]

n2a = lambda c: chr(c+64)
a = 26 ** (size-1)

ans = []
while(a >= 1):
    ans.append(n2a(b // a + 1).lower())
    b %= a
    a //= 26

print(*ans, sep="")


# Optimized solution
N = int(eval(input()))
N -= 1

d = 26
for i in range(1,15):
    if N >= d:
        N -= d
        d *= 26
    else:
        d //= 26
        ans = ""
        for j in range(i):
            ans += chr(N // d + ord("a"))
            N %= d
            d //= 26
        break

print(ans)