using System;
using System.Collections.Generic;
using System.Windows;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Atcoder
{
    public class Program
    {
        private static long mod = 1000000007;

        static void Main(string[] args)
        {
            var n = Read().Long();
            var ans = ToAlphabet(n);
            WriteRead(ans.ToLower());
        }

        static string ToAlphabet(long self)
        {
            if (self <= 0) return "";
            long n = self % 26;
            n = (n == 0) ? 26 : n;
            string s = ((char)(n + 64)).ToString();
            if (self == n) return s;
            return ToAlphabet((self - n) / 26) + s;
        }

        ///// <summary>
        ///// 数字 ⇒ Column(列・エクセル)変換 
        ///// </summary>
        ///// <param name="index"></param>
        ///// <returns></returns>
        //public static string GetColumnString(long index)
        //{
        //    string str = "";

        //    long maxDigit = GetCurDigit(index);

        //    double[] maxPow = GetMaxDigitArray();

        //    for (long i = maxDigit; i >= 0; --i)
        //    {

        //        double pow = 0.0;

        //        pow = Math.Pow(26.0, i);

        //        // 26のi乗の商を計算
        //        double quotient = Math.Floor(index / pow);

        //        if (i != 0)
        //        {
        //            if (-0.000001 <= Math.Floor(index % pow) && Math.Floor(index % pow) <= 0.000001)
        //            {
        //                quotient -= 1;
        //            }
        //            else if (quotient > 26)
        //            {
        //                quotient = 26;
        //            }
        //        }

        //        char curDigit = (char)((long)quotient + 0x40);

        //        str = str + curDigit.ToString();

        //        // 上の桁を計算したので、下の桁へ移行
        //        index = index - (long)(quotient * pow);
        //    }

        //    return str;
        //}


        ///// <summary>
        ///// 現在の桁数
        ///// </summary>
        ///// <param name="index"></param>
        ///// <returns></returns>
        //public static long GetCurDigit(long index)
        //{
        //    long maxDigit = 20;

        //    double[] maxPow = GetMaxDigitArray();
        //    double[] minPow = new double[maxDigit];

        //    // アルファベット26進の桁の最小値 計算 
        //    // ( 例. 3桁なら 26*26 + 26 + 1 = AAA )

        //    minPow[0] = 1;
        //    for (long i = 1; i < minPow.Length; ++i)
        //    {
        //        minPow[i] = maxPow[i - 1] + 1;
        //    }


        //    long curDigit = 0;

        //    // indexが26の何乗か分の桁を持っているかを計算する
        //    for (long i = 0; i < maxPow.Length - 1; ++i)
        //    {
        //        if (minPow[i] <= index && index <= maxPow[i])
        //        {
        //            curDigit = i;
        //            break;
        //        }
        //    }

        //    return curDigit;
        //}

        ///// <summary>
        ///// 最大桁の配列
        ///// </summary>
        ///// <returns></returns>
        //private static double[] GetMaxDigitArray()
        //{
        //    long maxDigit = 20;

        //    double[] maxPow = new double[maxDigit];

        //    // アルファベット26進の桁の最大値 計算 ( 例. 3桁なら 26*26*26 + 26*26 + 26 = ZZZ) 
        //    for (long i = 0; i < maxPow.Length; ++i)
        //    {
        //        maxPow[i] = Math.Pow(26.0, i + 1);

        //        for (long j = i; j > 0; --j)
        //        {
        //            maxPow[i] += Math.Pow(26.0, j);
        //        }
        //    }

        //    return maxPow;
        //}

        ///// <summary>
        ///// Column(列・エクセル) ⇒ 数字 変換 
        ///// </summary>
        ///// <param name="index"></param>
        ///// <returns></returns>
        //public static long GetColumnNumber(string str)
        //{
        //    long digit = str.Length;

        //    // 大文字に変換
        //    str = str.ToUpperInvariant();

        //    long result = 0;

        //    for (long i = 0; i < digit; ++i)
        //    {
        //        char c = Convert.ToChar(str.Substring((int)i, 1));

        //        long curDigit = c - 0x40;

        //        double pow = Math.Pow(26.0, digit - i - 1);

        //        result += curDigit * (long)pow;
        //    }

        //    return result;
        //}

        public static string Read()
        {
            return Console.ReadLine();
        }

        public static string[] ReadSplit()
        {
            return Console.ReadLine().Split(' ');
        }

        public static void WriteRead(object str)
        {
            Console.WriteLine(str);
            Read();
        }

        public static void Write(object str)
        {
            Console.WriteLine(str);
        }

        private static bool ChangeMin<T>(ref T a, T b) where T : IComparable
        {
            if (a.CompareTo(b) > 0)
            {
                a = b;
                return true;
            }
            return false;
        }

        private static bool ChangekMax<T>(ref T a, T b) where T : IComparable
        {
            if (b.CompareTo(a) > 0)
            {
                a = b;
                return true;
            }
            return false;
        }
    }
}


public static class Extentions
{
    public static int Int(this object obj)
    {
        return int.Parse(obj.ToString());
    }

    public static long Long(this object obj)
    {
        return long.Parse(obj.ToString());
    }

    public static decimal Decimal(this object obj)
    {
        return decimal.Parse(obj.ToString());
    }

    public static double Double(this object obj)
    {
        return double.Parse(obj.ToString());
    }

    public static T2 GetValueZero<T1, T2>(this Dictionary<T1, T2> d, T1 key) where T2 : struct
    {
        T2 value;
        if (d.TryGetValue(key, out value))
        {
            return value;
        }
        return new T2();
    }
}



Measured memory_bytes: 17772