import System.Environment
import qualified Data.List.Split as T
import qualified Data.List as L
import qualified Data.Map.Strict as M
import qualified Data.ByteString.Lazy as B
--import Data.ByteString.Char8 as C
import Text.Printf
import Data.Maybe
import Data.Char
import Control.Monad

main = do args<-getArgs
 --         if Prelude.length args == 0 then go encode64 
--          else when (args!!0 == "-d") $ go decode64
          go encode64
          where go f = B.getContents >>= B.putStr.B.pack.f.B.unpack

fromBase64 x  = (['A'..'Z']++['a'..'z']++['0'..'9']++['+','/']) !! x
--mapBase64     = M.fromList $ C.map (\x-> (fromBase64 x,x)) [0..63]
--binToDec      = sum . C.map (2^) . L.findIndices (=='1') . C.reverse 

encode64 x = L.map (printf "%08b") xi
             where xi=map fromIntegral x :: [Int]

--x++repeat (fromIntegral $ ord '=')

{-
encode64 x = pad64 (C.length x) . C.map (fromBase64 . binToDec) . T.chunksOf 6 . 
             C.concat . C.map (printf "%08b" ) $ x ++ cycle 0
-}

{-
decode64 x = C.map (chr . binToDec) . T.chunksOf 8 . 
             C.concat . C.map ( printf "%06b" . fromJust) . C.filter isJust . 
             C.map (flip M.lookup mapBase64) $ x
-}

{-
pad64 l = (++(C.take m ((cycle "=")))) . C.take ((l+m)*3 `div` 2 -3-m)
          where m = mod (3 - mod l 3) 3
-}