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 Haskell (GHC 8.8.3) (judge verdict: Runtime Error)

{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE BangPatterns #-}
{-# LANGUAGE TypeFamilies #-}
import           Data.Maybe
import           Data.Int
import           Data.List
import           Data.Char
-- import qualified Data.Vector.Unboxing as VU
import qualified Data.Vector as V
import qualified Data.Vector.Mutable as VM
import qualified Data.Vector.Unboxed as VU
import qualified Data.Vector.Unboxed.Mutable as VUM
import qualified Data.ByteString.Char8 as BS
import           Data.List (scanl')
import           Data.IORef
import           Control.Monad
import           Control.Monad.ST
import           Control.Monad.State.Strict
import           Control.Monad.Primitive
import           Control.Applicative
import           Debug.Trace
import           Text.Printf

main = do
  n <- getInt
  putStrLn $ map digitToAlpha $ to26 n

to26 n = helpf n []
  where
    helpf m list
      | 26 < m = helpf (m `div` 26) ((m `mod` 26) : list)
      | otherwise = m : list

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


readInt = BS.readInt . BS.dropWhile isSpace
getVector f = VU.unfoldr f <$> BS.getLine
getIntVector = getVector readInt
getBSVector = getVector BS.uncons
getInt = readLn :: IO Int
getInt2Tuple = (\vec -> (vec VU.! 0, vec VU.! 1)) <$> getIntVector
getInt3Tuple = (\vec -> (vec VU.! 0, vec VU.! 1, vec VU.! 2)) <$> getIntVector