base-exports.stdout-javascript-unknown-ghcjs

  writeSTRef :: forall s a. STRef s a -> a -> GHC.ST.ST s ()

module GHC.Show where
  -- Safety: Trustworthy
  type Show :: * -> Constraint
  class Show a where
    showsPrec :: GHC.Types.Int -> a -> ShowS
    show :: a -> GHC.Base.String
    showList :: [a] -> ShowS
    {-# MINIMAL showsPrec | show #-}
  type ShowS :: *
  type ShowS = GHC.Base.String -> GHC.Base.String
  appPrec :: GHC.Types.Int
  appPrec1 :: GHC.Types.Int
  asciiTab :: [GHC.Base.String]
  intToDigit :: GHC.Types.Int -> GHC.Types.Char
  protectEsc :: (GHC.Types.Char -> GHC.Types.Bool) -> ShowS -> ShowS
  showChar :: GHC.Types.Char -> ShowS
  showCommaSpace :: ShowS
  showList__ :: forall a. (a -> ShowS) -> [a] -> ShowS
  showLitChar :: GHC.Types.Char -> ShowS
  showLitString :: GHC.Base.String -> ShowS
  showMultiLineString :: GHC.Base.String -> [GHC.Base.String]
  showParen :: GHC.Types.Bool -> ShowS -> ShowS
  showSignedInt :: GHC.Types.Int -> GHC.Types.Int -> ShowS
  showSpace :: ShowS
  showString :: GHC.Base.String -> ShowS
  shows :: forall a. Show a => a -> ShowS

module GHC.Stable where
  -- Safety: Unsafe
  type StablePtr :: * -> *
  data StablePtr a = StablePtr (GHC.Prim.StablePtr# a)
  castPtrToStablePtr :: forall a. GHC.Ptr.Ptr () -> StablePtr a
  castStablePtrToPtr :: forall a. StablePtr a -> GHC.Ptr.Ptr ()
  deRefStablePtr :: forall a. StablePtr a -> GHC.Types.IO a
  freeStablePtr :: forall a. StablePtr a -> GHC.Types.IO ()
  newStablePtr :: forall a. a -> GHC.Types.IO (StablePtr a)

module GHC.StableName where
  -- Safety: Trustworthy
  type role StableName phantom
  type StableName :: * -> *
  data StableName a = StableName (GHC.Prim.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 GHC.Stack where
  -- Safety: Trustworthy
  type CallStack :: *
  data CallStack = ...
  type CostCentre :: *
  data CostCentre
  type CostCentreStack :: *
  data CostCentreStack
  type HasCallStack :: Constraint
  type HasCallStack = ?callStack::CallStack :: Constraint
  type SrcLoc :: *
  data SrcLoc = SrcLoc {srcLocPackage :: [GHC.Types.Char], srcLocModule :: [GHC.Types.Char], srcLocFile :: [GHC.Types.Char], srcLocStartLine :: GHC.Types.Int, srcLocStartCol :: GHC.Types.Int, srcLocEndLine :: GHC.Types.Int, srcLocEndCol :: GHC.Types.Int}
  callStack :: HasCallStack => CallStack
  ccLabel :: GHC.Ptr.Ptr CostCentre -> GHC.Types.IO base-4.18.0.0:GHC.Foreign.Internal.CString
  ccModule :: GHC.Ptr.Ptr CostCentre -> GHC.Types.IO base-4.18.0.0:GHC.Foreign.Internal.CString
  ccSrcSpan :: GHC.Ptr.Ptr CostCentre -> GHC.Types.IO base-4.18.0.0:GHC.Foreign.Internal.CString
  ccsCC :: GHC.Ptr.Ptr CostCentreStack -> GHC.Types.IO (GHC.Ptr.Ptr CostCentre)
  ccsParent :: GHC.Ptr.Ptr CostCentreStack -> GHC.Types.IO (GHC.Ptr.Ptr CostCentreStack)
  ccsToStrings :: GHC.Ptr.Ptr CostCentreStack -> GHC.Types.IO [GHC.Base.String]
  clearCCS :: forall a. GHC.Types.IO a -> GHC.Types.IO a
  currentCallStack :: GHC.Types.IO [GHC.Base.String]
  emptyCallStack :: CallStack
  errorWithStackTrace :: forall a. GHC.Base.String -> a
  freezeCallStack :: CallStack -> CallStack
  fromCallSiteList :: [([GHC.Types.Char], SrcLoc)] -> CallStack
  getCCSOf :: forall a. a -> GHC.Types.IO (GHC.Ptr.Ptr CostCentreStack)
  getCallStack :: CallStack -> [([GHC.Types.Char], SrcLoc)]
  getCurrentCCS :: forall dummy. dummy -> GHC.Types.IO (GHC.Ptr.Ptr CostCentreStack)
  popCallStack :: CallStack -> CallStack
  prettyCallStack :: CallStack -> GHC.Base.String
  prettySrcLoc :: SrcLoc -> GHC.Base.String
  pushCallStack :: ([GHC.Types.Char], SrcLoc) -> CallStack -> CallStack
  renderStack :: [GHC.Base.String] -> GHC.Base.String
  whoCreated :: forall a. a -> GHC.Types.IO [GHC.Base.String]
  withFrozenCallStack :: forall a. HasCallStack => (HasCallStack => a) -> a

module GHC.Stack.CCS where
  -- Safety: Trustworthy
  type CostCentre :: *
  data CostCentre
  type CostCentreStack :: *
  data CostCentreStack
  ccLabel :: GHC.Ptr.Ptr CostCentre -> GHC.Types.IO base-4.18.0.0:GHC.Foreign.Internal.CString
  ccModule :: GHC.Ptr.Ptr CostCentre -> GHC.Types.IO base-4.18.0.0:GHC.Foreign.Internal.CString
  ccSrcSpan :: GHC.Ptr.Ptr CostCentre -> GHC.Types.IO base-4.18.0.0:GHC.Foreign.Internal.CString
  ccsCC :: GHC.Ptr.Ptr CostCentreStack -> GHC.Types.IO (GHC.Ptr.Ptr CostCentre)
  ccsParent :: GHC.Ptr.Ptr CostCentreStack -> GHC.Types.IO (GHC.Ptr.Ptr CostCentreStack)
  ccsToStrings :: GHC.Ptr.Ptr CostCentreStack -> GHC.Types.IO [GHC.Base.String]
  clearCCS :: forall a. GHC.Types.IO a -> GHC.Types.IO a
  currentCallStack :: GHC.Types.IO [GHC.Base.String]
  getCCSOf :: forall a. a -> GHC.Types.IO (GHC.Ptr.Ptr CostCentreStack)
  getCurrentCCS :: forall dummy. dummy -> GHC.Types.IO (GHC.Ptr.Ptr CostCentreStack)
  renderStack :: [GHC.Base.String] -> GHC.Base.String
  whoCreated :: forall a. a -> GHC.Types.IO [GHC.Base.String]

module GHC.Stack.CloneStack where
  -- Safety: None
  type StackEntry :: *
  data StackEntry = StackEntry {functionName :: GHC.Base.String, moduleName :: GHC.Base.String, srcLoc :: GHC.Base.String, closureType :: GHC.Types.Word}
  type StackSnapshot :: *
  data StackSnapshot = StackSnapshot GHC.Prim.StackSnapshot#
  cloneMyStack :: GHC.Types.IO StackSnapshot
  cloneThreadStack :: GHC.Conc.Sync.ThreadId -> GHC.Types.IO StackSnapshot
  decode :: StackSnapshot -> GHC.Types.IO [StackEntry]

module GHC.Stack.Types where
  -- Safety: Trustworthy
  type CallStack :: *
  data CallStack = EmptyCallStack | PushCallStack [GHC.Types.Char] SrcLoc CallStack | FreezeCallStack CallStack
  type HasCallStack :: Constraint
  type HasCallStack = ?callStack::CallStack :: Constraint
  type SrcLoc :: *
  data SrcLoc = SrcLoc {srcLocPackage :: [GHC.Types.Char], srcLocModule :: [GHC.Types.Char], srcLocFile :: [GHC.Types.Char], srcLocStartLine :: GHC.Types.Int, srcLocStartCol :: GHC.Types.Int, srcLocEndLine :: GHC.Types.Int, srcLocEndCol :: GHC.Types.Int}
  emptyCallStack :: CallStack
  freezeCallStack :: CallStack -> CallStack
  fromCallSiteList :: [([GHC.Types.Char], SrcLoc)] -> CallStack
  getCallStack :: CallStack -> [([GHC.Types.Char], SrcLoc)]
  pushCallStack :: ([GHC.Types.Char], SrcLoc) -> CallStack -> CallStack

module GHC.StaticPtr where
  -- Safety: None
  type IsStatic :: (* -> *) -> Constraint
  class IsStatic p where
    fromStaticPtr :: forall a. base-4.18.0.0:Data.Typeable.Internal.Typeable a => StaticPtr a -> p a
    {-# MINIMAL fromStaticPtr #-}
  type StaticKey :: *
  type StaticKey = GHC.Fingerprint.Type.Fingerprint
  type StaticPtr :: * -> *
  data StaticPtr a = ...
  type StaticPtrInfo :: *
  data StaticPtrInfo = StaticPtrInfo {spInfoUnitId :: GHC.Base.String, spInfoModuleName :: GHC.Base.String, spInfoSrcLoc :: (GHC.Types.Int, GHC.Types.Int)}
  deRefStaticPtr :: forall a. StaticPtr a -> a
  staticKey :: forall a. StaticPtr a -> StaticKey
  staticPtrInfo :: forall a. StaticPtr a -> StaticPtrInfo
  staticPtrKeys :: GHC.Types.IO [StaticKey]
  unsafeLookupStaticPtr :: forall a. StaticKey -> GHC.Types.IO (GHC.Maybe.Maybe (StaticPtr a))

module GHC.Stats where
  -- Safety: Trustworthy
  type GCDetails :: *
  data GCDetails
    = GCDetails {gcdetails_gen :: GHC.Word.Word32,
                 gcdetails_threads :: GHC.Word.Word32,
                 gcdetails_allocated_bytes :: GHC.Word.Word64,
                 gcdetails_live_bytes :: GHC.Word.Word64,
                 gcdetails_large_objects_bytes :: GHC.Word.Word64,
                 gcdetails_compact_bytes :: GHC.Word.Word64,
                 gcdetails_slop_bytes :: GHC.Word.Word64,
                 gcdetails_mem_in_use_bytes :: GHC.Word.Word64,
                 gcdetails_copied_bytes :: GHC.Word.Word64,
                 gcdetails_par_max_copied_bytes :: GHC.Word.Word64,
                 gcdetails_par_balanced_copied_bytes :: GHC.Word.Word64,
                 gcdetails_block_fragmentation_bytes :: GHC.Word.Word64,
                 gcdetails_sync_elapsed_ns :: RtsTime,
                 gcdetails_cpu_ns :: RtsTime,
                 gcdetails_elapsed_ns :: RtsTime,
                 gcdetails_nonmoving_gc_sync_cpu_ns :: RtsTime,
                 gcdetails_nonmoving_gc_sync_elapsed_ns :: RtsTime}
  type RTSStats :: *
  data RTSStats
    = RTSStats {gcs :: GHC.Word.Word32,
                major_gcs :: GHC.Word.Word32,
                allocated_bytes :: GHC.Word.Word64,
                max_live_bytes :: GHC.Word.Word64,
                max_large_objects_bytes :: GHC.Word.Word64,
                max_compact_bytes :: GHC.Word.Word64,
                max_slop_bytes :: GHC.Word.Word64,
                max_mem_in_use_bytes :: GHC.Word.Word64,
                cumulative_live_bytes :: GHC.Word.Word64,
                copied_bytes :: GHC.Word.Word64,
                par_copied_bytes :: GHC.Word.Word64,
                cumulative_par_max_copied_bytes :: GHC.Word.Word64,
                cumulative_par_balanced_copied_bytes :: GHC.Word.Word64,
                init_cpu_ns :: RtsTime,
                init_elapsed_ns :: RtsTime,
                mutator_cpu_ns :: RtsTime,
                mutator_elapsed_ns :: RtsTime,
                gc_cpu_ns :: RtsTime,
                gc_elapsed_ns :: RtsTime,
                cpu_ns :: RtsTime,
                elapsed_ns :: RtsTime,
                nonmoving_gc_sync_cpu_ns :: RtsTime,
                nonmoving_gc_sync_elapsed_ns :: RtsTime,
                nonmoving_gc_sync_max_elapsed_ns :: RtsTime,
                nonmoving_gc_cpu_ns :: RtsTime,
                nonmoving_gc_elapsed_ns :: RtsTime,
                nonmoving_gc_max_elapsed_ns :: RtsTime,
                gc :: GCDetails}
  type RtsTime :: *
  type RtsTime = GHC.Int.Int64
  getRTSStats :: GHC.Types.IO RTSStats
  getRTSStatsEnabled :: GHC.Types.IO GHC.Types.Bool

module GHC.Storable where
  -- Safety: Trustworthy
  readDoubleOffPtr :: GHC.Ptr.Ptr GHC.Types.Double -> GHC.Types.Int -> GHC.Types.IO GHC.Types.Double
  readFloatOffPtr :: GHC.Ptr.Ptr GHC.Types.Float -> GHC.Types.Int -> GHC.Types.IO GHC.Types.Float
  readFunPtrOffPtr :: forall a. GHC.Ptr.Ptr (GHC.Ptr.FunPtr a) -> GHC.Types.Int -> GHC.Types.IO (GHC.Ptr.FunPtr a)
  readInt16OffPtr :: GHC.Ptr.Ptr GHC.Int.Int16 -> GHC.Types.Int -> GHC.Types.IO GHC.Int.Int16
  readInt32OffPtr :: GHC.Ptr.Ptr GHC.Int.Int32 -> GHC.Types.Int -> GHC.Types.IO GHC.Int.Int32
  readInt64OffPtr :: GHC.Ptr.Ptr GHC.Int.Int64 -> GHC.Types.Int -> GHC.Types.IO GHC.Int.Int64
  readInt8OffPtr :: GHC.Ptr.Ptr GHC.Int.Int8 -> GHC.Types.Int -> GHC.Types.IO GHC.Int.Int8
  readIntOffPtr :: GHC.Ptr.Ptr GHC.Types.Int -> GHC.Types.Int -> GHC.Types.IO GHC.Types.Int
  readPtrOffPtr :: forall a. GHC.Ptr.Ptr (GHC.Ptr.Ptr a) -> GHC.Types.Int -> GHC.Types.IO (GHC.Ptr.Ptr a)
  readStablePtrOffPtr :: forall a. GHC.Ptr.Ptr (GHC.Stable.StablePtr a) -> GHC.Types.Int -> GHC.Types.IO (GHC.Stable.StablePtr a)
  readWideCharOffPtr :: GHC.Ptr.Ptr GHC.Types.Char -> GHC.Types.Int -> GHC.Types.IO GHC.Types.Char
  readWord16OffPtr :: GHC.Ptr.Ptr GHC.Word.Word16 -> GHC.Types.Int -> GHC.Types.IO GHC.Word.Word16
  readWord32OffPtr :: GHC.Ptr.Ptr GHC.Word.Word32 -> GHC.Types.Int -> GHC.Types.IO GHC.Word.Word32
  readWord64OffPtr :: GHC.Ptr.Ptr GHC.Word.Word64 -> GHC.Types.Int -> GHC.Types.IO GHC.Word.Word64
  readWord8OffPtr :: GHC.Ptr.Ptr GHC.Word.Word8 -> GHC.Types.Int -> GHC.Types.IO GHC.Word.Word8
  readWordOffPtr :: GHC.Ptr.Ptr GHC.Types.Word -> GHC.Types.Int -> GHC.Types.IO GHC.Types.Word
  writeDoubleOffPtr :: GHC.Ptr.Ptr GHC.Types.Double -> GHC.Types.Int -> GHC.Types.Double -> GHC.Types.IO ()
  writeFloatOffPtr :: GHC.Ptr.Ptr GHC.Types.Float -> GHC.Types.Int -> GHC.Types.Float -> GHC.Types.IO ()
  writeFunPtrOffPtr :: forall a. GHC.Ptr.Ptr (GHC.Ptr.FunPtr a) -> GHC.Types.Int -> GHC.Ptr.FunPtr a -> GHC.Types.IO ()
  writeInt16OffPtr :: GHC.Ptr.Ptr GHC.Int.Int16 -> GHC.Types.Int -> GHC.Int.Int16 -> GHC.Types.IO ()
  writeInt32OffPtr :: GHC.Ptr.Ptr GHC.Int.Int32 -> GHC.Types.Int -> GHC.Int.Int32 -> GHC.Types.IO ()
  writeInt64OffPtr :: GHC.Ptr.Ptr GHC.Int.Int64 -> GHC.Types.Int -> GHC.Int.Int64 -> GHC.Types.IO ()
  writeInt8OffPtr :: GHC.Ptr.Ptr GHC.Int.Int8 -> GHC.Types.Int -> GHC.Int.Int8 -> GHC.Types.IO ()
  writeIntOffPtr :: GHC.Ptr.Ptr GHC.Types.Int -> GHC.Types.Int -> GHC.Types.Int -> GHC.Types.IO ()
  writePtrOffPtr :: forall a. GHC.Ptr.Ptr (GHC.Ptr.Ptr a) -> GHC.Types.Int -> GHC.Ptr.Ptr a -> GHC.Types.IO ()
  writeStablePtrOffPtr :: forall a. GHC.Ptr.Ptr (GHC.Stable.StablePtr a) -> GHC.Types.Int -> GHC.Stable.StablePtr a -> GHC.Types.IO ()
  writeWideCharOffPtr :: GHC.Ptr.Ptr GHC.Types.Char -> GHC.Types.Int -> GHC.Types.Char -> GHC.Types.IO ()
  writeWord16OffPtr :: GHC.Ptr.Ptr GHC.Word.Word16 -> GHC.Types.Int -> GHC.Word.Word16 -> GHC.Types.IO ()
  writeWord32OffPtr :: GHC.Ptr.Ptr GHC.Word.Word32 -> GHC.Types.Int -> GHC.Word.Word32 -> GHC.Types.IO ()
  writeWord64OffPtr :: GHC.Ptr.Ptr GHC.Word.Word64 -> GHC.Types.Int -> GHC.Word.Word64 -> GHC.Types.IO ()
  writeWord8OffPtr :: GHC.Ptr.Ptr GHC.Word.Word8 -> GHC.Types.Int -> GHC.Word.Word8 -> GHC.Types.IO ()
  writeWordOffPtr :: GHC.Ptr.Ptr GHC.Types.Word -> GHC.Types.Int -> GHC.Types.Word -> GHC.Types.IO ()

module GHC.TopHandler where
  -- Safety: Trustworthy
  flushStdHandles :: GHC.Types.IO ()
  reportError :: GHC.Exception.Type.SomeException -> GHC.Types.IO ()
  reportStackOverflow :: GHC.Types.IO ()
  runIO :: forall a. GHC.Types.IO a -> GHC.Types.IO a
  runIOFastExit :: forall a. GHC.Types.IO a -> GHC.Types.IO a
  runMainIO :: forall a. GHC.Types.IO a -> GHC.Types.IO a
  runNonIO :: forall a. a -> GHC.Types.IO a
  topHandler :: forall a. GHC.Exception.Type.SomeException -> GHC.Types.IO a
  topHandlerFastExit :: forall a. GHC.Exception.Type.SomeException -> GHC.Types.IO a

module GHC.TypeError where
  -- Safety: Trustworthy
  type Assert :: GHC.Types.Bool -> Constraint -> Constraint
  type family Assert check errMsg where
    forall (_1 :: Constraint). Assert GHC.Types.True _1 = () :: Constraint
    forall (_1 :: GHC.Types.Bool) (errMsg :: Constraint). Assert _1 errMsg = errMsg
  type ErrorMessage :: *
  data ErrorMessage = Text GHC.Types.Symbol | forall t. ShowType t | ErrorMessage :<>: ErrorMessage | ErrorMessage :$$: ErrorMessage
  type TypeError :: forall b. ErrorMessage -> b
  type family TypeError a where
  type Unsatisfiable :: ErrorMessage -> Constraint
  class Unsatisfiable msg where
    ...
    {-# MINIMAL GHC.TypeError.unsatisfiableLifted #-}
  unsatisfiable :: forall {rep :: GHC.Types.RuntimeRep} (msg :: ErrorMessage) (a :: TYPE rep). Unsatisfiable msg => a

module GHC.TypeLits where
  -- Safety: Trustworthy
  type (*) :: Natural -> Natural -> Natural
  type family (*) a b
  type (+) :: Natural -> Natural -> Natural
  type family (+) a b
  type (-) :: Natural -> Natural -> Natural
  type family (-) a b
  type (<=) :: forall {t}. t -> t -> Constraint
  type (<=) x y = GHC.TypeError.Assert (x <=? y) (Data.Type.Ord.LeErrMsg x y) :: Constraint
  type (<=?) :: forall k. k -> k -> GHC.Types.Bool
  type (<=?) m n = Data.Type.Ord.OrdCond (Data.Type.Ord.Compare m n) GHC.Types.True GHC.Types.True GHC.Types.False :: GHC.Types.Bool
  type AppendSymbol :: Symbol -> Symbol -> Symbol
  type family AppendSymbol a b
  type CharToNat :: GHC.Types.Char -> Natural
  type family CharToNat a
  type CmpChar :: GHC.Types.Char -> GHC.Types.Char -> GHC.Types.Ordering
  type family CmpChar a b
  type CmpNat :: Natural -> Natural -> GHC.Types.Ordering
  type family CmpNat a b
  type CmpSymbol :: Symbol -> Symbol -> GHC.Types.Ordering
  type family CmpSymbol a b
  type ConsSymbol :: GHC.Types.Char -> Symbol -> Symbol
  type family ConsSymbol a b
  type Div :: Natural -> Natural -> Natural
  type family Div a b
  type ErrorMessage :: *
  data ErrorMessage = Text Symbol | forall t. ShowType t | ErrorMessage :<>: ErrorMessage | ErrorMessage :$$: ErrorMessage
  type KnownChar :: GHC.Types.Char -> Constraint
  class KnownChar n where
    charSing :: SChar n
    {-# MINIMAL charSing #-}
  type KnownNat :: Nat -> Constraint
  class KnownNat n where
    natSing :: SNat n
    {-# MINIMAL natSing #-}
  type KnownSymbol :: Symbol -> Constraint
  class KnownSymbol n where
    symbolSing :: SSymbol n
    {-# MINIMAL symbolSing #-}
  type Log2 :: Natural -> Natural
  type family Log2 a
  type Mod :: Natural -> Natural -> Natural
  type family Mod a b
  type Nat :: *
  type Nat = Natural
  type NatToChar :: Natural -> GHC.Types.Char
  type family NatToChar a
  type Natural :: *
  data Natural = ...
  type role OrderingI nominal nominal
  type OrderingI :: forall {k}. k -> k -> *
  data OrderingI a b where
    LTI :: forall {k} (a :: k) (b :: k). (Data.Type.Ord.Compare a b ~ GHC.Types.LT) => OrderingI a b
    EQI :: forall {k} (a :: k). (Data.Type.Ord.Compare a a ~ GHC.Types.EQ) => OrderingI a a
    GTI :: forall {k} (a :: k) (b :: k). (Data.Type.Ord.Compare a b ~ GHC.Types.GT) => OrderingI a b
  pattern SChar :: forall (c :: GHC.Types.Char). () => KnownChar c => SChar c
  type role SChar nominal
  type SChar :: GHC.Types.Char -> *
  newtype SChar s = ...
  pattern SNat :: forall (n :: Nat). () => KnownNat n => SNat n
  type role SNat nominal
  type SNat :: Nat -> *
  newtype SNat n = ...
  pattern SSymbol :: forall (s :: Symbol). () => KnownSymbol s => SSymbol s
  type role SSymbol nominal
  type SSymbol :: Symbol -> *
  newtype SSymbol s = ...
  type SomeChar :: *
  data SomeChar = forall (n :: GHC.Types.Char). KnownChar n => SomeChar (Data.Proxy.Proxy n)
  type SomeNat :: *
  data SomeNat = forall (n :: Nat). KnownNat n => SomeNat (Data.Proxy.Proxy n)
  type SomeSymbol :: *
  data SomeSymbol = forall (n :: Symbol). KnownSymbol n => SomeSymbol (Data.Proxy.Proxy n)
  type Symbol :: *
  data Symbol
  type TypeError :: forall b. ErrorMessage -> b
  type family TypeError a where
  type UnconsSymbol :: Symbol -> GHC.Maybe.Maybe (GHC.Types.Char, Symbol)
  type family UnconsSymbol a
  type (^) :: Natural -> Natural -> Natural
  type family (^) a b
  charVal :: forall (n :: GHC.Types.Char) (proxy :: GHC.Types.Char -> *). KnownChar n => proxy n -> GHC.Types.Char
  charVal' :: forall (n :: GHC.Types.Char). KnownChar n => GHC.Prim.Proxy# n -> GHC.Types.Char
  cmpChar :: forall (a :: GHC.Types.Char) (b :: GHC.Types.Char) (proxy1 :: GHC.Types.Char -> *) (proxy2 :: GHC.Types.Char -> *). (KnownChar a, KnownChar b) => proxy1 a -> proxy2 b -> OrderingI a b
  cmpNat :: forall (a :: Nat) (b :: Nat) (proxy1 :: Nat -> *) (proxy2 :: Nat -> *). (KnownNat a, KnownNat b) => proxy1 a -> proxy2 b -> OrderingI a b
  cmpSymbol :: forall (a :: Symbol) (b :: Symbol) (proxy1 :: Symbol -> *) (proxy2 :: Symbol -> *). (KnownSymbol a, KnownSymbol b) => proxy1 a -> proxy2 b -> OrderingI a b
  decideChar :: forall (a :: GHC.Types.Char) (b :: GHC.Types.Char) (proxy1 :: GHC.Types.Char -> *) (proxy2 :: GHC.Types.Char -> *). (KnownChar a, KnownChar b) => proxy1 a -> proxy2 b -> Data.Either.Either ((a Data.Type.Equality.:~: b) -> GHC.Base.Void) (a Data.Type.Equality.:~: b)
  decideNat :: forall (a :: Nat) (b :: Nat) (proxy1 :: Nat -> *) (proxy2 :: Nat -> *). (KnownNat a, KnownNat b) => proxy1 a -> proxy2 b -> Data.Either.Either ((a Data.Type.Equality.:~: b) -> GHC.Base.Void) (a Data.Type.Equality.:~: b)
  decideSymbol :: forall (a :: Symbol) (b :: Symbol) (proxy1 :: Symbol -> *) (proxy2 :: Symbol -> *). (KnownSymbol a, KnownSymbol b) => proxy1 a -> proxy2 b -> Data.Either.Either ((a Data.Type.Equality.:~: b) -> GHC.Base.Void) (a Data.Type.Equality.:~: b)
  fromSChar :: forall (c :: GHC.Types.Char). SChar c -> GHC.Types.Char
  fromSNat :: forall (n :: Nat). SNat n -> GHC.Num.Integer.Integer
  fromSSymbol :: forall (s :: Symbol). SSymbol s -> GHC.Base.String
  natVal :: forall (n :: Nat) (proxy :: Nat -> *). KnownNat n => proxy n -> GHC.Num.Integer.Integer
  natVal' :: forall (n :: Nat). KnownNat n => GHC.Prim.Proxy# n -> GHC.Num.Integer.Integer
  sameChar :: forall (a :: GHC.Types.Char) (b :: GHC.Types.Char) (proxy1 :: GHC.Types.Char -> *) (proxy2 :: GHC.Types.Char -> *). (KnownChar a, KnownChar b) => proxy1 a -> proxy2 b -> GHC.Maybe.Maybe (a Data.Type.Equality.:~: b)
  sameNat :: forall (a :: Nat) (b :: Nat) (proxy1 :: Nat -> *) (proxy2 :: Nat -> *). (KnownNat a, KnownNat b) => proxy1 a -> proxy2 b -> GHC.Maybe.Maybe (a Data.Type.Equality.:~: b)
  sameSymbol :: forall (a :: Symbol) (b :: Symbol) (proxy1 :: Symbol -> *) (proxy2 :: Symbol -> *). (KnownSymbol a, KnownSymbol b) => proxy1 a -> proxy2 b -> GHC.Maybe.Maybe (a Data.Type.Equality.:~: b)
  someCharVal :: GHC.Types.Char -> SomeChar
  someNatVal :: GHC.Num.Integer.Integer -> GHC.Maybe.Maybe SomeNat
  someSymbolVal :: GHC.Base.String -> SomeSymbol
  symbolVal :: forall (n :: Symbol) (proxy :: Symbol -> *). KnownSymbol n => proxy n -> GHC.Base.String
  symbolVal' :: forall (n :: Symbol). KnownSymbol n => GHC.Prim.Proxy# n -> GHC.Base.String
  withKnownChar :: forall (c :: GHC.Types.Char) (rep :: GHC.Types.RuntimeRep) (r :: TYPE rep). SChar c -> (KnownChar c => r) -> r
  withKnownNat :: forall (n :: Nat) (rep :: GHC.Types.RuntimeRep) (r :: TYPE rep). SNat n -> (KnownNat n => r) -> r
  withKnownSymbol :: forall (s :: Symbol) (rep :: GHC.Types.RuntimeRep) (r :: TYPE rep). SSymbol s -> (KnownSymbol s => r) -> r
  withSomeSChar :: forall (rep :: GHC.Types.RuntimeRep) (r :: TYPE rep). GHC.Types.Char -> (forall (c :: GHC.Types.Char). SChar c -> r) -> r
  withSomeSNat :: forall (rep :: GHC.Types.RuntimeRep) (r :: TYPE rep). GHC.Num.Integer.Integer -> (forall (n :: Nat). GHC.Maybe.Maybe (SNat n) -> r) -> r
  withSomeSSymbol :: forall (rep :: GHC.Types.RuntimeRep) (r :: TYPE rep). GHC.Base.String -> (forall (s :: Symbol). SSymbol s -> r) -> r

module GHC.TypeLits.Internal where
  -- Safety: Trustworthy
  type CmpChar :: GHC.Types.Char -> GHC.Types.Char -> GHC.Types.Ordering
  type family CmpChar a b
  type CmpSymbol :: Symbol -> Symbol -> GHC.Types.Ordering
  type family CmpSymbol a b
  type Symbol :: *
  data Symbol

module GHC.TypeNats where
  -- Safety: Trustworthy
  type (*) :: Natural -> Natural -> Natural
  type family (*) a b
  type (+) :: Natural -> Natural -> Natural
  type family (+) a b
  type (-) :: Natural -> Natural -> Natural
  type family (-) a b
  type (<=) :: forall {t}. t -> t -> Constraint
  type (<=) x y = GHC.TypeError.Assert (x <=? y) (Data.Type.Ord.LeErrMsg x y) :: Constraint
  type (<=?) :: forall k. k -> k -> GHC.Types.Bool
  type (<=?) m n = Data.Type.Ord.OrdCond (Data.Type.Ord.Compare m n) GHC.Types.True GHC.Types.True GHC.Types.False :: GHC.Types.Bool
  type CmpNat :: Natural -> Natural -> GHC.Types.Ordering
  type family CmpNat a b
  type Div :: Natural -> Natural -> Natural
  type family Div a b
  type KnownNat :: Nat -> Constraint
  class KnownNat n where
    natSing :: SNat n
    {-# MINIMAL natSing #-}
  type Log2 :: Natural -> Natural
  type family Log2 a
  type Mod :: Natural -> Natural -> Natural
  type family Mod a b
  type Nat :: *
  type Nat = Natural
  type Natural :: *
  data Natural = ...
  pattern SNat :: forall (n :: Nat). () => KnownNat n => SNat n
  type role SNat nominal
  type SNat :: Nat -> *
  newtype SNat n = ...
  type SomeNat :: *
  data SomeNat = forall (n :: Nat). KnownNat n => SomeNat (Data.Proxy.Proxy n)
  type (^) :: Natural -> Natural -> Natural
  type family (^) a b
  cmpNat :: forall (a :: Nat) (b :: Nat) (proxy1 :: Nat -> *) (proxy2 :: Nat -> *). (KnownNat a, KnownNat b) => proxy1 a -> proxy2 b -> Data.Type.Ord.OrderingI a b
  decideNat :: forall (a :: Nat) (b :: Nat) (proxy1 :: Nat -> *) (proxy2 :: Nat -> *). (KnownNat a, KnownNat b) => proxy1 a -> proxy2 b -> Data.Either.Either ((a Data.Type.Equality.:~: b) -> GHC.Base.Void) (a Data.Type.Equality.:~: b)
  fromSNat :: forall (n :: Nat). SNat n -> Natural
  natVal :: forall (n :: Nat) (proxy :: Nat -> *). KnownNat n => proxy n -> Natural
  natVal' :: forall (n :: Nat). KnownNat n => GHC.Prim.Proxy# n -> Natural
  sameNat :: forall (a :: Nat) (b :: Nat) (proxy1 :: Nat -> *) (proxy2 :: Nat -> *). (KnownNat a, KnownNat b) => proxy1 a -> proxy2 b -> GHC.Maybe.Maybe (a Data.Type.Equality.:~: b)
  someNatVal :: Natural -> SomeNat
  withKnownNat :: forall (n :: Nat) (rep :: GHC.Types.RuntimeRep) (r :: TYPE rep). SNat n -> (KnownNat n => r) -> r
  withSomeSNat :: forall (rep :: GHC.Types.RuntimeRep) (r :: TYPE rep). Natural -> (forall (n :: Nat). SNat n -> r) -> r

module GHC.TypeNats.Internal where
  -- Safety: Trustworthy
  type CmpNat :: Natural -> Natural -> GHC.Types.Ordering
  type family CmpNat a b
  type Natural :: *
  data Natural = ...

module GHC.Unicode where
  -- Safety: Trustworthy
  type GeneralCategory :: *
  data GeneralCategory = UppercaseLetter | LowercaseLetter | TitlecaseLetter | ModifierLetter | OtherLetter | NonSpacingMark | SpacingCombiningMark | EnclosingMark | DecimalNumber | LetterNumber | OtherNumber | ConnectorPunctuation | DashPunctuation | OpenPunctuation | ClosePunctuation | InitialQuote | FinalQuote | OtherPunctuation | MathSymbol | CurrencySymbol | ModifierSymbol | OtherSymbol | Space | LineSeparator | ParagraphSeparator | Control | Format | Surrogate | PrivateUse | NotAssigned
  generalCategory :: GHC.Types.Char -> GeneralCategory
  isAlpha :: GHC.Types.Char -> GHC.Types.Bool
  isAlphaNum :: GHC.Types.Char -> GHC.Types.Bool
  isAscii :: GHC.Types.Char -> GHC.Types.Bool
  isAsciiLower :: GHC.Types.Char -> GHC.Types.Bool
  isAsciiUpper :: GHC.Types.Char -> GHC.Types.Bool
  isControl :: GHC.Types.Char -> GHC.Types.Bool
  isDigit :: GHC.Types.Char -> GHC.Types.Bool
  isHexDigit :: GHC.Types.Char -> GHC.Types.Bool
  isLatin1 :: GHC.Types.Char -> GHC.Types.Bool
  isLower :: GHC.Types.Char -> GHC.Types.Bool
  isLowerCase :: GHC.Types.Char -> GHC.Types.Bool
  isOctDigit :: GHC.Types.Char -> GHC.Types.Bool
  isPrint :: GHC.Types.Char -> GHC.Types.Bool
  isPunctuation :: GHC.Types.Char -> GHC.Types.Bool
  isSpace :: GHC.Types.Char -> GHC.Types.Bool
  isSymbol :: GHC.Types.Char -> GHC.Types.Bool
  isUpper :: GHC.Types.Char -> GHC.Types.Bool
  isUpperCase :: GHC.Types.Char -> GHC.Types.Bool
  toLower :: GHC.Types.Char -> GHC.Types.Char
  toTitle :: GHC.Types.Char -> GHC.Types.Char
  toUpper :: GHC.Types.Char -> GHC.Types.Char
  unicodeVersion :: Data.Version.Version

module GHC.Weak where
  -- Safety: Unsafe
  type Weak :: * -> *
  data Weak v = Weak (GHC.Prim.Weak# v)
  deRefWeak :: forall v. Weak v -> GHC.Types.IO (GHC.Maybe.Maybe v)
  finalize :: forall v. Weak v -> GHC.Types.IO ()
  getFinalizerExceptionHandler :: GHC.Types.IO (GHC.Exception.Type.SomeException -> GHC.Types.IO ())
  mkWeak :: forall k v. k -> v -> GHC.Maybe.Maybe (GHC.Types.IO ()) -> GHC.Types.IO (Weak v)
  printToHandleFinalizerExceptionHandler :: GHC.IO.Handle.Types.Handle -> GHC.Exception.Type.SomeException -> GHC.Types.IO ()
  setFinalizerExceptionHandler :: (GHC.Exception.Type.SomeException -> GHC.Types.IO ()) -> GHC.Types.IO ()

module GHC.Weak.Finalize where
  -- Safety: Unsafe
  getFinalizerExceptionHandler :: GHC.Types.IO (GHC.Exception.Type.SomeException -> GHC.Types.IO ())
  printToHandleFinalizerExceptionHandler :: GHC.IO.Handle.Types.Handle -> GHC.Exception.Type.SomeException -> GHC.Types.IO ()
  runFinalizerBatch :: GHC.Types.Int -> GHC.Prim.Array# (GHC.Prim.State# GHC.Prim.RealWorld -> GHC.Prim.State# GHC.Prim.RealWorld) -> GHC.Types.IO ()
  setFinalizerExceptionHandler :: (GHC.Exception.Type.SomeException -> GHC.Types.IO ()) -> GHC.Types.IO ()

module GHC.Word where
  -- Safety: Trustworthy
  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: Trustworthy
  type Floating :: * -> Constraint
  class GHC.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.Float.RealFloat a => GHC.Num.Integer.Integer -> a -> ([GHC.Types.Int], GHC.Types.Int)
  fromRat :: forall a. GHC.Float.RealFloat a => GHC.Real.Rational -> a
  lexDigits :: Text.ParserCombinators.ReadP.ReadS GHC.Base.String
  readBin :: forall a. (GHC.Classes.Eq a, GHC.Num.Num a) => Text.ParserCombinators.ReadP.ReadS a
  readDec :: forall a. (GHC.Classes.Eq a, GHC.Num.Num a) => Text.ParserCombinators.ReadP.ReadS a
  readFloat :: forall a. GHC.Real.RealFrac a => Text.ParserCombinators.ReadP.ReadS a
  readHex :: forall a. (GHC.Classes.Eq a, GHC.Num.Num a) => Text.ParserCombinators.ReadP.ReadS a
  readInt :: forall a. GHC.Num.Num a => a -> (GHC.Types.Char -> GHC.Types.Bool) -> (GHC.Types.Char -> GHC.Types.Int) -> Text.ParserCombinators.ReadP.ReadS a
  readOct :: forall a. (GHC.Classes.Eq a, GHC.Num.Num a) => Text.ParserCombinators.ReadP.ReadS a
  readSigned :: forall a. GHC.Real.Real a => Text.ParserCombinators.ReadP.ReadS a -> Text.ParserCombinators.ReadP.ReadS a
  showBin :: forall a. GHC.Real.Integral a => a -> GHC.Show.ShowS
  showEFloat :: forall a. GHC.Float.RealFloat a => GHC.Maybe.Maybe GHC.Types.Int -> a -> GHC.Show.ShowS
  showFFloat :: forall a. GHC.Float.RealFloat a => GHC.Maybe.Maybe GHC.Types.Int -> a -> GHC.Show.ShowS
  showFFloatAlt :: forall a. GHC.Float.RealFloat a => GHC.Maybe.Maybe GHC.Types.Int -> a -> GHC.Show.ShowS
  showFloat :: forall a. GHC.Float.RealFloat a => a -> GHC.Show.ShowS
  showGFloat :: forall a. GHC.Float.RealFloat a => GHC.Maybe.Maybe GHC.Types.Int -> a -> GHC.Show.ShowS
  showGFloatAlt :: forall a. GHC.Float.RealFloat a => GHC.Maybe.Maybe GHC.Types.Int -> a -> GHC.Show.ShowS
  showHFloat :: forall a. GHC.Float.RealFloat a => a -> GHC.Show.ShowS
  showHex :: forall a. GHC.Real.Integral a => a -> GHC.Show.ShowS
  showInt :: forall a. GHC.Real.Integral a => a -> GHC.Show.ShowS
  showIntAtBase :: forall a. GHC.Real.Integral a => a -> (GHC.Types.Int -> GHC.Types.Char) -> a -> GHC.Show.ShowS
  showOct :: forall a. GHC.Real.Integral a => a -> GHC.Show.ShowS
  showSigned :: forall a. GHC.Real.Real a => (a -> GHC.Show.ShowS) -> GHC.Types.Int -> a -> GHC.Show.ShowS

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

module Prelude where
  -- Safety: Trustworthy
  (!!) :: forall a. GHC.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.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.Real.Ratio Integer
  type Read :: * -> Constraint
  class Read a where
    readsPrec :: Int -> ReadS a
    readList :: ReadS [a]
    ...
    {-# MINIMAL readsPrec | GHC.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.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.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.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.Stack.Types.HasCallStack => [a] -> a
  id :: forall a. a -> a
  init :: forall a. GHC.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.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.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.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.Base.String -> a) GHC.Base.String | OptArg (GHC.Maybe.Maybe GHC.Base.String -> a) GHC.Base.String
  type ArgOrder :: * -> *
  data ArgOrder a = RequireOrder | Permute | ReturnInOrder (GHC.Base.String -> a)
  type OptDescr :: * -> *
  data OptDescr a = Option [GHC.Types.Char] [GHC.Base.String] (ArgDescr a) GHC.Base.String
  getOpt :: forall a. ArgOrder a -> [OptDescr a] -> [GHC.Base.String] -> ([a], [GHC.Base.String], [GHC.Base.String])
  getOpt' :: forall a. ArgOrder a -> [OptDescr a] -> [GHC.Base.String] -> ([a], [GHC.Base.String], [GHC.Base.String], [GHC.Base.String])
  usageInfo :: forall a. GHC.Base.String -> [OptDescr a] -> GHC.Base.String

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

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

module System.Exit where
  -- Safety: Trustworthy
  type ExitCode :: *
  data ExitCode = ExitSuccess | ExitFailure GHC.Types.Int
  die :: forall a. GHC.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: Trustworthy
  type BufferMode :: *
  data BufferMode = NoBuffering | LineBuffering | BlockBuffering (GHC.Maybe.Maybe GHC.Types.Int)
  type FilePath :: *
  type FilePath = GHC.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.Base.String -> IO ()
  char8 :: TextEncoding
  fixIO :: forall a. (a -> IO a) -> IO a
  getChar :: IO GHC.Types.Char
  getContents :: IO GHC.Base.String
  getContents' :: IO GHC.Base.String
  getLine :: IO GHC.Base.String
  hClose :: Handle -> IO ()
  hFileSize :: Handle -> IO GHC.Num.Integer.Integer
  hFlush :: Handle -> IO ()
  hGetBuf :: forall a. Handle -> GHC.Ptr.Ptr a -> GHC.Types.Int -> IO GHC.Types.Int
  hGetBufNonBlocking :: forall a. Handle -> GHC.Ptr.Ptr a -> GHC.Types.Int -> IO GHC.Types.Int
  hGetBufSome :: forall a. Handle -> GHC.Ptr.Ptr a -> GHC.Types.Int -> IO GHC.Types.Int