{-# LANGUAGE BangPatterns #-}
{-# LANGUAGE BlockArguments #-}
{-# LANGUAGE TypeApplications #-}
{-# LANGUAGE FlexibleContexts    #-}
{-# LANGUAGE FlexibleInstances   #-}


import Control.Applicative
import Control.Monad.State
import qualified Numeric as Nu
import Control.Monad.Identity
import qualified Control.Monad as CM
import qualified Data.List as L
import qualified Control.Monad.ST as ST
import qualified Data.ByteString.Char8         as BS
import qualified Data.Array as A
import qualified Data.Array.IO as AI
import qualified Data.Char as Ch
import qualified Data.Text as T
import qualified Data.Text.IO as T
import qualified Data.Array.ST as AST
import qualified Data.ByteString.Builder as BB
import qualified Data.Set                      as Set
import qualified Data.Map.Strict               as Map
import Prelude hiding (print)


------------------------------------------------------

main = do
    s <- getLine
    let a=fst$head$Nu.readHex s
        b= (Nu.showOct a "")
        c=L.group$L.sort$ b
        maxi=maximum$map fst$zip(map length c)(map head c) in putStr$unwords$words$L.intersperse ' ' $map snd$filter(\(x,y)->x==maxi)$zip(map length c)(map head c)

-------------------------------------------------------

cin::Sanao a=>IO a
cin=sanao<$>BS.getLine

type Moji= BS.ByteString

print :: Show a => a -> IO ()
print x=BS.putStrLn $ BS.pack $ show x

class Sanao a where
  sanao :: Moji -> a
  {-# MINIMAL sanao #-}

instance Sanao Moji  where
  sanao= id

instance Sanao Int where
    sanao x= case BS.readInt x of
                Nothing -> error "ここはInt"
                Just (a,_) -> a

instance Sanao Double where
    sanao x= case BS.readInt x of
                Nothing -> error "ここはDouble"
                Just (a,_) -> realToFrac a

instance Sanao [Moji] where
    sanao=BS.words

instance (Sanao a)=>Sanao [a] where
    sanao= map sanao.BS.words

instance Sanao(Int,Int) where
    sanao= (\[a, b]->(a, b)) . map sanao . BS.words

instance Sanao(Int, Int, Int) where
    sanao= (\[a, b, c]->(a, b, c)) . map sanao . BS.words

instance Sanao(Int, Int, Int, Int) where
    sanao= (\[a, b, c, d]->(a, b, c, d)) . map sanao . BS.words

instance Sanao(Double,Double) where
    sanao= (\[a, b]->(a, b)) . map sanao . BS.words

instance Sanao(Double,Double, Double) where
    sanao= (\[a, b, c]->(a, b, c)) . map sanao . BS.words

instance Sanao(Double,Double, Double, Double) where
    sanao= (\[a, b, c, d]->(a, b, c, d)) . map sanao . BS.words

instance Sanao(Moji,Int) where
    sanao= (\[a, b]->(a,sanao b)) . BS.words

instance Sanao(Moji,Int, Int) where
    sanao= (\[a, b, c]->(a,sanao b, sanao c)) . BS.words


instance Sanao(Int,Moji) where
    sanao= (\[a, b]->(sanao a,b)) . BS.words

instance Sanao(Moji,Double) where
    sanao= (\[a, b]->(a,sanao b)) . BS.words

instance Sanao(Double,Moji) where
    sanao= (\[a, b]->(sanao a,b)) . BS.words