Problem:
Score : 300 points

Problem Statement

1000000000000001 dogs suddenly appeared under the roof of Roger's house, all of which he decided to keep. The dogs had been numbered 1 through 1000000000000001, but he gave them new names, as follows:

the dogs numbered 1,2,\cdots,26 were respectively given the names a, b, ..., z;

the dogs numbered 27,28,29,\cdots,701,702 were respectively given the names aa, ab, ac, ..., zy, zz;

the dogs numbered 703,704,705,\cdots,18277,18278 were respectively given the names aaa, aab, aac, ..., zzy, zzz;

the dogs numbered 18279,18280,18281,\cdots,475253,475254 were respectively given the names aaaa, aaab, aaac, ..., zzzy, zzzz;

the dogs numbered 475255,475256,\cdots were respectively given the names aaaaa, aaaab, ...;

and so on.

To sum it up, the dogs numbered 1, 2, \cdots were respectively given the following names:

a, b, ..., z, aa, ab, ..., az, ba, bb, ..., bz, ..., za, zb, ..., zz, aaa, aab, ..., aaz, aba, abb, ..., abz, ..., zzz, aaaa, ...

Now, Roger asks you:

"What is the name for the dog numbered N?"

Constraints

N is an integer.

1 \leq N \leq 1000000000000001

Input

Input is given from Standard Input in the following format:

N

Output

Print the answer to Roger's question as a string consisting of lowercase English letters.

Sample Input 1

2

Sample Output 1

b

Sample Input 2

27

Sample Output 2

aa

Sample Input 3

123456789

Sample Output 3

jjddja

Solution in C# (Mono-mcs 6.8.0.105) (judge verdict: Runtime Error)

using System;
using System.Collections;
using System.Collections.Generic;
//using System.Collections.Immutable;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Numerics;
using System.Runtime.InteropServices;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading.Tasks;
using static System.Math;
//using static System.Linq.Enumerable;
using static Math2;
using static Output;
using static Utils;

public class CP
{
    Input sc;
    public void Solve()
    {
        sc = new Input();
        bool multicases = false;
        var t = multicases ? sc.Int : 1;
        // var sw = new Stopwatch();
        // sw.Start();
        while (t-- > 0)
        {
            case1();
        }
        // sw.Stop();
        //Put(sw.ElapsedMilliseconds + "ms");
    }
    public void case1()
    {
        long n = sc.Int;
        var ans = "";
        while (n > 0)
        {
            var x = n % 26;
            if (x == 0)
            {
                x = 26;
            }
            ans += (char)('a' + x - 1);
            if (x == 26)
            {
                n -= 1;
            }
            n /= 26;
        }
        Put(ans.Reverse());


    }

    public void case2()
    {
        int k = sc.Int;
        var s = sc.String;
    }
}













public static class NumberTheory
{
    public static Dictionary<long, int> PrimeFactorization(long N)
    {
        var ret = new Dictionary<long, int>();
        for (long i = 2; i * i <= N; ++i)
        {
            int cnt = 0;
            while (N % i == 0)
            {
                cnt++;
                N /= i;
            }
            if (cnt != 0) ret[i] = cnt;
        }
        if (N >= 2) ret[N] = 1;
        return ret;
    }
    public static Dictionary<int, int> FactoricalPF(int N)
    {
        var ret = new Dictionary<int, int>();
        for (int i = 2; i <= N; ++i)
        {
            int ni = i;
            for (int j = 2; j * j <= ni; ++j)
            {
                int cnt = 0;
                while (ni % j == 0)
                {
                    ++cnt;
                    ni /= j;
                }
                if (cnt == 0) continue;
                if (ret.ContainsKey(j))
                    ret[j] += cnt;
                else ret[j] = cnt;
            }
            if (ni >= 2)
            {
                if (ret.ContainsKey(ni))
                    ret[ni] += 1;
                else ret[ni] = 1;
            }
        }
        return ret;
    }
    public static List<long> DivisorEnumrate(long N)
    {
        var ret = new List<long>();
        for (long i = 1; i * i <= N; ++i)
        {
            if (N % i == 0)
            {
                ret.Add(i);
                ret.Add(N / i);
            }
        }
        return ret;
    }
    public static List<int> seive(int n)
    {
        var ret = new List<int>();
        bool[] isPrime = new bool[n + 1];
        for (int i = 1; i <= n; ++i) isPrime[i] = true;
        isPrime[1] = false;
        for (int i = 1; i <= n; ++i)
        {
            int j = i;
            if (isPrime[i]) ret.Add(i);
            else continue;
            while (j <= n)
            {
                j += i;
                if (j > n) continue;
                isPrime[j] = false;
            }
        }
        return ret;
    }
    public static bool isPrime(long n)
    {
        for (int i = 2; i * i <= n; ++i)
        {
            if (n % i == 0) return false;
        }
        return true;
    }
}
// public class LasySegmentTree<T, U>
// {
//     Func<T, T, T> F;
//     Func<T, U, T> G;
//     Func<U, U, U> H;
//     T E;
//     U I;


// }
public class PriorityQueue<T>
{
    List<T> _item;
    public int Count { get { return _item.Count; } }
    bool _isascend { get; set; }
    public T Peek { get { return _item[0]; } }
    Comparison<T> Comp;
    public PriorityQueue(bool IsAscend = true, IEnumerable<T> list = null) : this(Comparer<T>.Default.Compare, IsAscend, list) { }
    public PriorityQueue(Comparison<T> cmp, bool IsAscend = true, IEnumerable<T> list = null)
    {
        _item = new List<T>();
        _isascend = IsAscend;
        this.Comp = cmp;
        if (list != null)
        {
            _item.AddRange(list);
            Build();
        }
    }

    private int Compare(int i, int j) => (_isascend ? -1 : 1) * Comp(_item[i], _item[j]);
    private void Swap(int i, int j) { var t = _item[i]; _item[i] = _item[j]; _item[j] = t; }
    private int Parent(int i) => (i - 1) >> 1;
    private int Left(int i) => (i << 1) + 1;
    public T Enqueue(T val)
    {
        int i = _item.Count;
        _item.Add(val);
        while (i > 0)
        {
            int p = Parent(i);
            if (Compare(i, p) > 0)
                Swap(i, p);
            i = p;
        }
        return val;
    }
    private void Heapify(int index)
    {
        for (int i = index, j;
            (j = Left(i)) < _item.Count; i = j)
        {
            if (j != _item.Count - 1 && Compare(j, j + 1) < 0) j++;
            if (Compare(i, j) < 0)
                Swap(i, j);
        }
    }
    public T Dequeue()
    {
        T val = _item[0];
        _item[0] = _item[_item.Count - 1];
        _item.RemoveAt(_item.Count - 1);
        Heapify(0);
        return val;
    }
    private void Build()
    {
        for (var i = (_item.Count >> 1) - 1; i >= 0; i--)
            Heapify(i);
    }
    public bool Any() => Count > 0;
}
public class BinarySearch
{
    public static int Lower_Bound<T>(IList<T> Array, T Target)
    {
        return Lower_Bound<T>(Array, Target, Comparer<T>.Default.Compare);
    }
    public static int Lower_Bound<T>(IList<T> Array, T Target, Comparison<T> Comp)
    {
        var cmp = Comparer<T>.Create(Comp);
        var l = -1; //always ng
        var r = Array.Count(); //always ok
        while (r - l > 1)
        {
            var mid = l + (r - l) / 2;
            var res = cmp.Compare(Array[mid], Target);
            if (res >= 0) r = mid;
            else l = mid;
        }
        return r;
    }
    public static int Upper_Bound<T>(IList<T> Array, T Target)
    {
        return Upper_Bound<T>(Array, Target, Comparer<T>.Default.Compare);
    }
    public static int Upper_Bound<T>(IList<T> Array, T Target, Comparison<T> Comp)
    {
        var cmp = Comparer<T>.Create(Comp);
        var l = -1;
        var r = Array.Count;
        while (r - l > 1)
        {
            var mid = l + (r - l) / 2;
            var res = cmp.Compare(Array[mid], Target);
            if (res > 0) r = mid;
            else l = mid;
        }
        return r;
    }
    public static bool Contains<T>(IList<T> Arr, T Target)
    {
        return Contains<T>(Arr, Target, Comparer<T>.Default.Compare);
    }
    public static bool Contains<T>(IList<T> Arr, T Target, Comparison<T> Comp)
    {
        return (Upper_Bound(Arr, Target, Comp) - Lower_Bound(Arr, Target, Comp) > 0);
    }
}
public static class Math2
{
    public const int INF = 1 << 29;
    public const long INFL = 1L << 60;
    public const long MOD = 1000000007;
    public const long MOD2 = 998244353;

    public static long Power(long a, long b, long MOD = 1000000007) //i^N
    {
        long res = 1;
        while (b > 0)
        {
            if ((b & 1) != 0) res = res * a % MOD;
            a = a * a % MOD;
            b >>= 1;
        }
        return res;
    }
    public static long Power2(long a, long b) //i^N
    {
        long res = 1;
        while (b > 0)
        {
            if ((b & 1) != 0) res = res * a;
            a = a * a;
            b >>= 1;
        }
        return res;
    }
    public static long GCD(long a, long b)
    {
        if (a == 0) return b;
        while (b > 0)
        {
            var r = a % b;
            a = b;
            b = r;
        }
        return a;
    }
    public static long LCM(long a, long b) => (b / GCD(a, b)) * a;
    public static long Comb(long n, long r, int MOD = 1000000007)
    {
        if (r > n - r) r = n - r;
        long Nume = 1;
        long Deno = 1;

        if (r > n - r) r = n - r;
        for (long i = 1; i <= r; ++i)
        {
            Deno = (Deno * i) % MOD;
            Nume = Nume * (n - i + 1) % MOD;
        }
        return (Nume * inv(Deno)) % MOD;
    }
    public static long Comb2(long n, long r)
    {
        long Nume = 1;
        long Deno = 1;

        if (r > n - r) r = n - r;
        for (long i = 1; i <= r; ++i)
        {
            Deno *= i;
            Nume *= n - i + 1;
        }
        return Nume / Deno;
    }
    public static long inv(long x, int MOD = 1000000007)
    {
        return Power(x, MOD - 2, MOD);
    }
}
public static class Utils
{
    public static T[] sort<T>(this T[] a)
    {
        Array.Sort(a);
        return a;
    }
    public static int popcnt(long a)
    {
        int cnt = 0;
        while (a > 0)
        {
            if ((a & 1) == 1) ++cnt;
            a >>= 1;
        }
        return cnt;
    }
    public static void Swap<T>(ref T A, ref T B)
    {
        T x = A;
        A = B;
        B = x;
    }
    public static int DigitSum(string N)
    {

        int ret = 0;
        for (int i = 0; i < N.Length; ++i) ret += N[i] - '0';
        return ret;
    }
    public static string ConvertBase(long N, int K)
    {
        StringBuilder ret = new StringBuilder();
        while (N > 0)
        {
            var r = N % K;
            N /= K;
            ret.Append(r);
        }
        return new string(ret.ToString().ToCharArray().Reverse().ToArray());
    }
    public static bool NextPermutation<T>(IList<T> lis, Comparison<T> cmp)
    {
        int n = lis.Count;
        int i = n - 1;
        while (i - 1 >= 0)
        {
            if (cmp(lis[i - 1], lis[i]) < 0) break;
            --i;
        }
        if (i == 0) return false;
        int j = i;
        while (j + 1 < n)
        {
            if (cmp(lis[i - 1], lis[j + 1]) > 0) break;
            ++j;
        }
        var _q = lis[j];
        lis[j] = lis[i - 1];
        lis[i - 1] = _q;
        int k = i;
        int l = n - 1;
        while (k < l)
        {
            var _p = lis[k];
            lis[k] = lis[l];
            lis[l] = _p;

            ++k;
            --l;
        }
        return true;
    }
    public static bool NextPermutation<T>(IList<T> lis) => NextPermutation(lis, Comparer<T>.Default.Compare);
}
class Program
{
    static void Main(string[] args)
    {
        var CP = new CP();
        CP.Solve();
    }
}
public static class Output
{

    public static void Put(string a) => Console.WriteLine(a);
    public static void Put(params object[] i) => Put(string.Join(" ", i));
    public static void Put<T>(IEnumerable<T> a) => Put(string.Join(" ", a));
    public static void PutV<T>(IEnumerable<T> a) { foreach (var z in a) Put(z); }
    public static void YN(bool i)
    {
        if (i) Put("Yes");
        else Put("No");
    }
}
public class Input
{
    public static string Str => Console.ReadLine();
    public static bool IsTypeEqual<T, U>() => typeof(T).Equals(typeof(U));
    public static T ConvertType<T, U>(U a) => (T)Convert.ChangeType(a, typeof(T));
    public static T Cast<T>(string s)
    {
        if (IsTypeEqual<T, int>()) return ConvertType<T, int>(int.Parse(s));
        else if (IsTypeEqual<T, long>()) return ConvertType<T, long>(long.Parse(s));
        else if (IsTypeEqual<T, double>()) return ConvertType<T, double>(double.Parse(s));
        else if (IsTypeEqual<T, char>()) return ConvertType<T, char>(char.Parse(s));
        else if (IsTypeEqual<T, BigInteger>()) return ConvertType<T, BigInteger>(BigInteger.Parse(s));
        else if (IsTypeEqual<T, decimal>()) return ConvertType<T, decimal>(decimal.Parse(s));
        else return ConvertType<T, string>(s);
    }
    public static T[] Castarr<T>(string[] s)
    {

        var ret = new T[s.Length];
        int i = 0;
        if (IsTypeEqual<T, char>())
        {
            var list = new List<T>();
            foreach (var t in s)
            {
                foreach (var u in t)
                {
                    list.Add(ConvertType<T, char>(char.Parse(u.ToString())));
                }
            }
            return list.ToArray();
        }
        foreach (var t in s)
        {
            if (IsTypeEqual<T, int>()) ret[i++] = ConvertType<T, int>(int.Parse(t));
            else if (IsTypeEqual<T, long>()) ret[i++] = ConvertType<T, long>(long.Parse(t));
            else if (IsTypeEqual<T, double>()) ret[i++] = ConvertType<T, double>(double.Parse(t));
            else if (IsTypeEqual<T, BigInteger>()) ret[i++] = ConvertType<T, BigInteger>(BigInteger.Parse(t));
            else ret[i++] = ConvertType<T, string>(t);
        }
        return ret;
    }
    Queue<string> q = new Queue<string>();
    void next() { var ss = Str.Split(' '); foreach (var item in ss) q.Enqueue(item); }
    public T cin<T>() { if (!q.Any()) next(); return Cast<T>(q.Dequeue()); }
    public T[] cinarr<T>() { return Castarr<T>(Str.Split(' ')); }
    public T[] cinarr<T>(int n) { var ret = new T[n]; for (int i = 0; i < n; ++i) ret[i] = cin<T>(); return ret; }
    public int Int => cin<int>();
    public long Long => cin<long>();
    public double Double => cin<double>();
    public char Char => cin<char>();
    public string String => cin<string>();
    public BigInteger BI => cin<BigInteger>();
    public int[] Intarr => cinarr<int>();
    public long[] Longarr => cinarr<long>();
    public double[] Doublearr => cinarr<double>();
    public char[] Chararr => cinarr<char>();
    public string[] Stringarr => cinarr<string>();
    public BigInteger[] BIarr => cinarr<BigInteger>();
    public void cin<T>(out T t) { t = cin<T>(); }
    public void mul<T, U>(out T t, out U u) { t = cin<T>(); u = cin<U>(); }
    public void mul<T, U, V>(out T t, out U u, out V v) { t = cin<T>(); u = cin<U>(); v = cin<V>(); }
    public void mul<T, U, V, W>(out T t, out U u, out V v, out W w) { t = cin<T>(); u = cin<U>(); v = cin<V>(); w = cin<W>(); }
    public void mul<T, U, V, W, X>(out T t, out U u, out V v, out W w, out X x) { t = cin<T>(); u = cin<U>(); v = cin<V>(); w = cin<W>(); x = cin<X>(); }
    public void mul<T, U, V, W, X, Y>(out T t, out U u, out V v, out W w, out X x, out Y y) { t = cin<T>(); u = cin<U>(); v = cin<V>(); w = cin<W>(); x = cin<X>(); y = cin<Y>(); }
    public void mul<T, U, V, W, X, Y, Z>(out T t, out U u, out V v, out W w, out X x, out Y y, out Z z) { t = cin<T>(); u = cin<U>(); v = cin<V>(); w = cin<W>(); x = cin<X>(); y = cin<Y>(); z = cin<Z>(); }
}