CodeEff/ECCO huggingface dataset:
# Original solution
from string import ascii_lowercase
from itertools import accumulate


def solve(string):
    n = int(string)
    t = [0] + [len(ascii_lowercase)**i for i in range(1, 12)]
    *t, = accumulate(t)
    l = 0
    ans = ""
    while t[l] < n:
        l += 1
    n -= t[l - 1] + 1
    for i in range(l - 1):
        j, n = divmod(n, len(ascii_lowercase)**(l - i - 1))
        ans += ascii_lowercase[j]
    ans += ascii_lowercase[n]
    return ans


if __name__ == '__main__':
    import sys
    print((solve(sys.stdin.read().strip())))


# Optimized solution
from string import ascii_lowercase


def solve(string):
    n = int(string)
    ans = ""
    while n:
        n, c = divmod(n - 1, len(ascii_lowercase))
        ans = ascii_lowercase[c] + ans
    return ans


if __name__ == '__main__':
    import sys
    print((solve(sys.stdin.read().strip())))
# Original solution
import sys
input = sys.stdin.readline
from collections import *

N = int(eval(input()))
l = [0, 26]

for i in range(30):
    l.append(l[-1]*26)

for i in range(len(l)):
    if N-l[i]>0:
        N -= l[i]
    else:
        keta = i
        break

ans = []
alpha = 'abcdefghijklmnopqrstuvwxyz'

for i in range(keta):
    for j in range(26):
        if N-pow(26, keta-1-i)>0:
            N -= pow(26, keta-1-i)
        else:
            ans.append(j)
            break

ans2 = []

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

print((''.join(ans2)))

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

for i in range(1, 100):
    if N<=26**i:
        ans = ''
        N -= 1
        
        for j in range(i):
            ans += chr(ord('a')+N%26)
            N //= 26
            
        break
    else:
        N -= 26**i

print((ans[::-1]))
# Original solution
N = int(eval(input()))

cnt = [0] + [26 ** i for i in range(1, 11)]
for i in range(10):
    cnt[i + 1] += cnt[i]

ans = ""
x = N - 1
for i in reversed(list(range(1, 11))):
    if x >= cnt[i]:
        v = (x - cnt[i]) // 26 ** i
        ans += chr(ord("a") + v)
        x -= (v + 1) * (26 ** i)

ans += chr(ord("a") + x % 26)
print(ans)
    

# Optimized solution
x = int(eval(input()))
ans = ""
while x > 0:
    x -= 1
    ans += chr(ord("a") + x % 26)
    x //= 26
print((ans[::-1]))
# Original solution
def colnum_string(n):
    string = ""
    while n > 0:
        n, remainder = divmod(n - 1, 26)
        string = chr(65 + remainder) + string
    return string.lower()
N = int(eval(input()))
print((colnum_string(N)))

# Optimized solution
N = int(eval(input()))
name = ''
while N>0:
    N, r = divmod(N-1, 26)
    name = chr(65+r)+name
print((name.lower()))
# Original solution
import bisect
import copy
import heapq
import sys
import itertools
import math
import queue
from functools import lru_cache
input = sys.stdin.readline
sys.setrecursionlimit(1000000)
mod = 998244353

def read_values(): return list(map(int, input().split()))
def read_index(): return [int(x) - 1 for x in input().split()]
def read_list(): return list(read_values())
def read_lists(N): return [read_list() for n in range(N)]


def to_char(a):
    return chr(a + ord("a"))

def main():
    N = int(eval(input())) - 1

    res = ""
    while N >= 26:
        res = to_char(N % 26) + res
        N //= 26
        N -= 1

    print((to_char(N) + res))


if __name__ == "__main__":
    main()



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

res = ""
while N > 0:
    r = (N - 1) % 26
    res = chr(r + 97) + res
    N -= r + 1
    N //= 26
print(res)
# Original solution
N = int(eval(input()))

res = ""
while N > 0:
    r = (N - 1) % 26
    res = chr(r + 97) + res
    N -= r + 1
    N //= 26
print(res)

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

res = ""
while N > 0:
    N -= 1
    r = N % 26
    res = chr(r + 97) + res
    N //= 26
print(res)
# Original solution
from collections import deque
def main():
    n = int(eval(input()))
    c = deque()
    while n:
        n -= 1
        c.appendleft(n % 26)
        n = n // 26
    cs = []
    for ce in c:
        ce += 97
        cec = chr(ce)
        cs.append(cec)
    print(("".join(cs)))

if __name__ == '__main__':
    main()


# Optimized solution
def main():
    n = int(eval(input()))
    nl = 0
    yokei = 0
    yokei_pre = 0
    while yokei < n:
        nl += 1
        yokei_pre = yokei
        yokei += 26 ** nl

    n -= yokei_pre
    n -= 1
    c = [0] * nl
    for i1 in range(1, nl + 1):
        r = n % 26
        c[-i1] = r
        n = n // 26
    cs = []
    for ce in c:
        ce += 97
        cec = chr(ce)
        cs.append(cec)
    print(("".join(cs)))


if __name__ == '__main__':
    main()
# Original solution
def to_n(x,n):
    ans=[]
    if x==0:
        return [0]
    while x>0:
        x-=1
        ans.append(x%n)
        x//=n
    return ans[::-1]

from sys import stdin
def main():
    #入力
    readline=stdin.readline
    n=int(readline())

    alp=[chr(i) for i in range(97,97+26)]
    m=to_n(n,26)
    ans=[alp[m[i]] for i in range(len(m))]
    print(("".join(ans)))

if __name__=="__main__":
    main()

# Optimized solution
def to_n(x,n,cnt):
    ans=[]
    for _ in range(cnt):
        ans.append(x%n)
        x//=n
    return ans[::-1]

from sys import stdin
def main():
    #入力
    readline=stdin.readline
    n=int(readline())

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

    tmp=26
    cnt=1
    while n>tmp:
        n-=tmp
        tmp*=26
        cnt+=1
    
    n-=1
    m=to_n(n,26,cnt)
    ans="".join([alp[m[i]] for i in range(len(m))])
    print(ans)

if __name__=="__main__":
    main()
# Original solution
from sys import stdin
nii=lambda:list(map(int,stdin.readline().split()))
lnii=lambda:list(map(int,stdin.readline().split()))

abc='abcdefghijklmnopqrstuvwxyz'

n=int(eval(input()))

ans=''
while n!=0:
  t_ans=n%26
  ans+=str(abc[t_ans-1])

  if abc[t_ans-1]=='z':
    n-=1

  n//=26

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

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

abc='abcdefghijklmnopqrstuvwxyz'

ans=''
while n!=0:
  q=n%26
  ans+=abc[q-1]

  if q==0:
    n-=1

  n//=26

print((ans[::-1]))
# Original solution
import sys

sys.setrecursionlimit(10 ** 8)

input = sys.stdin.readline


def main():
    N = int(eval(input()))
    Norg = N

    ans = []

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

    ans.append(N)

    ansstr = []
    for i, a in enumerate(ans[::-1]):
        ansstr.append(chr(ord("a") + a))
    print(("".join(ansstr)))

if __name__ == '__main__':
    main()


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

ans = []
while N:
    N -= 1
    ans.append(chr(ord('a') + N % 26))
    N = N // 26

print(("".join(map(str, ans[::-1]))))
# Original solution
N = int(eval(input()))

ans = []
while N:
    N -= 1
    ans.append(chr(ord('a') + N % 26))
    N = N // 26

print(("".join(map(str, ans[::-1]))))



# Optimized solution
import sys

sys.setrecursionlimit(10 ** 8)

input = sys.stdin.readline


def main():
    N = int(eval(input()))

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

    print(ans)




if __name__ == '__main__':
    main()
# Original solution
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(eval(input()))
Alpha = toString(N)
alpha = Alpha.lower()
print(alpha)
    

# Optimized solution
num = 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(num).lower()))
# Original solution
import string

cs = string.ascii_lowercase
def factor(n):
    b = 26
    ds = [n % b]
    n //= b
    while n:
        d = n % b
        ds.append(d)
        n //= b
    return ds

n = int(eval(input()))
lst = [sum(26**i for i in range(p+1)) - 1 for p in range(1, 12)]
lst = [0] + lst
for i in range(1, len(lst)):
    if n < lst[i]:
        pos = n - lst[i - 1] - 1
        fp = factor(pos)
        while len(fp) < i:
            fp.append(0)
        fp.reverse()

        print((''.join(cs[d] for d in fp)))
        break


# Optimized solution
import string

cs = string.ascii_lowercase
def factor(n):
    b = 26
    ds = [n % b]
    n //= b
    while n:
        d = n % b
        ds.append(d)
        n //= b
    return ds

n = int(eval(input()))
lst = [sum(26**i for i in range(p+1)) - 1 for p in range(1, 12)]
lst = [0] + lst
for i in range(1, len(lst)):
    if n <= lst[i]:
        pos = n - lst[i - 1] - 1
        fp = factor(pos)
        while len(fp) < i:
            fp.append(0)
        fp.reverse()

        print((''.join(cs[d] for d in fp)))
        break
# Original solution
def f(n):
    alphabets = "abcdefghijklmnopqrstuvwxyz"

    s = ""
    while n > 0:
        n, mod = divmod(n, 26)
        if mod == 0:
            s += 'z'
            n -= 1
        else:
            s += alphabets[mod - 1]
    
    return s[::-1]

print((f(int(eval(input())))))

# Optimized solution
n = int(eval(input()))
a = "abcdefghijklmnopqrstuvwxyz"
s = ""
while n > 0:
    n, m = divmod(n, 26)

    if not m:
        n -= 1

    s = a[(m - 1) % 26] + s

print(s)
# Original solution
n = int(eval(input()))
ans = []
m = ord('a') - 1
x = 0
while 26 ** x <= n:
    x += 1
while x > 0:
    x -= 1
    tmp = n // (26 ** x)
    ans.append(tmp)
    n = n - tmp * (26 ** x)
for i in range(len(ans) - 1, -1, -1):
    if ans[i] == 0:
        if i == 0:
            ans[i] = ''
            continue
        ans[i] = chr(m + 26)
        j = i - 1
        while ans[j] == 0:
            ans[j] = 25
            j -= 1
        ans[j] -= 1
    else:
        ans[i] = chr(m + ans[i])
print((''.join(ans)))

# Optimized solution
n = int(eval(input()))
ans = ''
m = ord('a') - 1
x = 0
while n != 0:
    rem = (n % (26 ** (x + 1))) // (26 ** x)
    if rem == 0:
        ans = 'z' + ans
        n -= 26 ** (x + 1)
    else:
        ans = chr(m + rem) + ans
        n -= rem * 26 ** x
    x += 1
print(ans)
# Original solution
N = int(eval(input()))
res = []
while N:
    N -= 1
    N, r = divmod(N, 26)
    res.append(chr(r + ord('a')))
res.reverse()
print((''.join(res)))


# Optimized solution
N = int(eval(input()))
mapping = 'zabcdefghijklmnopqrstuvwxy'
res = []
for i in range(1, 99):
    if N <= 26 ** i:
        for j in range(i):
            N, r = divmod(N, 26)
            res.append(mapping[r])
            if r:
                N += 1
        break
    else:
        N -= 26 ** i
res.reverse()
print((''.join(res)))
# Original solution
n = int(eval(input()))
alphabet = [chr(i) for i in range(97, 97+26)]
ans = ""
i = 0
while n - 26**i >= 0:
    n -= 26**i
    i += 1
# ここを抜けた時,iは桁数

for _ in range(i):
    q,r = divmod(n,26)
    n = q
    ans += alphabet[r]
print((ans[::-1]))




# Optimized solution
n = int(eval(input()))
alphabet = [chr(i) for i in range(97, 97+26)]
ans = ""
i = 0
# 次26**iを引いたらマイナスになるよ、というところで抜ける
while n - 26**i >= 0:
    n -= 26**i
    i += 1
# ここを抜けた時,iは桁数、nは「i桁の中でn番目」を表す

# したからk番目は、26**kで割った余り（に対応するアルファベット）
# 「上の桁で表現しきれなかった数」＝「その桁での表現」
for _ in range(i):
    q,r = divmod(n,26)
    n = q
    ans += alphabet[r]
print((ans[::-1]))
# Original solution
n=int(eval(input()))
x=1
X='abcdefghijklmnopqrstuvwxyz'
for i in range(1,100):
    if x<=n<x+26**i:
        n-=x
        cnt=i
        break
    else:
        x+=26**i
ans=''
for i in reversed(list(range(cnt))):
    ans+=X[n//(26**i)]
    n%=(26**i)
print(ans)

# Optimized solution
n=int(eval(input()))
x=1
X='abcdefghijklmnopqrstuvwxyz'
for i in range(1,100):
    if x<=n<x+26**i:
        n-=x
        cnt=i
        break
    else:
        x+=26**i
ans=''
for i in range(cnt):
    ans=ans+X[n%26]
    n//=26

print((ans[::-1]))
# Original solution
al = ["Q"] + [chr(ord('a') + i) for i in range(26)]
n = int(eval(input()))
s = ""
while n:
    if n % 26:
        a = n % 26
        n //= 26
    else:
        a = 26
        n //= 26
        n -= 1
    s += al[a]
print((s[::-1]))

# Optimized solution
al = [chr(ord('a') + i) for i in range(26)]
n = int(eval(input()))
s = ""
while n:
    s += al[n % 26 - 1]
    n = (n - 1) // 26
print((s[::-1]))
# Original solution
import string


N = int(eval(input()))
S = string.ascii_lowercase

ans = ''
if N <= 26:
    ans = S[N - 1]

else:
    while True:
        N, b = divmod(N, 26)
        ans = S[b - 1] + ans
        if b == 0:
            N -= 1

        if N <= 26:
            ans = S[N - 1] + ans
            break

print(ans)

# Optimized solution
import string
 

N = int(eval(input()))
S = string.ascii_lowercase
 
ans = ''

while N > 0:
    N, b = divmod(N - 1, 26)
    ans = S[b] + ans

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

# Optimized solution
def f(N):
    if N == 0: return ""
    N -= 1
    return f(N//26) + chr(97 + N%26)

N = int(eval(input()))
print((f(N)))
# Original solution
N = int(eval(input()))
ans = ""

while N >= 26:
    m = N % 26
    if m == 0:
        ans = chr(96 + 26) + ans
        N //= 26
        N -= 1
    else:
        ans = chr(96 + m) + ans
        N //= 26
# print(ans, N)
if N == 0:
    print(ans)
else:
    print((chr(96 + N) + ans))


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


def solve(x):
    if x == 0:
        return ""
    x -= 1
    return solve(x // 26) + chr(97 + x % 26)


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


# Optimized solution
N, ans = int(eval(input())), ''
while N > 0:
    N -= 1
    ans += chr(N % 26 + ord('a'))
    N //= 26
print((ans[::-1]))
# Original solution
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"]
 
ans=["0"]*cnt
for i in range(cnt):
    j=num%26
    num//=26
    ans[-i-1]=alp[j]

print(*ans, sep='')


# Optimized solution
n=int(input())
 
cnt=0
tmp=0
 
while n>tmp:
    cnt+=1
    tmp+=26**cnt
 
num=n-(tmp//26)

ans=["0"]*cnt

for i in range(1, cnt+1):
    j=num%26
    num//=26
    add=chr(ord("a")+j)
    ans[-i]=add

print(*ans, sep='')
# Original solution
n = int(eval(input()))
eigo = 'abcdefghijklmnopqrstuvwxyz'

keta = 1
j = 1
while n > 26**j:
    n -= 26**j
    keta += 1
    j += 1

n = n-1
ans =''

while keta != 0:
    a = n //(26**(keta-1))
    if a != 0:
        n = n -(26**(keta-1)*a)
        ans += eigo[a]
    else:
        ans+= eigo[0]
    keta -= 1

print(ans)

# Optimized solution
n = int(eval(input()))
eigo = 'abcdefghijklmnopqrstuvwxyz'

keta = 1
while n > 26**keta:
    n -= 26**keta
    keta += 1

ans =''
n = n-1
for i in range(keta):
    a =n // 26**(keta-1-i)
    ans += eigo[a]
    n = n % (26**(keta-1-i))
print(ans)
# Original solution
#!python3

import sys
iim = lambda: list(map(int, sys.stdin.readline().rstrip().split()))

def resolve():
    N = int(eval(input()))
    s = "abcdefghijklmnopqrstuvwxyz"
    ans = ""
    a = N-1
    x = 26
    i = 1
    while True:
        if a < x:
            break
        a -= x
        x *= 26
        i += 1

    while a:
        a, b = divmod(a, 26)
        ans = s[b] + ans


    print((s[0]*(i-len(ans)) + ans))

if __name__ == "__main__":
    resolve()


# Optimized solution
#!python3

import sys
iim = lambda: list(map(int, sys.stdin.readline().rstrip().split()))

def resolve():
    N = int(eval(input()))
    s = "abcdefghijklmnopqrstuvwxyz"
    ans = ""

    a = N
    while a:
        a -= 1
        a, b = divmod(a, 26)
        ans = s[b] + ans

    print(ans)

if __name__ == "__main__":
    resolve()
# Original solution
# https://atcoder.jp/contests/abc171/tasks/abc171_c

import string

numbers = string.digits                             # [0-9] をロード
abc = string.ascii_lowercase                        # [a-z] をロード
ABC = string.ascii_uppercase                        # [A-Z] をロード
characters = numbers + abc + ABC                    # [0-9] + [a-z] + [A-Z] の 62進数まで対応


def base_cvt(value, n=2, output=characters):        # n=26, output=abc で、[a-z]表示の26進数を生成可能
    try:
        tmp = int(value)
    except:
        raise ValueError('Invalid value:', value)   # 整数以外はアウト

    if n < 2 or n > len(characters):                # 62進数まで対応
        raise ValueError('Invalid n:', value)

    coef = []
    while tmp >= n:
        idx = tmp % n                               #  tmp = a_k n^k + ... a_1 n^1 + a_0 n^0 の a_0 の値を取り出す
        coef.append(idx)
        tmp = tmp // n                              # a_k n^k + ... a_1 n^1 + a_0 n^0 ⇒　a_k n^k + ... a_1 n^1　:最小桁を消去してループ
    idx = tmp % n
    coef.append(idx)                                # coef = [a_0, a_1, ... , a_k]
    res = "".join([output[x] for x in reversed(coef)])
    return res


N = int(eval(input()))

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

res = base_cvt(N, 26, abc)
l = len(res)
print(("".join(["a"] * (k - l)) + res))

# Optimized solution
# https://atcoder.jp/contests/abc171/tasks/abc171_c

import sys
input = sys.stdin.readline
import string

numbers = string.digits                             # [0-9] をロード
abc = string.ascii_lowercase                        # [a-z] をロード
ABC = string.ascii_uppercase                        # [A-Z] をロード
characters = numbers + abc + ABC                    # [0-9] + [a-z] + [A-Z] の 62進数まで対応


def base_cvt(value, n=2, output=characters):        # n=26, output=abc で、[a-z]表示の26進数を生成可能
    try:
        tmp = int(value)
    except:
        raise ValueError('Invalid value:', value)   # 整数以外はアウト

    if n < 2 or n > len(characters):                # 62進数まで対応
        raise ValueError('Invalid n:', value)

    coef = []
    while tmp >= n:
        idx = tmp % n                               #  tmp = a_k n^k + ... a_1 n^1 + a_0 n^0 の a_0 の値を取り出す
        coef.append(idx)
        tmp = tmp // n                              # a_k n^k + ... a_1 n^1 + a_0 n^0 ⇒　a_k n^k + ... a_1 n^1　:最小桁を消去してループ
    idx = tmp % n
    coef.append(idx)                                # coef = [a_0, a_1, ... , a_k]
    res = "".join([output[x] for x in reversed(coef)])
    return res

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

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

res = base_cvt(N, 26, abc)
l = len(res)
print(("".join(["a"] * (k - l)) + res))
# Original solution
import math

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

if __name__ == '__main__':
    main()

# Optimized solution
import math


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


if __name__ == '__main__':
    solve()
# Original solution
import sys
import itertools
sys.setrecursionlimit(1000000000)
from heapq import heapify,heappop,heappush,heappushpop
import math
import collections
import copy
import bisect

if __name__ == "__main__":
    n = int(eval(input()))
    a = [0]*18
    a[0] = 26
    b = 2
    alpa = ["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 range(1,18):
        a[i] = a[i-1] + 26**b
        b+=1
    d = bisect.bisect_left(a,n)
    ans = "a"*(d+1)
    n = n - a[d-1] -1
    ans = ""
    for i in range(d,-1,-1):
        if i == d:
            ans += alpa[n%(26)]
        else:
            ans += alpa[n%(26)]
        n = n//26
    ans2 = ""
    for i in range(len(ans)):
        ans2 += ans[len(ans)-i-1]
    print(ans2)

# Optimized solution
import sys
import itertools
sys.setrecursionlimit(1000000000)
from heapq import heapify,heappop,heappush,heappushpop
import math
import collections
import copy

def main():
    n = int(eval(input()))
    ans = ""
    alpa = "abcdefghijklmnopqrstuvwxyz"
    while n:
        ans += alpa[n%26-1]
        n-=1
        n//=26
    ans2 = ""
    for i in range(len(ans)):
        ans2 += ans[len(ans)-i-1]
    print(ans2)
if __name__ == "__main__":
    main()
# Original solution
def main():
    N = int(eval(input())) - 1
    digits = []

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

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


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


if __name__ == "__main__":
    main()


# Optimized solution
def main():
    N = int(eval(input()))
    ans = ''

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


if __name__ == "__main__":
    main()
# Original solution
# C - One Quadrillion and One Dalmatians
n = int(eval(input()))
dic = dict()

import string
i = 1

for s in string.ascii_lowercase:
	dic[i % 26] = s
	i += 1	

name = ''
i = 1

while True:
	mod = n % 26
	name += dic[mod]
	
	if n > 26:
		if mod == 0:
			mod = 26
		
		n = (n - mod) // 26
		i += 1
	else:
		break

print((''.join(list(reversed(name)))))

# Optimized solution
# C - One Quadrillion and One Dalmatians
def get_alphabet(mod):
	import string
	lower = string.ascii_lowercase
	
	if mod == 0 or mod == 26:
		return 'z'
	else:
		return lower[mod - 1]


n = int(eval(input()))

ans = ''

while n > 26:
	mod = n % 26
	s = get_alphabet(mod)
	ans = s + ans
	n //= 26
	
	if mod == 0:
		n -= 1
	
ans = get_alphabet(n) + ans
print(ans)
# Original solution
N = int(eval(input())) - 1
rst = ''
for i in range(1, 10 ** 15):
    if N >= 26 ** i:
        N -= 26 ** i
        continue
    for j in range(i):
        rst += chr(ord('a') + N % 26)
        N //= 26
    print((rst[::-1]))
    break

# Optimized solution
N = int(eval(input())) - 1
result = ''
for i in range(1, 10 ** 15):
    if N >= 26 ** i:
        N -= 26 ** i
        continue
    for j in range(i):
        result += chr(ord('a') + N % 26)
        N //= 26
    print((result[::-1]))
    break
# Original solution
import sys
input = sys.stdin.readline

def slove():
    n = int(eval(input()))
    ans = ""
    abc = "abcdefghijklmnopqrstuvwxyz"
    count = 0
    while n != 0:
        count += 1
        k = n % 26
        if k == 0:
            tmp = "z"
            n = n - 26 ** count
            ans = tmp + ans
     
        else:
            tmp = abc[k-1]
            n = n//26
            ans = tmp + ans
        
    print(ans)


if __name__ == "__main__":
    slove()
    

# Optimized solution
import sys
input = sys.stdin.readline

def slove():
    n = int(eval(input()))
    ans = ""
    abc = "zabcdefghijklmnopqrstuvwxy"
    count = 0
    while n != 0:
        k = n % 26
        if k == 0:
            n -= 1
        n = n // 26
        ans = abc[k] + ans
        
    print(ans)


if __name__ == "__main__":
    slove()
# Original solution
n=int(eval(input()))
ans=""
for l in range(1,15):
  if n<=26**l:
    n-=1
    for j in range(l):
      ans+=chr(ord('a')+n%26)
      n//=26
    break
  else:
    n-=26**l
    
print((ans[::-1]))
    

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

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

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

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