#!/usr/bin/env ruby -w

word = ARGV.first

prelude = '
(!!)             :: [a] -> Int -> a                                   ||||| [0,1,2] !! 1 = 1
($)              :: (a -> b) -> a -> b                                ||||| f x $ g y = f x (g y)
($!)             :: (a -> b) -> (a -> b)                              ||||| 
(&&)             :: Bool -> Bool -> Bool                              ||||| Boolean \'and\'
(||)             :: Bool -> Bool -> Bool                              ||||| Boolean \'or\'
(*)              :: Num a => a -> a -> a                              ||||| Multiplication
(**)             :: Floating a => a -> a -> a                         ||||| Exponentiation
(+)              :: Num a => a -> a -> a                              ||||| Addition
(++)             :: [a] -> [a] -> [a]                                 ||||| Concatonation: "abc" ++ "def" = "abcdef"
(-)              :: Num a => a -> a -> a                              ||||| Subtraction
(.)              :: (b -> c) -> (a -> b) -> a -> c                    ||||| Function composition
(/)              :: Fractional a => a -> a -> a                       ||||| Division
(/=)             :: Eq a => a -> a -> Bool                            ||||| not equal
(<)              :: Ord a => a -> a -> Bool                           ||||| Less Than
(<=)             :: Ord a => a -> a -> Bool                           ||||| Less Than or Equal To
(==)             :: Eq a => a -> a -> Bool                            ||||| Equality
(=<<)            :: Monad a => (a -> m b) -> m a -> m b               ||||| Monadic binding
(>)              :: Ord a => a -> a -> Bool                           ||||| Greater Than
(>=)             :: Ord a => a -> a -> Bool                           ||||| Greater Than or Equal To
(>>)             :: Monad m => m a -> m b -> m b                      ||||| Monadic binding
(>>=)            :: Monad m => m a -> (a -> m b) -> m b               ||||| Monadic binding
(^)              :: (Num a, Integral b) => a -> b -> a                ||||| Exponentiation
(^^)             :: (Fractional a, Integral b) => a -> b -> a         ||||| negative exponent allowed
abs              :: Num a => a -> a                                   ||||| Absolute Value
acos             :: Floating a => a -> a                              ||||| Arccosine
acosh            :: Floating a => a -> a                              ||||| Hyperbolic Arccosine
all              :: (a -> Bool) -> [a] -> Bool                        ||||| all (/= \'a\') "cba" = False
and              :: [Bool] -> Bool                                    ||||| and [True, True, True] = True
any              :: (a -> Bool) -> [a] -> Bool                        ||||| any (== \'c\') "abc" = True
appendFile       :: FilePath -> String -> IO ()                       ||||| Appends String to FilePath
applyM           :: Monad m => (a -> m b) -> m a -> m b               ||||| 
asTypeOf         :: a -> a -> a                                       ||||| Sort of a type cast
asin             :: Floating a => a -> a                              ||||| Arcsine
asinh            :: Floating a => a -> a                              ||||| Hyperbolic Arcsine
atan             :: Floating a => a -> a                              ||||| Arctangent
atan2            :: RealFrac a => a -> a                              ||||| ArcTangent
atanh            :: Floating a => a -> a                              ||||| Hyperbolic Arctangent
break            :: (a -> Bool) -> [a] -> ([a], [a])                  ||||| break (<2) [1,2,3] = ([1],[2,3])
catch            :: IO a -> (IOError -> IO a) -> IO a                 |||||
ceiling          :: (RealFrac a, Integral b) => a -> b                |||||
compare          :: Ord a => a -> a -> Ordering                       |||||
concat           :: MonadPlus m => [m a] -> m a                       ||||| concat ["a","bc","d"] = "abcd"
concatMap        :: (a -> [b]) -> [a] -> [b]                          |||||
const            :: a -> b -> a                                       |||||
cos              :: Floating a => a -> a                              |||||
cosh             :: Floating a => a -> a                              |||||
curry            :: ((a, b) -> c) -> a -> b -> c                      |||||
cycle            :: [a] -> [a]                                        ||||| cycle "abc" = "abcabcabc...
decodeFloat      :: RealFloat a => a -> (Integer, Int)                |||||
div              :: Integral a => a -> a -> a                         |||||
divMod           :: Integral a => a -> a -> (a, a)                    |||||
drop             :: Int -> [a] -> [a]                                 ||||| drop 2 "abcd" = "cd"
dropWhile        :: (a -> Bool) -> [a] -> [a]                         ||||| dropWhile (>3) [5,3,5] = [3,5]
elem             :: Eq a => a -> [a] -> Bool                          ||||| \'a\' \'elem\' "abc" = True
encodeFloat      :: RealFloat a => Integer -> Int -> a                |||||
enumFrom         :: Enum a => a -> [a]                                ||||| [n..]
enumFromThen     :: Enum a => a -> a -> [a]                           ||||| [m,n..]
enumFromThenTo   :: Enum a => a -> a -> a -> [a]                      ||||| [m,n..o]
enumFromTo       :: Enum a => a -> a -> [a]                           ||||| [m..n]
error            :: String -> a                                       ||||| 
even             :: Integral a => a -> Bool                           |||||
exp              :: Floating a => a -> a                              |||||
exponent         :: RealFloat a => a -> Int                           |||||
fail             :: Monad m => String -> m a                          |||||
filter           :: (a -> Bool) -> [a] -> [a]                         |||||
flip             :: (a -> b -> c) -> (b -> a -> c)                    |||||
floatDigits      :: RealFloat a => a -> Int                           |||||
floatRadix       :: RealFloat a => a -> Integer                       |||||
floatRange       :: RealFloat a => a -> (Int, Int)                    |||||
floor            :: (RealFrac a, Integral b) => a -> b                |||||
fmap             :: Functor f => (a -> b) -> f a -> f b               |||||
foldl            :: (a -> b -> a) -> a -> [b] -> a                    ||||| foldl (+) 0 [a,b,c] = ((0+a)+b)+c
foldl1           :: (a -> a -> a) -> [a] -> a                         ||||| foldl1 (+) [a,b,c] = (a+b)+c
foldr            :: (a -> b -> b) -> b -> [a] -> b                    ||||| foldr (+) 0 [a,b,c] = a+(b+(c+0))
foldr1           :: (a -> a -> a) -> [a] -> a                         ||||| foldr1 (+) [a,b,c] = a+(b+c)
fromEnum         :: Enum a => a -> Int                                |||||
fromInteger      :: Num a => Integer -> a                             |||||
fromIntegral     :: (Integral a, Num b) => a -> b                     |||||
fromRational     :: Fractional a => Rational -> a                     |||||
fst              :: (a, b) -> a                                       |||||
gcd              :: (Integral a) => a -> a -> a                       |||||
getChar          :: IO Char                                           ||||| eof generates an IOError
getContents      :: IO String                                         |||||
getLine          :: IO String                                         ||||| eof generates an IOError
head             :: [a] -> a                                          |||||
id               :: a -> a                                            |||||
init             :: [a] -> [a]                                        ||||| init "abcd" = "abc"
interact         :: (String -> String) -> IO ()                       |||||
ioError          :: IOError -> IO a                                   |||||
isDenormalized   :: RealFloat a => a -> Bool                          |||||
isIEEE           :: RealFloat a => a -> Bool                          |||||
isInfinite       :: RealFloat a => a -> Bool                          |||||
isNaN            :: RealFloat a => a -> Bool                          |||||
isNegativeZero   :: RealFloat a => a -> Bool                          |||||
iterate          :: (a -> a) -> a -> [a]                              ||||| iterate (++ " ") "" = ["", " ", "  ",...]
last             :: [a] -> a                                          ||||| last "abcde" = "e"
lcm              :: Integral a => a -> a -> a                         |||||
length           :: [a] -> Int                                        ||||| length "Abc" = 3
lex              :: ReadS String                                      ||||| lex "abc def" = [("abc"," def")]
lines            :: String -> [String]                                |||||
log              :: Floating a => a -> a                              |||||
logBase          :: Floating a => a -> a -> a                         |||||
lookup           :: Eq a => a -> [(a, b)] -> Maybe b                  |||||
map              :: (a -> b) -> [a] -> [b]                            |||||
mapM             :: Monad m => (a -> m b) -> [a] -> m [b]             |||||
mapM_            :: Monad m => (a -> m b) -> [a] -> m ()              |||||
max              :: Ord a => a -> a -> a                              |||||
maxBound         :: Bounded a => a                                    |||||
maximum          :: Ord a => [a] -> a                                 |||||
maybe            :: b -> (a -> b) -> Maybe a -> b                     ||||| maybe 0 (+1) (Just 1) = 2
min              :: Ord a => a -> a -> a                              |||||
minBound         :: Bounded a => a                                    |||||
minimum          :: Ord a => [a] -> a                                 |||||
mod              :: Integral a => a -> a -> a                         |||||
negate           :: Num a => a -> a                                   |||||
not              :: Bool -> Bool                                      |||||
notElem          :: Eq a => a -> [a] -> Bool                          |||||
null             :: [a] -> Bool                                       |||||
odd              :: Integral a => a -> Bool                           |||||
or               :: [Bool] -> Bool                                    |||||
otherwise        :: Bool                                              |||||
pi               :: Floating a => a                                   |||||
pred             :: Enum a => a -> a                                  ||||| pred True = False
print            :: Show a => IO ()                                   ||||| adds a newline
product          :: Num a => [a] -> a                                 |||||
properFraction   :: (RealFrac a, Integral b) => a -> (b, a)           |||||
putChar          :: Char -> IO ()                                     |||||
putStr           :: String -> IO ()                                   |||||
putStrLn         :: String -> IO ()                                   ||||| adds a newline
quot             :: Integral a => a -> a -> a                         |||||
quotRem          :: Integral a => a -> a -> (a, a)                    |||||
read             :: Read a => String -> a                             |||||
readFile         :: FilePath -> IO String                             |||||
readIO           :: Read a => String -> IO a                          ||||| fails with IOError
readList         :: Read a => ReadS [a]                               |||||
readLn           :: Read a => IO a                                    |||||
readParen        :: Bool -> ReadS a -> ReadS a                        |||||
reads            :: Read a => ReadS a                                 ||||| reads "1 2" :: [(Int,String)] = [(1," 2")]
readsPrec        :: Read a => Int -> ReadS a                          |||||
realToFrac       :: (Real a, Fractional b) => a -> b                  |||||
recip            :: Fractional a => a -> a                            |||||
rem              :: Integral a => a -> a -> a                         |||||
repeat           :: a -> [a]                                          ||||| repeat \'a\' = "aaaaaaaaa..."
replicate        :: Int -> a -> [a]                                   ||||| replicate 4 \'a\' = "aaaa"
return           :: Monad m => a -> m a                               |||||
reverse          :: [a] -> [a]                                        ||||| reverse "abc" = "cba"
round            :: (RealFrac a, Integral b) => a -> b                |||||
scaleFloat       :: RealFloat a => Int -> a -> a                      |||||
scanl            :: (a -> b -> a) -> a -> [b] -> [a]                  ||||| scanl (+) 0 [1,2,3] = [0,1,3,6]
scanl1           :: (a -> a -> a) -> [a] -> [a]                       ||||| scanl1 (+) [1,2,3] = [1,3,6]
scanr            :: (a -> b -> b) -> b -> [a] -> [b]                  ||||| scanr (+) 0 [1,2,3] = [6,5,3,0]
scanr1           :: (a -> a -> a) -> [a] -> [a]                       ||||| scanr1 (+) [1,2,3] = [6,5,3]
seq              :: a -> b -> b                                       |||||
sequence         :: Monad m => [m a] -> m [a]                         |||||
sequence_        :: Monad m => [m a] -> m ()                          ||||| do operations in sequence
show             :: Show a => a -> String                             ||||| 
showChar         :: Char -> ShowS                                     |||||
showList         :: Show a => [a] -> ShowS                            |||||
showParen        :: Bool -> ShowS -> ShowS                            |||||
showString       :: String -> ShowS                                   |||||
shows            :: Show a => a -> ShowS                              ||||| 
showsPrec        :: Show a => Int -> a -> ShowS                       ||||| 
significand      :: RealFloat a => a -> a                             |||||
signum           :: Num a => a -> a                                   |||||
sin              :: Floating a => a -> a                              |||||
sinh             :: Floating a => a -> a                              |||||
snd              :: (a, b) -> b                                       |||||
span             :: (a -> Bool) -> [a] -> ([a], [a])                  ||||| span isAlpha "ab cd" = ("ab"," cd")
splitAt          :: Int -> [a] -> ([a], [a])                          ||||| splitAt 2 "abcdef" = ("ab","cdef")
sqrt             :: Floating a => a -> a                              |||||
subtract         :: Num a => a -> a -> a                              |||||
succ             :: Enum a => a -> a                                  ||||| succ False = True
sum              :: Num a => [a] -> a                                 ||||| sum [1,2,3] = 6
tail             :: [a] -> [a]                                        ||||| tail "abc" = "bc"
take             :: Int -> [a] -> [a]                                 ||||| take 3 "abcde" = "abc"
takeWhile        :: (a -> Bool) -> [a] -> [a]                         ||||| takeWhile (> 2) [3,2,1] = [3]
tan              :: Floating a => a -> a                              |||||
tanh             :: Floating a => a -> a                              |||||
toEnum           :: Enum a => Int -> a                                ||||| toEnum 0 :: Bool = False
toInteger        :: Integral a => a -> Integer                        |||||
toRational       :: Real a => a -> Rational                           |||||
truncate         :: (RealFrac a, Integral b) => a -> b                |||||
uncurry          :: (a -> b -> c) -> ((a, b) -> c)                    |||||
undefined        :: a                                                 ||||| 
unlines          :: [String] -> String                                |||||
until            :: (a -> Bool) -> (a -> a) -> a -> a                 ||||| until (> 3) (+ 2) 0 = 4
unwords          :: [String] -> String                                |||||
unzip            :: [(a, b)] -> ([a], [b])                            ||||| unzip [(\'a\',\'b\'),(\'c\',\'d\')] = ("ac",bd")
unzip3           :: [(a, b, c)] -> ([a], [b], [c])                    |||||
userError        :: String  -> IOError                                |||||
words            :: String -> [String]                                ||||| words "ab d as+3" = ["ab","d","as+3"]
writeFile        :: FilePath -> String -> IO ()                       |||||
zip              :: [a] -> [b] -> [(a, b)]                            ||||| zip "abc" "de" = [(\'a\',\'d\'), (\'b\',e\')]
zip3             :: [a] -> [b] -> [c] -> [(a, b, c)]                  |||||
zipWith          :: (a -> b -> c) -> [a] -> [b] -> [c]                ||||| zipWith (+) [1,2] [3,4] = [4,6]
zipWith3         :: (a -> b -> c -> d) -> [a] -> [b] -> [c] -> [d]    |||||'

lookup = prelude.strip.split("\n").inject(Hash.new) { |h,l|   
  name, desc = l.split("::")
  h[name.strip] = desc.split("|||||").map {|a| a.strip}
  h
}

if lookup[word]
  puts lookup[word]
else
  STDIN.each do |line|
    name, desc = line.strip.split("::")
    if name and desc
      if name.split(",").map{|s| s.strip}.include?(word)
        puts desc.strip
        exit
      end
    end
  end
  puts "☿ It is a mystery ☿"
end
