base-exports.stdout-mingw32

  -- Safety: Safe
  type BOOL :: *
  type BOOL = GHC.Types.Bool
  type BYTE :: *
  type BYTE = GHC.Internal.Word.Word8
  type DDWORD :: *
  type DDWORD = GHC.Internal.Word.Word64
  type DWORD :: *
  type DWORD = GHC.Internal.Word.Word32
  type ErrCode :: *
  type ErrCode = DWORD
  type HANDLE :: *
  type HANDLE = GHC.Internal.Ptr.Ptr ()
  type LPBOOL :: *
  type LPBOOL = GHC.Internal.Ptr.Ptr BOOL
  type LPCSTR :: *
  type LPCSTR = LPSTR
  type LPCTSTR :: *
  type LPCTSTR = LPTSTR
  type LPCWSTR :: *
  type LPCWSTR = LPWSTR
  type LPDWORD :: *
  type LPDWORD = GHC.Internal.Ptr.Ptr DWORD
  type LPSTR :: *
  type LPSTR = GHC.Internal.Ptr.Ptr GHC.Internal.Foreign.C.Types.CChar
  type LPTSTR :: *
  type LPTSTR = LPWSTR
  type LPVOID :: *
  type LPVOID = GHC.Internal.Ptr.Ptr ()
  type LPWSTR :: *
  type LPWSTR = GHC.Internal.Ptr.Ptr GHC.Internal.Foreign.C.Types.CWchar
  type NTSTATUS :: *
  type NTSTATUS = GHC.Internal.Int.Int32
  type UCHAR :: *
  type UCHAR = GHC.Internal.Word.Word8
  type UINT :: *
  type UINT = GHC.Internal.Word.Word32
  type ULONG :: *
  type ULONG = GHC.Internal.Word.Word32
  type WORD :: *
  type WORD = GHC.Internal.Word.Word16
  c_maperrno :: GHC.Types.IO ()
  c_maperrno_func :: ErrCode -> GHC.Internal.Foreign.C.Error.Errno
  ddwordToDwords :: DDWORD -> (DWORD, DWORD)
  dwordsToDdword :: (DWORD, DWORD) -> DDWORD
  errCodeToIOError :: GHC.Internal.Base.String -> ErrCode -> GHC.Types.IO GHC.Internal.IO.Exception.IOError
  failIf :: forall a. (a -> GHC.Types.Bool) -> GHC.Internal.Base.String -> GHC.Types.IO a -> GHC.Types.IO a
  failIfFalse_ :: GHC.Internal.Base.String -> GHC.Types.IO GHC.Types.Bool -> GHC.Types.IO ()
  failIfNull :: forall a. GHC.Internal.Base.String -> GHC.Types.IO (GHC.Internal.Ptr.Ptr a) -> GHC.Types.IO (GHC.Internal.Ptr.Ptr a)
  failIfZero :: forall a. (GHC.Classes.Eq a, GHC.Internal.Num.Num a) => GHC.Internal.Base.String -> GHC.Types.IO a -> GHC.Types.IO a
  failIf_ :: forall a. (a -> GHC.Types.Bool) -> GHC.Internal.Base.String -> GHC.Types.IO a -> GHC.Types.IO ()
  failUnlessSuccess :: GHC.Internal.Base.String -> GHC.Types.IO ErrCode -> GHC.Types.IO ()
  failUnlessSuccessOr :: ErrCode -> GHC.Internal.Base.String -> GHC.Types.IO ErrCode -> GHC.Types.IO GHC.Types.Bool
  failWith :: forall a. GHC.Internal.Base.String -> ErrCode -> GHC.Types.IO a
  getErrorMessage :: ErrCode -> GHC.Types.IO GHC.Internal.Base.String
  getLastError :: GHC.Types.IO ErrCode
  iNFINITE :: DWORD
  iNVALID_HANDLE_VALUE :: HANDLE
  nullHANDLE :: HANDLE
  throwGetLastError :: forall a. GHC.Internal.Base.String -> GHC.Types.IO a

module GHC.Word where
  -- Safety: Safe
  type Word :: *
  data Word = W# GHC.Prim.Word#
  type Word16 :: *
  data Word16 = W16# GHC.Prim.Word16#
  type Word32 :: *
  data Word32 = W32# GHC.Prim.Word32#
  type Word64 :: *
  data Word64 = W64# GHC.Prim.Word64#
  type Word8 :: *
  data Word8 = W8# GHC.Prim.Word8#
  bitReverse16 :: Word16 -> Word16
  bitReverse32 :: Word32 -> Word32
  bitReverse64 :: Word64 -> Word64
  bitReverse8 :: Word8 -> Word8
  byteSwap16 :: Word16 -> Word16
  byteSwap32 :: Word32 -> Word32
  byteSwap64 :: Word64 -> Word64
  eqWord :: Word -> Word -> GHC.Types.Bool
  eqWord16 :: Word16 -> Word16 -> GHC.Types.Bool
  eqWord32 :: Word32 -> Word32 -> GHC.Types.Bool
  eqWord64 :: Word64 -> Word64 -> GHC.Types.Bool
  eqWord8 :: Word8 -> Word8 -> GHC.Types.Bool
  geWord :: Word -> Word -> GHC.Types.Bool
  geWord16 :: Word16 -> Word16 -> GHC.Types.Bool
  geWord32 :: Word32 -> Word32 -> GHC.Types.Bool
  geWord64 :: Word64 -> Word64 -> GHC.Types.Bool
  geWord8 :: Word8 -> Word8 -> GHC.Types.Bool
  gtWord :: Word -> Word -> GHC.Types.Bool
  gtWord16 :: Word16 -> Word16 -> GHC.Types.Bool
  gtWord32 :: Word32 -> Word32 -> GHC.Types.Bool
  gtWord64 :: Word64 -> Word64 -> GHC.Types.Bool
  gtWord8 :: Word8 -> Word8 -> GHC.Types.Bool
  leWord :: Word -> Word -> GHC.Types.Bool
  leWord16 :: Word16 -> Word16 -> GHC.Types.Bool
  leWord32 :: Word32 -> Word32 -> GHC.Types.Bool
  leWord64 :: Word64 -> Word64 -> GHC.Types.Bool
  leWord8 :: Word8 -> Word8 -> GHC.Types.Bool
  ltWord :: Word -> Word -> GHC.Types.Bool
  ltWord16 :: Word16 -> Word16 -> GHC.Types.Bool
  ltWord32 :: Word32 -> Word32 -> GHC.Types.Bool
  ltWord64 :: Word64 -> Word64 -> GHC.Types.Bool
  ltWord8 :: Word8 -> Word8 -> GHC.Types.Bool
  neWord :: Word -> Word -> GHC.Types.Bool
  neWord16 :: Word16 -> Word16 -> GHC.Types.Bool
  neWord32 :: Word32 -> Word32 -> GHC.Types.Bool
  neWord64 :: Word64 -> Word64 -> GHC.Types.Bool
  neWord8 :: Word8 -> Word8 -> GHC.Types.Bool
  uncheckedShiftL64# :: GHC.Prim.Word64# -> GHC.Prim.Int# -> GHC.Prim.Word64#
  uncheckedShiftRL64# :: GHC.Prim.Word64# -> GHC.Prim.Int# -> GHC.Prim.Word64#

module Numeric where
  -- Safety: Safe
  type Floating :: * -> Constraint
  class GHC.Internal.Real.Fractional a => Floating a where
    pi :: a
    exp :: a -> a
    log :: a -> a
    sqrt :: a -> a
    (**) :: a -> a -> a
    logBase :: a -> a -> a
    sin :: a -> a
    cos :: a -> a
    tan :: a -> a
    asin :: a -> a
    acos :: a -> a
    atan :: a -> a
    sinh :: a -> a
    cosh :: a -> a
    tanh :: a -> a
    asinh :: a -> a
    acosh :: a -> a
    atanh :: a -> a
    log1p :: a -> a
    expm1 :: a -> a
    log1pexp :: a -> a
    log1mexp :: a -> a
    {-# MINIMAL pi, exp, log, sin, cos, asin, acos, atan, sinh, cosh, asinh, acosh, atanh #-}
  floatToDigits :: forall a. GHC.Internal.Float.RealFloat a => GHC.Num.Integer.Integer -> a -> ([GHC.Types.Int], GHC.Types.Int)
  fromRat :: forall a. GHC.Internal.Float.RealFloat a => GHC.Internal.Real.Rational -> a
  lexDigits :: GHC.Internal.Text.ParserCombinators.ReadP.ReadS GHC.Internal.Base.String
  readBin :: forall a. (GHC.Classes.Eq a, GHC.Internal.Num.Num a) => GHC.Internal.Text.ParserCombinators.ReadP.ReadS a
  readDec :: forall a. (GHC.Classes.Eq a, GHC.Internal.Num.Num a) => GHC.Internal.Text.ParserCombinators.ReadP.ReadS a
  readFloat :: forall a. GHC.Internal.Real.RealFrac a => GHC.Internal.Text.ParserCombinators.ReadP.ReadS a
  readHex :: forall a. (GHC.Classes.Eq a, GHC.Internal.Num.Num a) => GHC.Internal.Text.ParserCombinators.ReadP.ReadS a
  readInt :: forall a. GHC.Internal.Num.Num a => a -> (GHC.Types.Char -> GHC.Types.Bool) -> (GHC.Types.Char -> GHC.Types.Int) -> GHC.Internal.Text.ParserCombinators.ReadP.ReadS a
  readOct :: forall a. (GHC.Classes.Eq a, GHC.Internal.Num.Num a) => GHC.Internal.Text.ParserCombinators.ReadP.ReadS a
  readSigned :: forall a. GHC.Internal.Real.Real a => GHC.Internal.Text.ParserCombinators.ReadP.ReadS a -> GHC.Internal.Text.ParserCombinators.ReadP.ReadS a
  showBin :: forall a. GHC.Internal.Real.Integral a => a -> GHC.Internal.Show.ShowS
  showEFloat :: forall a. GHC.Internal.Float.RealFloat a => GHC.Internal.Maybe.Maybe GHC.Types.Int -> a -> GHC.Internal.Show.ShowS
  showFFloat :: forall a. GHC.Internal.Float.RealFloat a => GHC.Internal.Maybe.Maybe GHC.Types.Int -> a -> GHC.Internal.Show.ShowS
  showFFloatAlt :: forall a. GHC.Internal.Float.RealFloat a => GHC.Internal.Maybe.Maybe GHC.Types.Int -> a -> GHC.Internal.Show.ShowS
  showFloat :: forall a. GHC.Internal.Float.RealFloat a => a -> GHC.Internal.Show.ShowS
  showGFloat :: forall a. GHC.Internal.Float.RealFloat a => GHC.Internal.Maybe.Maybe GHC.Types.Int -> a -> GHC.Internal.Show.ShowS
  showGFloatAlt :: forall a. GHC.Internal.Float.RealFloat a => GHC.Internal.Maybe.Maybe GHC.Types.Int -> a -> GHC.Internal.Show.ShowS
  showHFloat :: forall a. GHC.Internal.Float.RealFloat a => a -> GHC.Internal.Show.ShowS
  showHex :: forall a. GHC.Internal.Real.Integral a => a -> GHC.Internal.Show.ShowS
  showInt :: forall a. GHC.Internal.Real.Integral a => a -> GHC.Internal.Show.ShowS
  showIntAtBase :: forall a. GHC.Internal.Real.Integral a => a -> (GHC.Types.Int -> GHC.Types.Char) -> a -> GHC.Internal.Show.ShowS
  showOct :: forall a. GHC.Internal.Real.Integral a => a -> GHC.Internal.Show.ShowS
  showSigned :: forall a. GHC.Internal.Real.Real a => (a -> GHC.Internal.Show.ShowS) -> GHC.Types.Int -> a -> GHC.Internal.Show.ShowS

module Numeric.Natural where
  -- Safety: Safe
  type Natural :: *
  data Natural = ...
  minusNaturalMaybe :: Natural -> Natural -> GHC.Internal.Maybe.Maybe Natural

module Prelude where
  -- Safety: Trustworthy
  (!!) :: forall a. GHC.Internal.Stack.Types.HasCallStack => [a] -> Int -> a
  ($) :: forall (repa :: GHC.Types.RuntimeRep) (repb :: GHC.Types.RuntimeRep) (a :: TYPE repa) (b :: TYPE repb). (a -> b) -> a -> b
  ($!) :: forall (r :: GHC.Types.RuntimeRep) a (b :: TYPE r). (a -> b) -> a -> b
  (&&) :: Bool -> Bool -> Bool
  (++) :: forall a. [a] -> [a] -> [a]
  (.) :: forall b c a. (b -> c) -> (a -> b) -> a -> c
  (<$>) :: forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
  (=<<) :: forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
  type Applicative :: (* -> *) -> Constraint
  class Functor f => Applicative f where
    pure :: forall a. a -> f a
    (<*>) :: forall a b. f (a -> b) -> f a -> f b
    liftA2 :: forall a b c. (a -> b -> c) -> f a -> f b -> f c
    (*>) :: forall a b. f a -> f b -> f b
    (<*) :: forall a b. f a -> f b -> f a
    {-# MINIMAL pure, ((<*>) | liftA2) #-}
  type Bool :: *
  data Bool = False | True
  type Bounded :: * -> Constraint
  class Bounded a where
    minBound :: a
    maxBound :: a
    {-# MINIMAL minBound, maxBound #-}
  type Char :: *
  data Char = ...
  type Double :: *
  data Double = ...
  type Either :: * -> * -> *
  data Either a b = Left a | Right b
  type Enum :: * -> Constraint
  class Enum a where
    succ :: a -> a
    pred :: a -> a
    toEnum :: Int -> a
    fromEnum :: a -> Int
    enumFrom :: a -> [a]
    enumFromThen :: a -> a -> [a]
    enumFromTo :: a -> a -> [a]
    enumFromThenTo :: a -> a -> a -> [a]
    {-# MINIMAL toEnum, fromEnum #-}
  type Eq :: * -> Constraint
  class Eq a where
    (==) :: a -> a -> Bool
    (/=) :: a -> a -> Bool
    {-# MINIMAL (==) | (/=) #-}
  type FilePath :: *
  type FilePath = String
  type Float :: *
  data Float = ...
  type Floating :: * -> Constraint
  class Fractional a => Floating a where
    pi :: a
    exp :: a -> a
    log :: a -> a
    sqrt :: a -> a
    (**) :: a -> a -> a
    logBase :: a -> a -> a
    sin :: a -> a
    cos :: a -> a
    tan :: a -> a
    asin :: a -> a
    acos :: a -> a
    atan :: a -> a
    sinh :: a -> a
    cosh :: a -> a
    tanh :: a -> a
    asinh :: a -> a
    acosh :: a -> a
    atanh :: a -> a
    ...
    {-# MINIMAL pi, exp, log, sin, cos, asin, acos, atan, sinh, cosh, asinh, acosh, atanh #-}
  type Foldable :: (* -> *) -> Constraint
  class Foldable t where
    ...
    foldMap :: forall m a. Monoid m => (a -> m) -> t a -> m
    ...
    foldr :: forall a b. (a -> b -> b) -> b -> t a -> b
    ...
    foldl :: forall b a. (b -> a -> b) -> b -> t a -> b
    foldl' :: forall b a. (b -> a -> b) -> b -> t a -> b
    foldr1 :: forall a. (a -> a -> a) -> t a -> a
    foldl1 :: forall a. (a -> a -> a) -> t a -> a
    ...
    null :: forall a. t a -> Bool
    length :: forall a. t a -> Int
    elem :: forall a. Eq a => a -> t a -> Bool
    maximum :: forall a. Ord a => t a -> a
    minimum :: forall a. Ord a => t a -> a
    sum :: forall a. Num a => t a -> a
    product :: forall a. Num a => t a -> a
    {-# MINIMAL foldMap | foldr #-}
  type Fractional :: * -> Constraint
  class Num a => Fractional a where
    (/) :: a -> a -> a
    recip :: a -> a
    fromRational :: Rational -> a
    {-# MINIMAL fromRational, (recip | (/)) #-}
  type Functor :: (* -> *) -> Constraint
  class Functor f where
    fmap :: forall a b. (a -> b) -> f a -> f b
    (<$) :: forall a b. a -> f b -> f a
    {-# MINIMAL fmap #-}
  type IO :: * -> *
  newtype IO a = ...
  type IOError :: *
  type IOError = GHC.Internal.IO.Exception.IOException
  type Int :: *
  data Int = ...
  type Integer :: *
  data Integer = ...
  type Integral :: * -> Constraint
  class (Real a, Enum a) => Integral a where
    quot :: a -> a -> a
    rem :: a -> a -> a
    div :: a -> a -> a
    mod :: a -> a -> a
    quotRem :: a -> a -> (a, a)
    divMod :: a -> a -> (a, a)
    toInteger :: a -> Integer
    {-# MINIMAL quotRem, toInteger #-}
  type Maybe :: * -> *
  data Maybe a = Nothing | Just a
  type Monad :: (* -> *) -> Constraint
  class Applicative m => Monad m where
    (>>=) :: forall a b. m a -> (a -> m b) -> m b
    (>>) :: forall a b. m a -> m b -> m b
    return :: forall a. a -> m a
    {-# MINIMAL (>>=) #-}
  type MonadFail :: (* -> *) -> Constraint
  class Monad m => MonadFail m where
    fail :: forall a. String -> m a
    {-# MINIMAL fail #-}
  type Monoid :: * -> Constraint
  class Semigroup a => Monoid a where
    mempty :: a
    mappend :: a -> a -> a
    mconcat :: [a] -> a
    {-# MINIMAL mempty | mconcat #-}
  type Num :: * -> Constraint
  class Num a where
    (+) :: a -> a -> a
    (-) :: a -> a -> a
    (*) :: a -> a -> a
    negate :: a -> a
    abs :: a -> a
    signum :: a -> a
    fromInteger :: Integer -> a
    {-# MINIMAL (+), (*), abs, signum, fromInteger, (negate | (-)) #-}
  type Ord :: * -> Constraint
  class Eq a => Ord a where
    compare :: a -> a -> Ordering
    (<) :: a -> a -> Bool
    (<=) :: a -> a -> Bool
    (>) :: a -> a -> Bool
    (>=) :: a -> a -> Bool
    max :: a -> a -> a
    min :: a -> a -> a
    {-# MINIMAL compare | (<=) #-}
  type Ordering :: *
  data Ordering = LT | EQ | GT
  type Rational :: *
  type Rational = GHC.Internal.Real.Ratio Integer
  type Read :: * -> Constraint
  class Read a where
    readsPrec :: Int -> ReadS a
    readList :: ReadS [a]
    ...
    {-# MINIMAL readsPrec | GHC.Internal.Read.readPrec #-}
  type ReadS :: * -> *
  type ReadS a = String -> [(a, String)]
  type Real :: * -> Constraint
  class (Num a, Ord a) => Real a where
    toRational :: a -> Rational
    {-# MINIMAL toRational #-}
  type RealFloat :: * -> Constraint
  class (RealFrac a, Floating a) => RealFloat a where
    floatRadix :: a -> Integer
    floatDigits :: a -> Int
    floatRange :: a -> (Int, Int)
    decodeFloat :: a -> (Integer, Int)
    encodeFloat :: Integer -> Int -> a
    exponent :: a -> Int
    significand :: a -> a
    scaleFloat :: Int -> a -> a
    isNaN :: a -> Bool
    isInfinite :: a -> Bool
    isDenormalized :: a -> Bool
    isNegativeZero :: a -> Bool
    isIEEE :: a -> Bool
    atan2 :: a -> a -> a
    {-# MINIMAL floatRadix, floatDigits, floatRange, decodeFloat, encodeFloat, isNaN, isInfinite, isDenormalized, isNegativeZero, isIEEE #-}
  type RealFrac :: * -> Constraint
  class (Real a, Fractional a) => RealFrac a where
    properFraction :: forall b. Integral b => a -> (b, a)
    truncate :: forall b. Integral b => a -> b
    round :: forall b. Integral b => a -> b
    ceiling :: forall b. Integral b => a -> b
    floor :: forall b. Integral b => a -> b
    {-# MINIMAL properFraction #-}
  type Semigroup :: * -> Constraint
  class Semigroup a where
    (<>) :: a -> a -> a
    ...
    {-# MINIMAL (<>) | GHC.Internal.Base.sconcat #-}
  type Show :: * -> Constraint
  class Show a where
    showsPrec :: Int -> a -> ShowS
    show :: a -> String
    showList :: [a] -> ShowS
    {-# MINIMAL showsPrec | show #-}
  type ShowS :: *
  type ShowS = String -> String
  type String :: *
  type String = [Char]
  type Traversable :: (* -> *) -> Constraint
  class (Functor t, Foldable t) => Traversable t where
    traverse :: forall (f :: * -> *) a b. Applicative f => (a -> f b) -> t a -> f (t b)
    sequenceA :: forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a)
    mapM :: forall (m :: * -> *) a b. Monad m => (a -> m b) -> t a -> m (t b)
    sequence :: forall (m :: * -> *) a. Monad m => t (m a) -> m (t a)
    {-# MINIMAL traverse | sequenceA #-}
  type Word :: *
  data Word = ...
  (^) :: forall a b. (Num a, Integral b) => a -> b -> a
  (^^) :: forall a b. (Fractional a, Integral b) => a -> b -> a
  all :: forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
  and :: forall (t :: * -> *). Foldable t => t Bool -> Bool
  any :: forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
  appendFile :: FilePath -> String -> IO ()
  asTypeOf :: forall a. a -> a -> a
  break :: forall a. (a -> Bool) -> [a] -> ([a], [a])
  concat :: forall (t :: * -> *) a. Foldable t => t [a] -> [a]
  concatMap :: forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
  const :: forall a b. a -> b -> a
  curry :: forall a b c. ((a, b) -> c) -> a -> b -> c
  cycle :: forall a. GHC.Internal.Stack.Types.HasCallStack => [a] -> [a]
  drop :: forall a. Int -> [a] -> [a]
  dropWhile :: forall a. (a -> Bool) -> [a] -> [a]
  either :: forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
  error :: forall (r :: GHC.Types.RuntimeRep) (a :: TYPE r). GHC.Internal.Stack.Types.HasCallStack => [Char] -> a
  errorWithoutStackTrace :: forall (r :: GHC.Types.RuntimeRep) (a :: TYPE r). [Char] -> a
  even :: forall a. Integral a => a -> Bool
  filter :: forall a. (a -> Bool) -> [a] -> [a]
  flip :: forall a b c. (a -> b -> c) -> b -> a -> c
  fromIntegral :: forall a b. (Integral a, Num b) => a -> b
  fst :: forall a b. (a, b) -> a
  gcd :: forall a. Integral a => a -> a -> a
  getChar :: IO Char
  getContents :: IO String
  getLine :: IO String
  head :: forall a. GHC.Internal.Stack.Types.HasCallStack => [a] -> a
  id :: forall a. a -> a
  init :: forall a. GHC.Internal.Stack.Types.HasCallStack => [a] -> [a]
  interact :: (String -> String) -> IO ()
  ioError :: forall a. IOError -> IO a
  iterate :: forall a. (a -> a) -> a -> [a]
  last :: forall a. GHC.Internal.Stack.Types.HasCallStack => [a] -> a
  lcm :: forall a. Integral a => a -> a -> a
  lex :: ReadS String
  lines :: String -> [String]
  lookup :: forall a b. Eq a => a -> [(a, b)] -> Maybe b
  map :: forall a b. (a -> b) -> [a] -> [b]
  mapM_ :: forall (t :: * -> *) (m :: * -> *) a b. (Foldable t, Monad m) => (a -> m b) -> t a -> m ()
  maybe :: forall b a. b -> (a -> b) -> Maybe a -> b
  not :: Bool -> Bool
  notElem :: forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
  odd :: forall a. Integral a => a -> Bool
  or :: forall (t :: * -> *). Foldable t => t Bool -> Bool
  otherwise :: Bool
  print :: forall a. Show a => a -> IO ()
  putChar :: Char -> IO ()
  putStr :: String -> IO ()
  putStrLn :: String -> IO ()
  read :: forall a. Read a => String -> a
  readFile :: FilePath -> IO String
  readIO :: forall a. Read a => String -> IO a
  readLn :: forall a. Read a => IO a
  readParen :: forall a. Bool -> ReadS a -> ReadS a
  reads :: forall a. Read a => ReadS a
  realToFrac :: forall a b. (Real a, Fractional b) => a -> b
  repeat :: forall a. a -> [a]
  replicate :: forall a. Int -> a -> [a]
  reverse :: forall a. [a] -> [a]
  scanl :: forall b a. (b -> a -> b) -> b -> [a] -> [b]
  scanl1 :: forall a. (a -> a -> a) -> [a] -> [a]
  scanr :: forall a b. (a -> b -> b) -> b -> [a] -> [b]
  scanr1 :: forall a. (a -> a -> a) -> [a] -> [a]
  seq :: forall {r :: GHC.Types.RuntimeRep} a (b :: TYPE r). a -> b -> b
  sequence_ :: forall (t :: * -> *) (m :: * -> *) a. (Foldable t, Monad m) => t (m a) -> m ()
  showChar :: Char -> ShowS
  showParen :: Bool -> ShowS -> ShowS
  showString :: String -> ShowS
  shows :: forall a. Show a => a -> ShowS
  snd :: forall a b. (a, b) -> b
  span :: forall a. (a -> Bool) -> [a] -> ([a], [a])
  splitAt :: forall a. Int -> [a] -> ([a], [a])
  subtract :: forall a. Num a => a -> a -> a
  tail :: forall a. GHC.Internal.Stack.Types.HasCallStack => [a] -> [a]
  take :: forall a. Int -> [a] -> [a]
  takeWhile :: forall a. (a -> Bool) -> [a] -> [a]
  uncurry :: forall a b c. (a -> b -> c) -> (a, b) -> c
  undefined :: forall (r :: GHC.Types.RuntimeRep) (a :: TYPE r). GHC.Internal.Stack.Types.HasCallStack => a
  unlines :: [String] -> String
  until :: forall a. (a -> Bool) -> (a -> a) -> a -> a
  unwords :: [String] -> String
  unzip :: forall a b. [(a, b)] -> ([a], [b])
  unzip3 :: forall a b c. [(a, b, c)] -> ([a], [b], [c])
  userError :: String -> IOError
  words :: String -> [String]
  writeFile :: FilePath -> String -> IO ()
  zip :: forall a b. [a] -> [b] -> [(a, b)]
  zip3 :: forall a b c. [a] -> [b] -> [c] -> [(a, b, c)]
  zipWith :: forall a b c. (a -> b -> c) -> [a] -> [b] -> [c]
  zipWith3 :: forall a b c d. (a -> b -> c -> d) -> [a] -> [b] -> [c] -> [d]
  (||) :: Bool -> Bool -> Bool
  type (~) :: forall k. k -> k -> Constraint
  class (a ~ b) => (~) a b
    {-# MINIMAL #-}

module System.CPUTime where
  -- Safety: Trustworthy
  cpuTimePrecision :: GHC.Num.Integer.Integer
  getCPUTime :: GHC.Types.IO GHC.Num.Integer.Integer

module System.Console.GetOpt where
  -- Safety: Safe
  type ArgDescr :: * -> *
  data ArgDescr a = NoArg a | ReqArg (GHC.Internal.Base.String -> a) GHC.Internal.Base.String | OptArg (GHC.Internal.Maybe.Maybe GHC.Internal.Base.String -> a) GHC.Internal.Base.String
  type ArgOrder :: * -> *
  data ArgOrder a = RequireOrder | Permute | ReturnInOrder (GHC.Internal.Base.String -> a)
  type OptDescr :: * -> *
  data OptDescr a = Option [GHC.Types.Char] [GHC.Internal.Base.String] (ArgDescr a) GHC.Internal.Base.String
  getOpt :: forall a. ArgOrder a -> [OptDescr a] -> [GHC.Internal.Base.String] -> ([a], [GHC.Internal.Base.String], [GHC.Internal.Base.String])
  getOpt' :: forall a. ArgOrder a -> [OptDescr a] -> [GHC.Internal.Base.String] -> ([a], [GHC.Internal.Base.String], [GHC.Internal.Base.String], [GHC.Internal.Base.String])
  usageInfo :: forall a. GHC.Internal.Base.String -> [OptDescr a] -> GHC.Internal.Base.String

module System.Environment where
  -- Safety: Safe
  executablePath :: GHC.Internal.Maybe.Maybe (GHC.Types.IO (GHC.Internal.Maybe.Maybe GHC.Internal.IO.FilePath))
  getArgs :: GHC.Types.IO [GHC.Internal.Base.String]
  getEnv :: GHC.Internal.Base.String -> GHC.Types.IO GHC.Internal.Base.String
  getEnvironment :: GHC.Types.IO [(GHC.Internal.Base.String, GHC.Internal.Base.String)]
  getExecutablePath :: GHC.Types.IO GHC.Internal.IO.FilePath
  getProgName :: GHC.Types.IO GHC.Internal.Base.String
  lookupEnv :: GHC.Internal.Base.String -> GHC.Types.IO (GHC.Internal.Maybe.Maybe GHC.Internal.Base.String)
  setEnv :: GHC.Internal.Base.String -> GHC.Internal.Base.String -> GHC.Types.IO ()
  unsetEnv :: GHC.Internal.Base.String -> GHC.Types.IO ()
  withArgs :: forall a. [GHC.Internal.Base.String] -> GHC.Types.IO a -> GHC.Types.IO a
  withProgName :: forall a. GHC.Internal.Base.String -> GHC.Types.IO a -> GHC.Types.IO a

module System.Environment.Blank where
  -- Safety: Safe
  getArgs :: GHC.Types.IO [GHC.Internal.Base.String]
  getEnv :: GHC.Internal.Base.String -> GHC.Types.IO (GHC.Internal.Maybe.Maybe GHC.Internal.Base.String)
  getEnvDefault :: GHC.Internal.Base.String -> GHC.Internal.Base.String -> GHC.Types.IO GHC.Internal.Base.String
  getEnvironment :: GHC.Types.IO [(GHC.Internal.Base.String, GHC.Internal.Base.String)]
  getExecutablePath :: GHC.Types.IO GHC.Internal.IO.FilePath
  getProgName :: GHC.Types.IO GHC.Internal.Base.String
  setEnv :: GHC.Internal.Base.String -> GHC.Internal.Base.String -> GHC.Types.Bool -> GHC.Types.IO ()
  unsetEnv :: GHC.Internal.Base.String -> GHC.Types.IO ()
  withArgs :: forall a. [GHC.Internal.Base.String] -> GHC.Types.IO a -> GHC.Types.IO a
  withProgName :: forall a. GHC.Internal.Base.String -> GHC.Types.IO a -> GHC.Types.IO a

module System.Exit where
  -- Safety: Safe
  type ExitCode :: *
  data ExitCode = ExitSuccess | ExitFailure GHC.Types.Int
  die :: forall a. GHC.Internal.Base.String -> GHC.Types.IO a
  exitFailure :: forall a. GHC.Types.IO a
  exitSuccess :: forall a. GHC.Types.IO a
  exitWith :: forall a. ExitCode -> GHC.Types.IO a

module System.IO where
  -- Safety: Safe
  type BufferMode :: *
  data BufferMode = NoBuffering | LineBuffering | BlockBuffering (GHC.Internal.Maybe.Maybe GHC.Types.Int)
  type FilePath :: *
  type FilePath = GHC.Internal.Base.String
  type Handle :: *
  data Handle = ...
  type HandlePosn :: *
  data HandlePosn = ...
  type IO :: * -> *
  newtype IO a = ...
  type IOMode :: *
  data IOMode = ReadMode | WriteMode | AppendMode | ReadWriteMode
  type Newline :: *
  data Newline = LF | CRLF
  type NewlineMode :: *
  data NewlineMode = NewlineMode {inputNL :: Newline, outputNL :: Newline}
  type SeekMode :: *
  data SeekMode = AbsoluteSeek | RelativeSeek | SeekFromEnd
  type TextEncoding :: *
  data TextEncoding = ...
  appendFile :: FilePath -> GHC.Internal.Base.String -> IO ()
  char8 :: TextEncoding
  fixIO :: forall a. (a -> IO a) -> IO a
  getChar :: IO GHC.Types.Char
  getContents :: IO GHC.Internal.Base.String
  getContents' :: IO GHC.Internal.Base.String
  getLine :: IO GHC.Internal.Base.String
  hClose :: Handle -> IO ()
  hFileSize :: Handle -> IO GHC.Num.Integer.Integer
  hFlush :: Handle -> IO ()
  hGetBuf :: forall a. Handle -> GHC.Internal.Ptr.Ptr a -> GHC.Types.Int -> IO GHC.Types.Int
  hGetBufNonBlocking :: forall a. Handle -> GHC.Internal.Ptr.Ptr a -> GHC.Types.Int -> IO GHC.Types.Int
  hGetBufSome :: forall a. Handle -> GHC.Internal.Ptr.Ptr a -> GHC.Types.Int -> IO GHC.Types.Int
  hGetBuffering :: Handle -> IO BufferMode
  hGetChar :: Handle -> IO GHC.Types.Char
  hGetContents :: Handle -> IO GHC.Internal.Base.String
  hGetContents' :: Handle -> IO GHC.Internal.Base.String
  hGetEcho :: Handle -> IO GHC.Types.Bool
  hGetEncoding :: Handle -> IO (GHC.Internal.Maybe.Maybe TextEncoding)
  hGetLine :: Handle -> IO GHC.Internal.Base.String
  hGetPosn :: Handle -> IO HandlePosn
  hIsClosed :: Handle -> IO GHC.Types.Bool
  hIsEOF :: Handle -> IO GHC.Types.Bool
  hIsOpen :: Handle -> IO GHC.Types.Bool
  hIsReadable :: Handle -> IO GHC.Types.Bool
  hIsSeekable :: Handle -> IO GHC.Types.Bool
  hIsTerminalDevice :: Handle -> IO GHC.Types.Bool
  hIsWritable :: Handle -> IO GHC.Types.Bool
  hLookAhead :: Handle -> IO GHC.Types.Char
  hPrint :: forall a. GHC.Internal.Show.Show a => Handle -> a -> IO ()
  hPutBuf :: forall a. Handle -> GHC.Internal.Ptr.Ptr a -> GHC.Types.Int -> IO ()
  hPutBufNonBlocking :: forall a. Handle -> GHC.Internal.Ptr.Ptr a -> GHC.Types.Int -> IO GHC.Types.Int
  hPutChar :: Handle -> GHC.Types.Char -> IO ()
  hPutStr :: Handle -> GHC.Internal.Base.String -> IO ()
  hPutStrLn :: Handle -> GHC.Internal.Base.String -> IO ()
  hReady :: Handle -> IO GHC.Types.Bool
  hSeek :: Handle -> SeekMode -> GHC.Num.Integer.Integer -> IO ()
  hSetBinaryMode :: Handle -> GHC.Types.Bool -> IO ()
  hSetBuffering :: Handle -> BufferMode -> IO ()
  hSetEcho :: Handle -> GHC.Types.Bool -> IO ()
  hSetEncoding :: Handle -> TextEncoding -> IO ()
  hSetFileSize :: Handle -> GHC.Num.Integer.Integer -> IO ()
  hSetNewlineMode :: Handle -> NewlineMode -> IO ()
  hSetPosn :: HandlePosn -> IO ()
  hShow :: Handle -> IO GHC.Internal.Base.String
  hTell :: Handle -> IO GHC.Num.Integer.Integer
  hWaitForInput :: Handle -> GHC.Types.Int -> IO GHC.Types.Bool
  interact :: (GHC.Internal.Base.String -> GHC.Internal.Base.String) -> IO ()
  isEOF :: IO GHC.Types.Bool
  latin1 :: TextEncoding
  localeEncoding :: TextEncoding
  mkTextEncoding :: GHC.Internal.Base.String -> IO TextEncoding
  nativeNewline :: Newline
  nativeNewlineMode :: NewlineMode
  noNewlineTranslation :: NewlineMode
  openBinaryFile :: FilePath -> IOMode -> IO Handle
  openBinaryTempFile :: FilePath -> GHC.Internal.Base.String -> IO (FilePath, Handle)
  openBinaryTempFileWithDefaultPermissions :: FilePath -> GHC.Internal.Base.String -> IO (FilePath, Handle)
  openFile :: FilePath -> IOMode -> IO Handle
  openTempFile :: FilePath -> GHC.Internal.Base.String -> IO (FilePath, Handle)
  openTempFileWithDefaultPermissions :: FilePath -> GHC.Internal.Base.String -> IO (FilePath, Handle)
  print :: forall a. GHC.Internal.Show.Show a => a -> IO ()
  putChar :: GHC.Types.Char -> IO ()
  putStr :: GHC.Internal.Base.String -> IO ()
  putStrLn :: GHC.Internal.Base.String -> IO ()
  readFile :: FilePath -> IO GHC.Internal.Base.String
  readFile' :: FilePath -> IO GHC.Internal.Base.String
  readIO :: forall a. GHC.Internal.Read.Read a => GHC.Internal.Base.String -> IO a
  readLn :: forall a. GHC.Internal.Read.Read a => IO a
  stderr :: Handle
  stdin :: Handle
  stdout :: Handle
  universalNewlineMode :: NewlineMode
  utf16 :: TextEncoding
  utf16be :: TextEncoding
  utf16le :: TextEncoding
  utf32 :: TextEncoding
  utf32be :: TextEncoding
  utf32le :: TextEncoding
  utf8 :: TextEncoding
  utf8_bom :: TextEncoding
  withBinaryFile :: forall r. FilePath -> IOMode -> (Handle -> IO r) -> IO r
  withFile :: forall r. FilePath -> IOMode -> (Handle -> IO r) -> IO r
  writeFile :: FilePath -> GHC.Internal.Base.String -> IO ()

module System.IO.Error where
  -- Safety: Safe
  type IOError :: *
  type IOError = GHC.Internal.IO.Exception.IOException
  type IOErrorType :: *
  data IOErrorType = ...
  alreadyExistsErrorType :: IOErrorType
  alreadyInUseErrorType :: IOErrorType
  annotateIOError :: IOError -> GHC.Internal.Base.String -> GHC.Internal.Maybe.Maybe GHC.Internal.IO.Handle.Types.Handle -> GHC.Internal.Maybe.Maybe GHC.Internal.IO.FilePath -> IOError
  catchIOError :: forall a. GHC.Types.IO a -> (IOError -> GHC.Types.IO a) -> GHC.Types.IO a
  doesNotExistErrorType :: IOErrorType
  eofErrorType :: IOErrorType
  fullErrorType :: IOErrorType
  illegalOperationErrorType :: IOErrorType
  ioError :: forall a. IOError -> GHC.Types.IO a
  ioeGetErrorString :: IOError -> GHC.Internal.Base.String
  ioeGetErrorType :: IOError -> IOErrorType
  ioeGetFileName :: IOError -> GHC.Internal.Maybe.Maybe GHC.Internal.IO.FilePath
  ioeGetHandle :: IOError -> GHC.Internal.Maybe.Maybe GHC.Internal.IO.Handle.Types.Handle
  ioeGetLocation :: IOError -> GHC.Internal.Base.String
  ioeSetErrorString :: IOError -> GHC.Internal.Base.String -> IOError
  ioeSetErrorType :: IOError -> IOErrorType -> IOError
  ioeSetFileName :: IOError -> GHC.Internal.IO.FilePath -> IOError
  ioeSetHandle :: IOError -> GHC.Internal.IO.Handle.Types.Handle -> IOError
  ioeSetLocation :: IOError -> GHC.Internal.Base.String -> IOError
  isAlreadyExistsError :: IOError -> GHC.Types.Bool
  isAlreadyExistsErrorType :: IOErrorType -> GHC.Types.Bool
  isAlreadyInUseError :: IOError -> GHC.Types.Bool
  isAlreadyInUseErrorType :: IOErrorType -> GHC.Types.Bool
  isDoesNotExistError :: IOError -> GHC.Types.Bool
  isDoesNotExistErrorType :: IOErrorType -> GHC.Types.Bool
  isEOFError :: IOError -> GHC.Types.Bool
  isEOFErrorType :: IOErrorType -> GHC.Types.Bool
  isFullError :: IOError -> GHC.Types.Bool
  isFullErrorType :: IOErrorType -> GHC.Types.Bool
  isIllegalOperation :: IOError -> GHC.Types.Bool
  isIllegalOperationErrorType :: IOErrorType -> GHC.Types.Bool
  isPermissionError :: IOError -> GHC.Types.Bool
  isPermissionErrorType :: IOErrorType -> GHC.Types.Bool
  isResourceVanishedError :: IOError -> GHC.Types.Bool
  isResourceVanishedErrorType :: IOErrorType -> GHC.Types.Bool
  isUserError :: IOError -> GHC.Types.Bool
  isUserErrorType :: IOErrorType -> GHC.Types.Bool
  mkIOError :: IOErrorType -> GHC.Internal.Base.String -> GHC.Internal.Maybe.Maybe GHC.Internal.IO.Handle.Types.Handle -> GHC.Internal.Maybe.Maybe GHC.Internal.IO.FilePath -> IOError
  modifyIOError :: forall a. (IOError -> IOError) -> GHC.Types.IO a -> GHC.Types.IO a
  permissionErrorType :: IOErrorType
  resourceVanishedErrorType :: IOErrorType
  tryIOError :: forall a. GHC.Types.IO a -> GHC.Types.IO (GHC.Internal.Data.Either.Either IOError a)
  userError :: GHC.Internal.Base.String -> IOError
  userErrorType :: IOErrorType

module System.IO.Unsafe where
  -- Safety: Unsafe
  unsafeDupablePerformIO :: forall a. GHC.Types.IO a -> a
  unsafeFixIO :: forall a. (a -> GHC.Types.IO a) -> GHC.Types.IO a
  unsafeInterleaveIO :: forall a. GHC.Types.IO a -> GHC.Types.IO a
  unsafePerformIO :: forall a. GHC.Types.IO a -> a

module System.Info where
  -- Safety: Safe
  arch :: GHC.Internal.Base.String
  compilerName :: GHC.Internal.Base.String
  compilerVersion :: GHC.Internal.Data.Version.Version
  fullCompilerVersion :: GHC.Internal.Data.Version.Version
  os :: GHC.Internal.Base.String

module System.Mem where
  -- Safety: Safe
  disableAllocationLimit :: GHC.Types.IO ()
  enableAllocationLimit :: GHC.Types.IO ()
  getAllocationCounter :: GHC.Types.IO GHC.Internal.Int.Int64
  performBlockingMajorGC :: GHC.Types.IO ()
  performGC :: GHC.Types.IO ()
  performMajorGC :: GHC.Types.IO ()
  performMinorGC :: GHC.Types.IO ()
  setAllocationCounter :: GHC.Internal.Int.Int64 -> GHC.Types.IO ()

module System.Mem.StableName where
  -- Safety: Safe
  type role StableName phantom
  type StableName :: * -> *
  data StableName a = ...
  eqStableName :: forall a b. StableName a -> StableName b -> GHC.Types.Bool
  hashStableName :: forall a. StableName a -> GHC.Types.Int
  makeStableName :: forall a. a -> GHC.Types.IO (StableName a)

module System.Mem.Weak where
  -- Safety: Trustworthy
  type Weak :: * -> *
  data Weak v = ...
  addFinalizer :: forall key. key -> GHC.Types.IO () -> GHC.Types.IO ()
  deRefWeak :: forall v. Weak v -> GHC.Types.IO (GHC.Internal.Maybe.Maybe v)
  finalize :: forall v. Weak v -> GHC.Types.IO ()
  getFinalizerExceptionHandler :: GHC.Types.IO (GHC.Internal.Exception.Type.SomeException -> GHC.Types.IO ())
  mkWeak :: forall k v. k -> v -> GHC.Internal.Maybe.Maybe (GHC.Types.IO ()) -> GHC.Types.IO (Weak v)
  mkWeakPair :: forall k v. k -> v -> GHC.Internal.Maybe.Maybe (GHC.Types.IO ()) -> GHC.Types.IO (Weak (k, v))
  mkWeakPtr :: forall k. k -> GHC.Internal.Maybe.Maybe (GHC.Types.IO ()) -> GHC.Types.IO (Weak k)
  printToHandleFinalizerExceptionHandler :: GHC.Internal.IO.Handle.Types.Handle -> GHC.Internal.Exception.Type.SomeException -> GHC.Types.IO ()
  setFinalizerExceptionHandler :: (GHC.Internal.Exception.Type.SomeException -> GHC.Types.IO ()) -> GHC.Types.IO ()

module System.Posix.Internals where
  -- Safety: Safe
  type CFLock :: *
  data CFLock
  type CFilePath :: *
  type CFilePath = GHC.Internal.Foreign.C.String.CWString
  type CGroup :: *
  data CGroup
  type CLconv :: *
  data CLconv
  type CPasswd :: *
  data CPasswd
  type CSigaction :: *
  data CSigaction
  type CSigset :: *
  data CSigset
  type CStat :: *
  data CStat
  type CTermios :: *
  data CTermios
  type CTm :: *
  data CTm
  type CTms :: *
  data CTms
  type CUtimbuf :: *
  data CUtimbuf
  type CUtsname :: *
  data CUtsname
  type FD :: *
  type FD = GHC.Internal.Foreign.C.Types.CInt
  c_access :: GHC.Internal.Foreign.C.String.Encoding.CString -> GHC.Internal.Foreign.C.Types.CInt -> GHC.Types.IO GHC.Internal.Foreign.C.Types.CInt
  c_chmod :: GHC.Internal.Foreign.C.String.Encoding.CString -> GHC.Internal.System.Posix.Types.CMode -> GHC.Types.IO GHC.Internal.Foreign.C.Types.CInt
  c_close :: GHC.Internal.Foreign.C.Types.CInt -> GHC.Types.IO GHC.Internal.Foreign.C.Types.CInt
  c_creat :: GHC.Internal.Foreign.C.String.Encoding.CString -> GHC.Internal.System.Posix.Types.CMode -> GHC.Types.IO GHC.Internal.Foreign.C.Types.CInt
  c_dup :: GHC.Internal.Foreign.C.Types.CInt -> GHC.Types.IO GHC.Internal.Foreign.C.Types.CInt
  c_dup2 :: GHC.Internal.Foreign.C.Types.CInt -> GHC.Internal.Foreign.C.Types.CInt -> GHC.Types.IO GHC.Internal.Foreign.C.Types.CInt
  c_fstat :: GHC.Internal.Foreign.C.Types.CInt -> GHC.Internal.Ptr.Ptr CStat -> GHC.Types.IO GHC.Internal.Foreign.C.Types.CInt
  c_ftruncate :: GHC.Internal.Foreign.C.Types.CInt -> GHC.Internal.System.Posix.Types.COff -> GHC.Types.IO GHC.Internal.Foreign.C.Types.CInt
  c_getpid :: GHC.Types.IO GHC.Internal.System.Posix.Types.CPid
  c_interruptible_open :: CFilePath -> GHC.Internal.Foreign.C.Types.CInt -> GHC.Internal.System.Posix.Types.CMode -> GHC.Types.IO GHC.Internal.Foreign.C.Types.CInt
  c_interruptible_open_ :: CFilePath -> GHC.Internal.Foreign.C.Types.CInt -> GHC.Internal.System.Posix.Types.CMode -> GHC.Types.IO GHC.Internal.Foreign.C.Types.CInt
  c_isatty :: GHC.Internal.Foreign.C.Types.CInt -> GHC.Types.IO GHC.Internal.Foreign.C.Types.CInt
  c_lseek :: GHC.Internal.Foreign.C.Types.CInt -> GHC.Internal.Int.Int64 -> GHC.Internal.Foreign.C.Types.CInt -> GHC.Types.IO GHC.Internal.Int.Int64
  c_open :: CFilePath -> GHC.Internal.Foreign.C.Types.CInt -> GHC.Internal.System.Posix.Types.CMode -> GHC.Types.IO GHC.Internal.Foreign.C.Types.CInt
  c_pipe :: GHC.Internal.Ptr.Ptr GHC.Internal.Foreign.C.Types.CInt -> GHC.Types.IO GHC.Internal.Foreign.C.Types.CInt
  c_read :: GHC.Internal.Foreign.C.Types.CInt -> GHC.Internal.Ptr.Ptr GHC.Internal.Word.Word8 -> GHC.Internal.Foreign.C.Types.CUInt -> GHC.Types.IO GHC.Internal.Foreign.C.Types.CInt
  c_s_isblk :: GHC.Internal.System.Posix.Types.CMode -> GHC.Internal.Foreign.C.Types.CInt
  c_s_ischr :: GHC.Internal.System.Posix.Types.CMode -> GHC.Internal.Foreign.C.Types.CInt
  c_s_isdir :: GHC.Internal.System.Posix.Types.CMode -> GHC.Internal.Foreign.C.Types.CInt
  c_s_isfifo :: GHC.Internal.System.Posix.Types.CMode -> GHC.Internal.Foreign.C.Types.CInt
  c_s_isreg :: GHC.Internal.System.Posix.Types.CMode -> GHC.Internal.Foreign.C.Types.CInt
  c_safe_open :: CFilePath -> GHC.Internal.Foreign.C.Types.CInt -> GHC.Internal.System.Posix.Types.CMode -> GHC.Types.IO GHC.Internal.Foreign.C.Types.CInt
  c_safe_open_ :: CFilePath -> GHC.Internal.Foreign.C.Types.CInt -> GHC.Internal.System.Posix.Types.CMode -> GHC.Types.IO GHC.Internal.Foreign.C.Types.CInt
  c_safe_read :: GHC.Internal.Foreign.C.Types.CInt -> GHC.Internal.Ptr.Ptr GHC.Internal.Word.Word8 -> GHC.Internal.Foreign.C.Types.CUInt -> GHC.Types.IO GHC.Internal.Foreign.C.Types.CInt
  c_safe_write :: GHC.Internal.Foreign.C.Types.CInt -> GHC.Internal.Ptr.Ptr GHC.Internal.Word.Word8 -> GHC.Internal.Foreign.C.Types.CUInt -> GHC.Types.IO GHC.Internal.Foreign.C.Types.CInt
  c_stat :: CFilePath -> GHC.Internal.Ptr.Ptr CStat -> GHC.Types.IO GHC.Internal.Foreign.C.Types.CInt
  c_umask :: GHC.Internal.System.Posix.Types.CMode -> GHC.Types.IO GHC.Internal.System.Posix.Types.CMode
  c_unlink :: GHC.Internal.Foreign.C.String.Encoding.CString -> GHC.Types.IO GHC.Internal.Foreign.C.Types.CInt
  c_utime :: GHC.Internal.Foreign.C.String.Encoding.CString -> GHC.Internal.Ptr.Ptr CUtimbuf -> GHC.Types.IO GHC.Internal.Foreign.C.Types.CInt
  c_write :: GHC.Internal.Foreign.C.Types.CInt -> GHC.Internal.Ptr.Ptr GHC.Internal.Word.Word8 -> GHC.Internal.Foreign.C.Types.CUInt -> GHC.Types.IO GHC.Internal.Foreign.C.Types.CInt
  checkForInteriorNuls :: GHC.Internal.IO.FilePath -> GHC.Types.IO ()
  const_echo :: GHC.Internal.Foreign.C.Types.CInt
  const_f_getfl :: GHC.Internal.Foreign.C.Types.CInt
  const_f_setfd :: GHC.Internal.Foreign.C.Types.CInt
  const_f_setfl :: GHC.Internal.Foreign.C.Types.CInt
  const_fd_cloexec :: GHC.Internal.Foreign.C.Types.CLong
  const_icanon :: GHC.Internal.Foreign.C.Types.CInt
  const_sig_block :: GHC.Internal.Foreign.C.Types.CInt
  const_sig_setmask :: GHC.Internal.Foreign.C.Types.CInt
  const_sigttou :: GHC.Internal.Foreign.C.Types.CInt
  const_tcsanow :: GHC.Internal.Foreign.C.Types.CInt
  const_vmin :: GHC.Internal.Foreign.C.Types.CInt
  const_vtime :: GHC.Internal.Foreign.C.Types.CInt
  dEFAULT_BUFFER_SIZE :: GHC.Types.Int
  fdFileSize :: FD -> GHC.Types.IO GHC.Num.Integer.Integer
  fdGetMode :: FD -> GHC.Types.IO GHC.Internal.IO.IOMode.IOMode
  fdStat :: FD -> GHC.Types.IO (GHC.Internal.IO.Device.IODeviceType, GHC.Internal.System.Posix.Types.CDev, GHC.Internal.System.Posix.Types.CIno)
  fdType :: FD -> GHC.Types.IO GHC.Internal.IO.Device.IODeviceType
  fileType :: GHC.Internal.IO.FilePath -> GHC.Types.IO GHC.Internal.IO.Device.IODeviceType
  getEcho :: FD -> GHC.Types.IO GHC.Types.Bool
  get_console_echo :: GHC.Internal.Foreign.C.Types.CInt -> GHC.Types.IO GHC.Internal.Foreign.C.Types.CInt
  hostIsThreaded :: GHC.Types.Bool
  ioe_unk_error :: GHC.Internal.Base.String -> GHC.Internal.Base.String -> GHC.Internal.IO.Exception.IOException
  ioe_unknownfiletype :: GHC.Internal.IO.Exception.IOException
  is_console :: GHC.Internal.Foreign.C.Types.CInt -> GHC.Types.IO GHC.Internal.Foreign.C.Types.CInt
  lstat :: CFilePath -> GHC.Internal.Ptr.Ptr CStat -> GHC.Types.IO GHC.Internal.Foreign.C.Types.CInt
  newFilePath :: GHC.Internal.IO.FilePath -> GHC.Types.IO GHC.Internal.Foreign.C.String.CWString
  o_APPEND :: GHC.Internal.Foreign.C.Types.CInt
  o_BINARY :: GHC.Internal.Foreign.C.Types.CInt
  o_CREAT :: GHC.Internal.Foreign.C.Types.CInt
  o_EXCL :: GHC.Internal.Foreign.C.Types.CInt
  o_NOCTTY :: GHC.Internal.Foreign.C.Types.CInt
  o_NONBLOCK :: GHC.Internal.Foreign.C.Types.CInt
  o_RDONLY :: GHC.Internal.Foreign.C.Types.CInt
  o_RDWR :: GHC.Internal.Foreign.C.Types.CInt
  o_TRUNC :: GHC.Internal.Foreign.C.Types.CInt
  o_WRONLY :: GHC.Internal.Foreign.C.Types.CInt
  peekFilePath :: GHC.Internal.Foreign.C.String.CWString -> GHC.Types.IO GHC.Internal.IO.FilePath
  puts :: GHC.Internal.Base.String -> GHC.Types.IO ()
  rtsIsThreaded_ :: GHC.Types.Int
  sEEK_CUR :: GHC.Internal.Foreign.C.Types.CInt
  sEEK_END :: GHC.Internal.Foreign.C.Types.CInt
  sEEK_SET :: GHC.Internal.Foreign.C.Types.CInt
  s_isblk :: GHC.Internal.System.Posix.Types.CMode -> GHC.Types.Bool
  s_ischr :: GHC.Internal.System.Posix.Types.CMode -> GHC.Types.Bool
  s_isdir :: GHC.Internal.System.Posix.Types.CMode -> GHC.Types.Bool
  s_isfifo :: GHC.Internal.System.Posix.Types.CMode -> GHC.Types.Bool
  s_isreg :: GHC.Internal.System.Posix.Types.CMode -> GHC.Types.Bool
  s_issock :: GHC.Internal.System.Posix.Types.CMode -> GHC.Types.Bool
  setCooked :: FD -> GHC.Types.Bool -> GHC.Types.IO ()
  setEcho :: FD -> GHC.Types.Bool -> GHC.Types.IO ()
  setNonBlockingFD :: FD -> GHC.Types.Bool -> GHC.Types.IO ()
  set_console_buffering :: GHC.Internal.Foreign.C.Types.CInt -> GHC.Internal.Foreign.C.Types.CInt -> GHC.Types.IO GHC.Internal.Foreign.C.Types.CInt
  set_console_echo :: GHC.Internal.Foreign.C.Types.CInt -> GHC.Internal.Foreign.C.Types.CInt -> GHC.Types.IO GHC.Internal.Foreign.C.Types.CInt
  sizeof_stat :: GHC.Types.Int
  st_dev :: GHC.Internal.Ptr.Ptr CStat -> GHC.Types.IO GHC.Internal.System.Posix.Types.CDev
  st_ino :: GHC.Internal.Ptr.Ptr CStat -> GHC.Types.IO GHC.Internal.System.Posix.Types.CIno
  st_mode :: GHC.Internal.Ptr.Ptr CStat -> GHC.Types.IO GHC.Internal.System.Posix.Types.CMode
  st_mtime :: GHC.Internal.Ptr.Ptr CStat -> GHC.Types.IO GHC.Internal.Foreign.C.Types.CTime
  st_size :: GHC.Internal.Ptr.Ptr CStat -> GHC.Types.IO GHC.Internal.Int.Int64
  statGetType :: GHC.Internal.Ptr.Ptr CStat -> GHC.Types.IO GHC.Internal.IO.Device.IODeviceType
  throwInternalNulError :: forall a. GHC.Internal.IO.FilePath -> GHC.Types.IO a
  withFilePath :: forall a. GHC.Internal.IO.FilePath -> (GHC.Internal.Foreign.C.String.CWString -> GHC.Types.IO a) -> GHC.Types.IO a

module System.Posix.Types where

-- ignored


module System.Timeout where
  -- Safety: Safe
  type Timeout :: *
  newtype Timeout = ...
  timeout :: forall a. GHC.Types.Int -> GHC.Types.IO a -> GHC.Types.IO (GHC.Internal.Maybe.Maybe a)

module Text.ParserCombinators.ReadP where
  -- Safety: Safe
  (+++) :: forall a. ReadP a -> ReadP a -> ReadP a
  (<++) :: forall a. ReadP a -> ReadP a -> ReadP a
  type ReadP :: * -> *
  newtype ReadP a = ...
  type ReadS :: * -> *
  type ReadS a = GHC.Internal.Base.String -> [(a, GHC.Internal.Base.String)]
  between :: forall open close a. ReadP open -> ReadP close -> ReadP a -> ReadP a
  chainl :: forall a. ReadP a -> ReadP (a -> a -> a) -> a -> ReadP a
  chainl1 :: forall a. ReadP a -> ReadP (a -> a -> a) -> ReadP a
  chainr :: forall a. ReadP a -> ReadP (a -> a -> a) -> a -> ReadP a
  chainr1 :: forall a. ReadP a -> ReadP (a -> a -> a) -> ReadP a
  char :: GHC.Types.Char -> ReadP GHC.Types.Char
  choice :: forall a. [ReadP a] -> ReadP a
  count :: forall a. GHC.Types.Int -> ReadP a -> ReadP [a]
  endBy :: forall a sep. ReadP a -> ReadP sep -> ReadP [a]
  endBy1 :: forall a sep. ReadP a -> ReadP sep -> ReadP [a]
  eof :: ReadP ()
  gather :: forall a. ReadP a -> ReadP (GHC.Internal.Base.String, a)
  get :: ReadP GHC.Types.Char
  look :: ReadP GHC.Internal.Base.String
  many :: forall a. ReadP a -> ReadP [a]
  many1 :: forall a. ReadP a -> ReadP [a]
  manyTill :: forall a end. ReadP a -> ReadP end -> ReadP [a]
  munch :: (GHC.Types.Char -> GHC.Types.Bool) -> ReadP GHC.Internal.Base.String
  munch1 :: (GHC.Types.Char -> GHC.Types.Bool) -> ReadP GHC.Internal.Base.String
  option :: forall a. a -> ReadP a -> ReadP a
  optional :: forall a. ReadP a -> ReadP ()
  pfail :: forall a. ReadP a
  readP_to_S :: forall a. ReadP a -> ReadS a
  readS_to_P :: forall a. ReadS a -> ReadP a
  satisfy :: (GHC.Types.Char -> GHC.Types.Bool) -> ReadP GHC.Types.Char
  sepBy :: forall a sep. ReadP a -> ReadP sep -> ReadP [a]
  sepBy1 :: forall a sep. ReadP a -> ReadP sep -> ReadP [a]
  skipMany :: forall a. ReadP a -> ReadP ()
  skipMany1 :: forall a. ReadP a -> ReadP ()
  skipSpaces :: ReadP ()
  string :: GHC.Internal.Base.String -> ReadP GHC.Internal.Base.String

module Text.ParserCombinators.ReadPrec where
  -- Safety: Safe
  (+++) :: forall a. ReadPrec a -> ReadPrec a -> ReadPrec a
  (<++) :: forall a. ReadPrec a -> ReadPrec a -> ReadPrec a
  type Prec :: *
  type Prec = GHC.Types.Int
  type ReadPrec :: * -> *
  newtype ReadPrec a = ...
  choice :: forall a. [ReadPrec a] -> ReadPrec a
  get :: ReadPrec GHC.Types.Char
  lift :: forall a. GHC.Internal.Text.ParserCombinators.ReadP.ReadP a -> ReadPrec a
  look :: ReadPrec GHC.Internal.Base.String
  minPrec :: Prec
  pfail :: forall a. ReadPrec a
  prec :: forall a. Prec -> ReadPrec a -> ReadPrec a
  readP_to_Prec :: forall a. (GHC.Types.Int -> GHC.Internal.Text.ParserCombinators.ReadP.ReadP a) -> ReadPrec a
  readPrec_to_P :: forall a. ReadPrec a -> GHC.Types.Int -> GHC.Internal.Text.ParserCombinators.ReadP.ReadP a
  readPrec_to_S :: forall a. ReadPrec a -> GHC.Types.Int -> GHC.Internal.Text.ParserCombinators.ReadP.ReadS a
  readS_to_Prec :: forall a. (GHC.Types.Int -> GHC.Internal.Text.ParserCombinators.ReadP.ReadS a) -> ReadPrec a
  reset :: forall a. ReadPrec a -> ReadPrec a
  step :: forall a. ReadPrec a -> ReadPrec a

module Text.Printf where
  -- Safety: Safe
  type FieldFormat :: *
  data FieldFormat = FieldFormat {fmtWidth :: GHC.Internal.Maybe.Maybe GHC.Types.Int, fmtPrecision :: GHC.Internal.Maybe.Maybe GHC.Types.Int, fmtAdjust :: GHC.Internal.Maybe.Maybe FormatAdjustment, fmtSign :: GHC.Internal.Maybe.Maybe FormatSign, fmtAlternate :: GHC.Types.Bool, fmtModifiers :: GHC.Internal.Base.String, fmtChar :: GHC.Types.Char}
  type FieldFormatter :: *
  type FieldFormatter = FieldFormat -> GHC.Internal.Show.ShowS
  type FormatAdjustment :: *
  data FormatAdjustment = LeftAdjust | ZeroPad
  type FormatParse :: *
  data FormatParse = FormatParse {fpModifiers :: GHC.Internal.Base.String, fpChar :: GHC.Types.Char, fpRest :: GHC.Internal.Base.String}
  type FormatSign :: *
  data FormatSign = SignPlus | SignSpace
  type HPrintfType :: * -> Constraint
  class HPrintfType t where
    ...
    {-# MINIMAL Text.Printf.hspr #-}
  type IsChar :: * -> Constraint
  class IsChar c where
    toChar :: c -> GHC.Types.Char
    fromChar :: GHC.Types.Char -> c
    {-# MINIMAL toChar, fromChar #-}
  type ModifierParser :: *
  type ModifierParser = GHC.Internal.Base.String -> FormatParse
  type PrintfArg :: * -> Constraint
  class PrintfArg a where
    formatArg :: a -> FieldFormatter
    parseFormat :: a -> ModifierParser
    {-# MINIMAL formatArg #-}
  type PrintfType :: * -> Constraint
  class PrintfType t where
    ...
    {-# MINIMAL Text.Printf.spr #-}
  errorBadArgument :: forall a. a
  errorBadFormat :: forall a. GHC.Types.Char -> a
  errorMissingArgument :: forall a. a
  errorShortFormat :: forall a. a
  formatChar :: GHC.Types.Char -> FieldFormatter
  formatInt :: forall a. (GHC.Internal.Real.Integral a, GHC.Internal.Enum.Bounded a) => a -> FieldFormatter
  formatInteger :: GHC.Num.Integer.Integer -> FieldFormatter
  formatRealFloat :: forall a. GHC.Internal.Float.RealFloat a => a -> FieldFormatter
  formatString :: forall a. IsChar a => [a] -> FieldFormatter
  hPrintf :: forall r. HPrintfType r => GHC.Internal.IO.Handle.Types.Handle -> GHC.Internal.Base.String -> r
  perror :: forall a. GHC.Internal.Base.String -> a
  printf :: forall r. PrintfType r => GHC.Internal.Base.String -> r
  vFmt :: GHC.Types.Char -> FieldFormat -> FieldFormat

module Text.Read where
  -- Safety: Safe
  (+++) :: forall a. ReadPrec a -> ReadPrec a -> ReadPrec a
  (<++) :: forall a. ReadPrec a -> ReadPrec a -> ReadPrec a
  type Lexeme :: *
  data Lexeme = Char GHC.Types.Char | String GHC.Internal.Base.String | Punc GHC.Internal.Base.String | Ident GHC.Internal.Base.String | Symbol GHC.Internal.Base.String | Number GHC.Internal.Text.Read.Lex.Number | EOF