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# (.NET Core 3.1.201) (judge verdict: Accepted)

using System;
using System.Globalization;
using System.IO;
using System.Runtime.CompilerServices;
using System.Text;
using static Scanner;

class Solver
{
    static void Main(string[] args) {
        Console.SetOut(new StreamWriter(Console.OpenStandardOutput()) { AutoFlush = false });
        Solve(new Cin<int>(), new Cin<long>(), new Cin<double>(), new Cin<string>());
        Console.Out.Flush();
    }

    static void Solve(Cin<int> ScanInt, Cin<long> ScanLong, Cin<double> ScanDouble, Cin<string> ScanStr) {
        long N = ScanLong;
        var sb = new StringBuilder();
        while (N > 0) {
            var n = N % 26 == 0 ? 26 : N % 26;
            sb.Insert(0, (char) (n + 'a' - 1));
            N = (N - n) / 26;
        }
        Console.WriteLine(sb.ToString());
    }
}

public readonly struct Cin<T>
{
    [MethodImpl(256)]
    public static implicit operator T(in Cin<T> _) => Scan<T>();
    [MethodImpl(256)]
    public T[] Array(int l) {
        var array = new T[l];
        for (int i = 0; i < array.Length; i++) array[i] = Scan<T>();
        return array;
    }
    [MethodImpl(256)]
    public T[,] Array2D(int x, int y) {
        var array = new T[x, y];
        for (int i = 0; i < x; ++i) for (int j = 0; j < x; ++j) array[i, j] = Scan<T>();
        return array;
    }
}

public class Scanner
{
    const int BUFFER_SIZE = 1024, CHAR_BEGIN = 33, CHAR_END = 126, CHAR_ZERO = 48, CHAR_NINE = 57;
    static readonly Stream stdin;
    static readonly byte[] buffer;
    static int size, p;
    static bool isEof;
    static Scanner() {
        stdin = Console.OpenStandardInput();
        buffer = new byte[BUFFER_SIZE];
    }
    [MethodImpl(256)]
    private static byte Read() {
        if (isEof) return default;
        if (p < size) return buffer[p++];
        p = 0;
        if ((size = stdin.Read(buffer, 0, BUFFER_SIZE)) > 0) return buffer[p++];
        isEof = true;
        return 0;
    }
    [MethodImpl(256)]
    private static char Next() {
        byte b;
        do b = Read();
        while (!(CHAR_BEGIN <= b && b <= CHAR_END));
        return (char) b;
    }
    [MethodImpl(256)]
    private static string Str() {
        var sb = new StringBuilder();
        for (var c = Next(); CHAR_BEGIN <= c && c <= CHAR_END; c = (char) Read()) {
            sb.Append(c);
        }
        return sb.ToString();
    }
    [MethodImpl(256)]
    private static int Int() {
        int temp = 0;
        for (var c = Next(); CHAR_ZERO <= c && c <= CHAR_NINE; c = (char) Read()) {
            temp = temp * 10 + c - CHAR_ZERO;
        }
        return temp;
    }
    [MethodImpl(256)]
    private static long Long() {
        long temp = 0;
        for (var c = Next(); CHAR_ZERO <= c && c <= CHAR_NINE; c = (char) Read()) {
            temp = temp * 10 + c - CHAR_ZERO;
        }
        return temp;
    }
    [MethodImpl(256)]
    private static double Double() => double.Parse(Str(), CultureInfo.InvariantCulture);
    [MethodImpl(256)]
    public static string ScanStrLine() {
        var sb = new StringBuilder();
        for (var c = Next(); c != '\n' && c != 0; c = (char) Read()) if (c != '\r') sb.Append(c);
        return sb.ToString();
    }
    [MethodImpl(256)]
    public static T Scan<T>() {
        if (typeof(T) == typeof(int)) {
            var i = Int();
            return Unsafe.As<int, T>(ref i);
        }
        if (typeof(T) == typeof(long)) {
            var l = Long();
            return Unsafe.As<long, T>(ref l);
        }
        if (typeof(T) == typeof(string)) {
            var s = Str();
            return Unsafe.As<string, T>(ref s);
        }
        if (typeof(T) == typeof(double)) {
            var d = Double();
            return Unsafe.As<double, T>(ref d);
        }
        return default;
    }
}