base-exports.stdout-javascript-unknown-ghcjs

  type Signal = Foreign.C.Types.CInt
  runHandlers :: GHC.ForeignPtr.ForeignPtr GHC.Word.Word8 -> Signal -> GHC.Types.IO ()
  runHandlersPtr :: GHC.Ptr.Ptr GHC.Word.Word8 -> Signal -> GHC.Types.IO ()
  setHandler :: Signal -> GHC.Maybe.Maybe (HandlerFun, Data.Dynamic.Dynamic) -> GHC.Types.IO (GHC.Maybe.Maybe (HandlerFun, Data.Dynamic.Dynamic))

module GHC.Conc.Sync where
  -- Safety: Unsafe
  type BlockReason :: *
  data BlockReason = BlockedOnMVar | BlockedOnBlackHole | BlockedOnException | BlockedOnSTM | BlockedOnForeignCall | BlockedOnOther
  type PrimMVar :: *
  data PrimMVar
  type STM :: * -> *
  newtype STM a = STM (GHC.Prim.State# GHC.Prim.RealWorld -> (# GHC.Prim.State# GHC.Prim.RealWorld, a #))
  type TVar :: * -> *
  data TVar a = TVar (GHC.Prim.TVar# GHC.Prim.RealWorld a)
  type ThreadId :: *
  data ThreadId = ThreadId GHC.Prim.ThreadId#
  type ThreadStatus :: *
  data ThreadStatus = ThreadRunning | ThreadFinished | ThreadBlocked BlockReason | ThreadDied
  atomically :: forall a. STM a -> GHC.Types.IO a
  catchSTM :: forall e a. GHC.Exception.Type.Exception e => STM a -> (e -> STM a) -> STM a
  childHandler :: GHC.Exception.Type.SomeException -> GHC.Types.IO ()
  disableAllocationLimit :: GHC.Types.IO ()
  enableAllocationLimit :: GHC.Types.IO ()
  forkIO :: GHC.Types.IO () -> GHC.Types.IO ThreadId
  forkIOWithUnmask :: ((forall a. GHC.Types.IO a -> GHC.Types.IO a) -> GHC.Types.IO ()) -> GHC.Types.IO ThreadId
  forkOn :: GHC.Types.Int -> GHC.Types.IO () -> GHC.Types.IO ThreadId
  forkOnWithUnmask :: GHC.Types.Int -> ((forall a. GHC.Types.IO a -> GHC.Types.IO a) -> GHC.Types.IO ()) -> GHC.Types.IO ThreadId
  fromThreadId :: ThreadId -> GHC.Word.Word64
  getAllocationCounter :: GHC.Types.IO GHC.Int.Int64
  getNumCapabilities :: GHC.Types.IO GHC.Types.Int
  getNumProcessors :: GHC.Types.IO GHC.Types.Int
  getUncaughtExceptionHandler :: GHC.Types.IO (GHC.Exception.Type.SomeException -> GHC.Types.IO ())
  killThread :: ThreadId -> GHC.Types.IO ()
  labelThread :: ThreadId -> GHC.Base.String -> GHC.Types.IO ()
  labelThreadByteArray# :: ThreadId -> GHC.Prim.ByteArray# -> GHC.Types.IO ()
  listThreads :: GHC.Types.IO [ThreadId]
  mkWeakThreadId :: ThreadId -> GHC.Types.IO (GHC.Weak.Weak ThreadId)
  modifyMVar_ :: forall a. GHC.MVar.MVar a -> (a -> GHC.Types.IO a) -> GHC.Types.IO ()
  myThreadId :: GHC.Types.IO ThreadId
  newStablePtrPrimMVar :: forall a. GHC.MVar.MVar a -> GHC.Types.IO (GHC.Stable.StablePtr PrimMVar)
  newTVar :: forall a. a -> STM (TVar a)
  newTVarIO :: forall a. a -> GHC.Types.IO (TVar a)
  numCapabilities :: GHC.Types.Int
  numSparks :: GHC.Types.IO GHC.Types.Int
  orElse :: forall a. STM a -> STM a -> STM a
  par :: forall a b. a -> b -> b
  pseq :: forall a b. a -> b -> b
  readTVar :: forall a. TVar a -> STM a
  readTVarIO :: forall a. TVar a -> GHC.Types.IO a
  reportError :: GHC.Exception.Type.SomeException -> GHC.Types.IO ()
  reportHeapOverflow :: GHC.Types.IO ()
  reportStackOverflow :: GHC.Types.IO ()
  retry :: forall a. STM a
  runSparks :: GHC.Types.IO ()
  setAllocationCounter :: GHC.Int.Int64 -> GHC.Types.IO ()
  setNumCapabilities :: GHC.Types.Int -> GHC.Types.IO ()
  setUncaughtExceptionHandler :: (GHC.Exception.Type.SomeException -> GHC.Types.IO ()) -> GHC.Types.IO ()
  sharedCAF :: forall a. a -> (GHC.Ptr.Ptr a -> GHC.Types.IO (GHC.Ptr.Ptr a)) -> GHC.Types.IO a
  showThreadId :: ThreadId -> GHC.Base.String
  threadCapability :: ThreadId -> GHC.Types.IO (GHC.Types.Int, GHC.Types.Bool)
  threadLabel :: ThreadId -> GHC.Types.IO (GHC.Maybe.Maybe GHC.Base.String)
  threadStatus :: ThreadId -> GHC.Types.IO ThreadStatus
  throwSTM :: forall e a. GHC.Exception.Type.Exception e => e -> STM a
  throwTo :: forall e. GHC.Exception.Type.Exception e => ThreadId -> e -> GHC.Types.IO ()
  unsafeIOToSTM :: forall a. GHC.Types.IO a -> STM a
  withMVar :: forall a b. GHC.MVar.MVar a -> (a -> GHC.Types.IO b) -> GHC.Types.IO b
  writeTVar :: forall a. TVar a -> a -> STM ()
  yield :: GHC.Types.IO ()

module GHC.ConsoleHandler where
  -- Safety: Trustworthy

module GHC.Constants where
  -- Safety: Trustworthy

module GHC.Desugar where
  -- Safety: Trustworthy
  (>>>) :: forall (arr :: * -> * -> *) a b c. Control.Arrow.Arrow arr => arr a b -> arr b c -> arr a c
  type AnnotationWrapper :: *
  data AnnotationWrapper = forall a. Data.Data.Data a => AnnotationWrapper a
  toAnnotationWrapper :: forall a. Data.Data.Data a => a -> AnnotationWrapper

module GHC.Encoding.UTF8 where
  -- Safety: None
  utf8CompareByteArray# :: GHC.Prim.ByteArray# -> GHC.Prim.ByteArray# -> GHC.Types.Ordering
  utf8CountCharsByteArray# :: GHC.Prim.ByteArray# -> GHC.Types.Int
  utf8DecodeByteArray# :: GHC.Prim.ByteArray# -> [GHC.Types.Char]
  utf8DecodeCharAddr# :: GHC.Prim.Addr# -> GHC.Prim.Int# -> (# GHC.Prim.Char#, GHC.Prim.Int# #)
  utf8DecodeCharByteArray# :: GHC.Prim.ByteArray# -> GHC.Prim.Int# -> (# GHC.Prim.Char#, GHC.Prim.Int# #)
  utf8DecodeCharPtr :: GHC.Ptr.Ptr GHC.Word.Word8 -> (GHC.Types.Char, GHC.Types.Int)
  utf8DecodeForeignPtr :: GHC.ForeignPtr.ForeignPtr GHC.Word.Word8 -> GHC.Types.Int -> GHC.Types.Int -> [GHC.Types.Char]
  utf8EncodeByteArray# :: GHC.Base.String -> GHC.Prim.ByteArray#
  utf8EncodePtr :: GHC.Ptr.Ptr GHC.Word.Word8 -> GHC.Base.String -> GHC.Types.IO ()
  utf8EncodedLength :: GHC.Base.String -> GHC.Types.Int

module GHC.Enum where
  -- Safety: Trustworthy
  type Bounded :: * -> Constraint
  class Bounded a where
    minBound :: a
    maxBound :: a
    {-# MINIMAL minBound, maxBound #-}
  type Enum :: * -> Constraint
  class Enum a where
    succ :: a -> a
    pred :: a -> a
    toEnum :: GHC.Types.Int -> a
    fromEnum :: a -> GHC.Types.Int
    enumFrom :: a -> [a]
    enumFromThen :: a -> a -> [a]
    enumFromTo :: a -> a -> [a]
    enumFromThenTo :: a -> a -> a -> [a]
    {-# MINIMAL toEnum, fromEnum #-}
  boundedEnumFrom :: forall a. (Enum a, Bounded a) => a -> [a]
  boundedEnumFromThen :: forall a. (Enum a, Bounded a) => a -> a -> [a]
  fromEnumError :: forall a b. GHC.Show.Show a => GHC.Base.String -> a -> b
  predError :: forall a. GHC.Base.String -> a
  succError :: forall a. GHC.Base.String -> a
  toEnumError :: forall a b. GHC.Show.Show a => GHC.Base.String -> GHC.Types.Int -> (a, a) -> b

module GHC.Environment where
  -- Safety: Trustworthy
  getFullArgs :: GHC.Types.IO [GHC.Base.String]

module GHC.Err where
  -- Safety: Trustworthy
  absentErr :: forall a. a
  error :: forall (r :: GHC.Types.RuntimeRep) (a :: TYPE r). GHC.Stack.Types.HasCallStack => [GHC.Types.Char] -> a
  errorWithoutStackTrace :: forall (r :: GHC.Types.RuntimeRep) (a :: TYPE r). [GHC.Types.Char] -> a
  undefined :: forall (r :: GHC.Types.RuntimeRep) (a :: TYPE r). GHC.Stack.Types.HasCallStack => a

module GHC.Event where
  -- Safety: Trustworthy

module GHC.Event.TimeOut where
  -- Safety: None
  type TimeoutCallback :: *
  type TimeoutCallback = GHC.Types.IO ()
  type TimeoutEdit :: *
  type TimeoutEdit = TimeoutQueue -> TimeoutQueue
  type TimeoutKey :: *
  newtype TimeoutKey = TK base-4.18.0.0:GHC.Event.Unique.Unique
  type TimeoutQueue :: *
  type TimeoutQueue = base-4.18.0.0:GHC.Event.PSQ.PSQ TimeoutCallback

module GHC.Exception where
  -- Safety: Trustworthy
  type ArithException :: *
  data ArithException = Overflow | Underflow | LossOfPrecision | DivideByZero | Denormal | RatioZeroDenominator
  type CallStack :: *
  data CallStack = ...
  pattern ErrorCall :: GHC.Base.String -> ErrorCall
  type ErrorCall :: *
  data ErrorCall = ErrorCallWithLocation GHC.Base.String GHC.Base.String
  type Exception :: * -> Constraint
  class (base-4.18.0.0:Data.Typeable.Internal.Typeable e, GHC.Show.Show e) => Exception e where
    toException :: e -> SomeException
    fromException :: SomeException -> GHC.Maybe.Maybe e
    displayException :: e -> GHC.Base.String
    {-# MINIMAL #-}
  type SomeException :: *
  data SomeException = forall e. Exception e => SomeException e
  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}
  divZeroException :: SomeException
  errorCallException :: GHC.Base.String -> SomeException
  errorCallWithCallStackException :: GHC.Base.String -> CallStack -> SomeException
  fromCallSiteList :: [([GHC.Types.Char], SrcLoc)] -> CallStack
  getCallStack :: CallStack -> [([GHC.Types.Char], SrcLoc)]
  overflowException :: SomeException
  prettyCallStack :: CallStack -> GHC.Base.String
  prettyCallStackLines :: CallStack -> [GHC.Base.String]
  prettySrcLoc :: SrcLoc -> GHC.Base.String
  ratioZeroDenomException :: SomeException
  showCCSStack :: [GHC.Base.String] -> [GHC.Base.String]
  throw :: forall (r :: GHC.Types.RuntimeRep) (a :: TYPE r) e. Exception e => e -> a
  underflowException :: SomeException

module GHC.Exception.Type where
  -- Safety: Trustworthy
  type ArithException :: *
  data ArithException = Overflow | Underflow | LossOfPrecision | DivideByZero | Denormal | RatioZeroDenominator
  type Exception :: * -> Constraint
  class (base-4.18.0.0:Data.Typeable.Internal.Typeable e, GHC.Show.Show e) => Exception e where
    toException :: e -> SomeException
    fromException :: SomeException -> GHC.Maybe.Maybe e
    displayException :: e -> GHC.Base.String
    {-# MINIMAL #-}
  type SomeException :: *
  data SomeException = forall e. Exception e => SomeException e
  divZeroException :: SomeException
  overflowException :: SomeException
  ratioZeroDenomException :: SomeException
  underflowException :: SomeException

module GHC.ExecutionStack where
  -- Safety: None
  type Location :: *
  data Location = Location {objectName :: GHC.Base.String, functionName :: GHC.Base.String, srcLoc :: GHC.Maybe.Maybe SrcLoc}
  type SrcLoc :: *
  data SrcLoc = SrcLoc {sourceFile :: GHC.Base.String, sourceLine :: GHC.Types.Int, sourceColumn :: GHC.Types.Int}
  getStackTrace :: GHC.Types.IO (GHC.Maybe.Maybe [Location])
  showStackTrace :: GHC.Types.IO (GHC.Maybe.Maybe GHC.Base.String)

module GHC.ExecutionStack.Internal where
  -- Safety: None
  type Location :: *
  data Location = Location {objectName :: GHC.Base.String, functionName :: GHC.Base.String, srcLoc :: GHC.Maybe.Maybe SrcLoc}
  type SrcLoc :: *
  data SrcLoc = SrcLoc {sourceFile :: GHC.Base.String, sourceLine :: GHC.Types.Int, sourceColumn :: GHC.Types.Int}
  type StackTrace :: *
  newtype StackTrace = ...
  collectStackTrace :: GHC.Types.IO (GHC.Maybe.Maybe StackTrace)
  invalidateDebugCache :: GHC.Types.IO ()
  showStackFrames :: [Location] -> GHC.Show.ShowS
  stackDepth :: StackTrace -> GHC.Types.Int
  stackFrames :: StackTrace -> GHC.Maybe.Maybe [Location]

module GHC.Exts where
  -- Safety: Unsafe
  (*#) :: Int# -> Int# -> Int#
  (*##) :: Double# -> Double# -> Double#
  (**##) :: Double# -> Double# -> Double#
  (+#) :: Int# -> Int# -> Int#
  (+##) :: Double# -> Double# -> Double#
  (-#) :: Int# -> Int# -> Int#
  (-##) :: Double# -> Double# -> Double#
  (/##) :: Double# -> Double# -> Double#
  (/=#) :: Int# -> Int# -> Int#
  (/=##) :: Double# -> Double# -> Int#
  (<#) :: Int# -> Int# -> Int#
  (<##) :: Double# -> Double# -> Int#
  (<=#) :: Int# -> Int# -> Int#
  (<=##) :: Double# -> Double# -> Int#
  (==#) :: Int# -> Int# -> Int#
  (==##) :: Double# -> Double# -> Int#
  (>#) :: Int# -> Int# -> Int#
  (>##) :: Double# -> Double# -> Int#
  (>=#) :: Int# -> Int# -> Int#
  (>=##) :: Double# -> Double# -> Int#
  type Addr# :: TYPE AddrRep
  data Addr#
  type Any :: forall k. k
  type family Any where
  type Array# :: forall {l :: Levity}. TYPE (BoxedRep l) -> UnliftedType
  data Array# a
  type ArrayArray# :: UnliftedType
  newtype ArrayArray# = ArrayArray# (Array# ByteArray#)
  type BCO :: *
  data BCO
  type Bool :: *
  data Bool = False | True
  type ByteArray# :: UnliftedType
  data ByteArray#
  type role CONSTRAINT nominal
  type CONSTRAINT :: RuntimeRep -> *
  data CONSTRAINT a
  type Char :: *
  data Char = C# Char#
  type Char# :: TYPE WordRep
  data Char#
  type role Coercible representational representational
  type Coercible :: forall k. k -> k -> Constraint
  class Coercible a b => Coercible a b
    {-# MINIMAL #-}
  type Compact# :: UnliftedType
  data Compact#
  type Constraint :: *
  type Constraint = CONSTRAINT LiftedRep
  type DictBox :: Constraint -> *
  data DictBox a = a => MkDictBox
  type Double :: *
  data Double = D# Double#
  type Double# :: TYPE DoubleRep
  data Double#
  type DoubleBox :: TYPE DoubleRep -> *
  data DoubleBox a = MkDoubleBox a
  type DoubleX2# :: TYPE (VecRep Vec2 DoubleElemRep)
  data DoubleX2#
  type DoubleX4# :: TYPE (VecRep Vec4 DoubleElemRep)
  data DoubleX4#
  type DoubleX8# :: TYPE (VecRep Vec8 DoubleElemRep)
  data DoubleX8#
  type Down :: * -> *
  newtype Down a = Down {getDown :: a}
  type role FUN nominal representational representational
  type FUN :: forall (n :: Multiplicity) -> forall {q :: RuntimeRep} {r :: RuntimeRep}. TYPE q -> TYPE r -> *
  data FUN n a b
  type Float :: *
  data Float = F# Float#
  type Float# :: TYPE FloatRep
  data Float#
  type FloatBox :: TYPE FloatRep -> *
  data FloatBox a = MkFloatBox a
  type FloatX16# :: TYPE (VecRep Vec16 FloatElemRep)
  data FloatX16#
  type FloatX4# :: TYPE (VecRep Vec4 FloatElemRep)
  data FloatX4#
  type FloatX8# :: TYPE (VecRep Vec8 FloatElemRep)
  data FloatX8#
  type role FunPtr phantom
  type FunPtr :: * -> *
  data FunPtr a = FunPtr Addr#
  type role IOPort# nominal representational
  type IOPort# :: forall {l :: Levity}. * -> TYPE (BoxedRep l) -> UnliftedType
  data IOPort# a b
  type Int :: *
  data Int = I# Int#
  type Int# :: TYPE IntRep
  data Int#
  type Int16# :: TYPE Int16Rep
  data Int16#
  type Int16X16# :: TYPE (VecRep Vec16 Int16ElemRep)
  data Int16X16#
  type Int16X32# :: TYPE (VecRep Vec32 Int16ElemRep)
  data Int16X32#
  type Int16X8# :: TYPE (VecRep Vec8 Int16ElemRep)
  data Int16X8#
  type Int32# :: TYPE Int32Rep
  data Int32#
  type Int32X16# :: TYPE (VecRep Vec16 Int32ElemRep)
  data Int32X16#
  type Int32X4# :: TYPE (VecRep Vec4 Int32ElemRep)
  data Int32X4#
  type Int32X8# :: TYPE (VecRep Vec8 Int32ElemRep)
  data Int32X8#
  type Int64# :: TYPE Int64Rep
  data Int64#
  type Int64X2# :: TYPE (VecRep Vec2 Int64ElemRep)
  data Int64X2#
  type Int64X4# :: TYPE (VecRep Vec4 Int64ElemRep)
  data Int64X4#
  type Int64X8# :: TYPE (VecRep Vec8 Int64ElemRep)
  data Int64X8#
  type Int8# :: TYPE Int8Rep
  data Int8#
  type Int8X16# :: TYPE (VecRep Vec16 Int8ElemRep)
  data Int8X16#
  type Int8X32# :: TYPE (VecRep Vec32 Int8ElemRep)
  data Int8X32#
  type Int8X64# :: TYPE (VecRep Vec64 Int8ElemRep)
  data Int8X64#
  type IntBox :: TYPE IntRep -> *
  data IntBox a = MkIntBox a
  type IsList :: * -> Constraint
  class IsList l where
    type Item :: * -> *
    type family Item l
    fromList :: [Item l] -> l
    fromListN :: Int -> [Item l] -> l
    toList :: l -> [Item l]
    {-# MINIMAL fromList, toList #-}
  type IsString :: * -> Constraint
  class IsString a where
    fromString :: GHC.Base.String -> a
    {-# MINIMAL fromString #-}
  KindRepApp :: GHC.Types.KindRep -> GHC.Types.KindRep -> GHC.Types.KindRep
  KindRepFun :: GHC.Types.KindRep -> GHC.Types.KindRep -> GHC.Types.KindRep
  KindRepTYPE :: RuntimeRep -> GHC.Types.KindRep
  KindRepTyConApp :: GHC.Types.TyCon -> [GHC.Types.KindRep] -> GHC.Types.KindRep
  KindRepTypeLitD :: GHC.Types.TypeLitSort -> [Char] -> GHC.Types.KindRep
  KindRepTypeLitS :: GHC.Types.TypeLitSort -> Addr# -> GHC.Types.KindRep
  KindRepVar :: GHC.Types.KindBndr -> GHC.Types.KindRep
  type Levity :: *
  data Levity = Lifted | Unlifted
  type LiftedRep :: RuntimeRep
  type LiftedRep = BoxedRep Lifted :: RuntimeRep
  type List :: * -> *
  data List a = ...
  type role MVar# nominal representational
  type MVar# :: forall {l :: Levity}. * -> TYPE (BoxedRep l) -> UnliftedType
  data MVar# a b
  type MultMul :: Multiplicity -> Multiplicity -> Multiplicity
  type family MultMul a b where
    forall (x :: Multiplicity). MultMul One x = x
    forall (x :: Multiplicity). MultMul x One = x
    forall (x :: Multiplicity). MultMul Many x = Many
    forall (x :: Multiplicity). MultMul x Many = Many
  type Multiplicity :: *
  data Multiplicity = One | Many
  type role MutVar# nominal representational
  type MutVar# :: forall {l :: Levity}. * -> TYPE (BoxedRep l) -> UnliftedType
  data MutVar# a b
  type role MutableArray# nominal representational
  type MutableArray# :: forall {l :: Levity}. * -> TYPE (BoxedRep l) -> UnliftedType
  data MutableArray# a b
  type role MutableArrayArray# nominal
  type MutableArrayArray# :: * -> UnliftedType
  newtype MutableArrayArray# s = MutableArrayArray# (MutableArray# s ByteArray#)
  type role MutableByteArray# nominal
  type MutableByteArray# :: * -> UnliftedType
  data MutableByteArray# a
  type Ordering :: *
  data Ordering = LT | EQ | GT
  type PromptTag# :: * -> UnliftedType
  data PromptTag# a
  type role Proxy# phantom
  type Proxy# :: forall k. k -> ZeroBitType
  data Proxy# a
  type role Ptr phantom
  type Ptr :: * -> *
  data Ptr a = Ptr Addr#
  type RealWorld :: *
  data RealWorld
  type RuntimeRep :: *
  data RuntimeRep = VecRep VecCount VecElem | TupleRep [RuntimeRep] | SumRep [RuntimeRep] | BoxedRep Levity | IntRep | Int8Rep | Int16Rep | Int32Rep | Int64Rep | WordRep | Word8Rep | Word16Rep | Word32Rep | Word64Rep | AddrRep | FloatRep | DoubleRep
  type SPEC :: *
  data SPEC = SPEC | SPEC2
  type SmallArray# :: forall {l :: Levity}. TYPE (BoxedRep l) -> UnliftedType
  data SmallArray# a
  type role SmallMutableArray# nominal representational
  type SmallMutableArray# :: forall {l :: Levity}. * -> TYPE (BoxedRep l) -> UnliftedType
  data SmallMutableArray# a b
  type SpecConstrAnnotation :: *
  data SpecConstrAnnotation = NoSpecConstr | ForceSpecConstr
  type role StableName# phantom
  type StableName# :: forall {l :: Levity}. TYPE (BoxedRep l) -> UnliftedType
  data StableName# a
  type StablePtr# :: forall {l :: Levity}. TYPE (BoxedRep l) -> TYPE AddrRep
  data StablePtr# a
  type StackSnapshot# :: UnliftedType
  data StackSnapshot#
  type role State# nominal
  type State# :: * -> ZeroBitType
  data State# a
  type Symbol :: *
  data Symbol
  type role TVar# nominal representational
  type TVar# :: forall {l :: Levity}. * -> TYPE (BoxedRep l) -> UnliftedType
  data TVar# a b
  type role TYPE nominal
  type TYPE :: RuntimeRep -> *
  data TYPE a
  type ThreadId# :: UnliftedType
  data ThreadId#
  TrNameD :: [Char] -> GHC.Types.TrName
  TrNameS :: Addr# -> GHC.Types.TrName
  TypeLitChar :: GHC.Types.TypeLitSort
  TypeLitNat :: GHC.Types.TypeLitSort
  TypeLitSymbol :: GHC.Types.TypeLitSort
  type UnliftedRep :: RuntimeRep
  type UnliftedRep = BoxedRep Unlifted :: RuntimeRep
  type UnliftedType :: *
  type UnliftedType = TYPE UnliftedRep
  type VecCount :: *
  data VecCount = Vec2 | Vec4 | Vec8 | Vec16 | Vec32 | Vec64
  type VecElem :: *
  data VecElem = Int8ElemRep | Int16ElemRep | Int32ElemRep | Int64ElemRep | Word8ElemRep | Word16ElemRep | Word32ElemRep | Word64ElemRep | FloatElemRep | DoubleElemRep
  type Void# :: ZeroBitType
  type Void# = (# #) :: ZeroBitType
  type Weak# :: forall {l :: Levity}. TYPE (BoxedRep l) -> UnliftedType
  data Weak# a
  type WithDict :: Constraint -> * -> Constraint
  class WithDict cls meth where
    withDict :: forall {rr :: RuntimeRep} (r :: TYPE rr). meth -> (cls => r) -> r
    {-# MINIMAL withDict #-}
  type Word :: *
  data Word = W# Word#
  type Word# :: TYPE WordRep
  data Word#
  type Word16# :: TYPE Word16Rep
  data Word16#
  type Word16X16# :: TYPE (VecRep Vec16 Word16ElemRep)
  data Word16X16#
  type Word16X32# :: TYPE (VecRep Vec32 Word16ElemRep)
  data Word16X32#
  type Word16X8# :: TYPE (VecRep Vec8 Word16ElemRep)
  data Word16X8#
  type Word32# :: TYPE Word32Rep
  data Word32#
  type Word32X16# :: TYPE (VecRep Vec16 Word32ElemRep)
  data Word32X16#
  type Word32X4# :: TYPE (VecRep Vec4 Word32ElemRep)
  data Word32X4#
  type Word32X8# :: TYPE (VecRep Vec8 Word32ElemRep)
  data Word32X8#
  type Word64# :: TYPE Word64Rep
  data Word64#
  type Word64X2# :: TYPE (VecRep Vec2 Word64ElemRep)
  data Word64X2#
  type Word64X4# :: TYPE (VecRep Vec4 Word64ElemRep)
  data Word64X4#
  type Word64X8# :: TYPE (VecRep Vec8 Word64ElemRep)
  data Word64X8#
  type Word8# :: TYPE Word8Rep
  data Word8#
  type Word8X16# :: TYPE (VecRep Vec16 Word8ElemRep)
  data Word8X16#
  type Word8X32# :: TYPE (VecRep Vec32 Word8ElemRep)
  data Word8X32#
  type Word8X64# :: TYPE (VecRep Vec64 Word8ElemRep)
  data Word8X64#
  type WordBox :: TYPE WordRep -> *
  data WordBox a = MkWordBox a
  type ZeroBitRep :: RuntimeRep
  type ZeroBitRep = TupleRep '[] :: RuntimeRep
  type ZeroBitType :: *
  type ZeroBitType = TYPE ZeroBitRep
  acosDouble# :: Double# -> Double#
  acosFloat# :: Float# -> Float#
  acoshDouble# :: Double# -> Double#
  acoshFloat# :: Float# -> Float#
  addCFinalizerToWeak# :: forall {k :: Levity} (b :: TYPE (BoxedRep k)). Addr# -> Addr# -> Int# -> Addr# -> Weak# b -> State# RealWorld -> (# State# RealWorld, Int# #)
  addIntC# :: Int# -> Int# -> (# Int#, Int# #)
  addWordC# :: Word# -> Word# -> (# Word#, Int# #)
  addr2Int# :: Addr# -> Int#
  addrToAny# :: forall {l :: Levity} (a :: TYPE (BoxedRep l)). Addr# -> (# a #)
  and# :: Word# -> Word# -> Word#
  and64# :: Word64# -> Word64# -> Word64#
  andI# :: Int# -> Int# -> Int#
  andWord16# :: Word16# -> Word16# -> Word16#
  andWord32# :: Word32# -> Word32# -> Word32#
  andWord8# :: Word8# -> Word8# -> Word8#
  anyToAddr# :: forall a. a -> State# RealWorld -> (# State# RealWorld, Addr# #)
  asinDouble# :: Double# -> Double#
  asinFloat# :: Float# -> Float#
  asinhDouble# :: Double# -> Double#
  asinhFloat# :: Float# -> Float#
  atanDouble# :: Double# -> Double#
  atanFloat# :: Float# -> Float#
  atanhDouble# :: Double# -> Double#
  atanhFloat# :: Float# -> Float#
  atomicCasAddrAddr# :: forall d. Addr# -> Addr# -> Addr# -> State# d -> (# State# d, Addr# #)
  atomicCasWord16Addr# :: forall d. Addr# -> Word16# -> Word16# -> State# d -> (# State# d, Word16# #)
  atomicCasWord32Addr# :: forall d. Addr# -> Word32# -> Word32# -> State# d -> (# State# d, Word32# #)
  atomicCasWord64Addr# :: forall d. Addr# -> Word64# -> Word64# -> State# d -> (# State# d, Word64# #)
  atomicCasWord8Addr# :: forall d. Addr# -> Word8# -> Word8# -> State# d -> (# State# d, Word8# #)
  atomicCasWordAddr# :: forall d. Addr# -> Word# -> Word# -> State# d -> (# State# d, Word# #)
  atomicExchangeAddrAddr# :: forall d. Addr# -> Addr# -> State# d -> (# State# d, Addr# #)
  atomicExchangeWordAddr# :: forall d. Addr# -> Word# -> State# d -> (# State# d, Word# #)
  atomicModifyMutVar# :: forall s a b c. MutVar# s a -> (a -> b) -> State# s -> (# State# s, c #)
  atomicModifyMutVar2# :: forall d a c. MutVar# d a -> (a -> c) -> State# d -> (# State# d, a, c #)
  atomicModifyMutVar_# :: forall d a. MutVar# d a -> (a -> a) -> State# d -> (# State# d, a, a #)
  atomicReadIntArray# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Int# #)
  atomicReadWordAddr# :: forall d. Addr# -> State# d -> (# State# d, Word# #)
  atomicSwapMutVar# :: forall {l :: Levity} d (a :: TYPE (BoxedRep l)). MutVar# d a -> a -> State# d -> (# State# d, a #)
  atomicWriteIntArray# :: forall d. MutableByteArray# d -> Int# -> Int# -> State# d -> State# d
  atomicWriteWordAddr# :: forall d. Addr# -> Word# -> State# d -> State# d
  atomically# :: forall {l :: Levity} (a :: TYPE (BoxedRep l)). (State# RealWorld -> (# State# RealWorld, a #)) -> State# RealWorld -> (# State# RealWorld, a #)
  augment :: forall a. (forall b. (a -> b -> b) -> b -> b) -> [a] -> [a]
  bitReverse# :: Word# -> Word#
  bitReverse16# :: Word# -> Word#
  bitReverse32# :: Word# -> Word#
  bitReverse64# :: Word64# -> Word64#
  bitReverse8# :: Word# -> Word#
  breakpoint :: forall a. a -> a
  breakpointCond :: forall a. Bool -> a -> a
  broadcastDoubleX2# :: Double# -> DoubleX2#
  broadcastDoubleX4# :: Double# -> DoubleX4#
  broadcastDoubleX8# :: Double# -> DoubleX8#
  broadcastFloatX16# :: Float# -> FloatX16#
  broadcastFloatX4# :: Float# -> FloatX4#
  broadcastFloatX8# :: Float# -> FloatX8#
  broadcastInt16X16# :: Int16# -> Int16X16#
  broadcastInt16X32# :: Int16# -> Int16X32#
  broadcastInt16X8# :: Int16# -> Int16X8#
  broadcastInt32X16# :: Int32# -> Int32X16#
  broadcastInt32X4# :: Int32# -> Int32X4#
  broadcastInt32X8# :: Int32# -> Int32X8#
  broadcastInt64X2# :: Int64# -> Int64X2#
  broadcastInt64X4# :: Int64# -> Int64X4#
  broadcastInt64X8# :: Int64# -> Int64X8#
  broadcastInt8X16# :: Int8# -> Int8X16#
  broadcastInt8X32# :: Int8# -> Int8X32#
  broadcastInt8X64# :: Int8# -> Int8X64#
  broadcastWord16X16# :: Word16# -> Word16X16#
  broadcastWord16X32# :: Word16# -> Word16X32#
  broadcastWord16X8# :: Word16# -> Word16X8#
  broadcastWord32X16# :: Word32# -> Word32X16#
  broadcastWord32X4# :: Word32# -> Word32X4#
  broadcastWord32X8# :: Word32# -> Word32X8#
  broadcastWord64X2# :: Word64# -> Word64X2#
  broadcastWord64X4# :: Word64# -> Word64X4#
  broadcastWord64X8# :: Word64# -> Word64X8#
  broadcastWord8X16# :: Word8# -> Word8X16#
  broadcastWord8X32# :: Word8# -> Word8X32#
  broadcastWord8X64# :: Word8# -> Word8X64#
  build :: forall a. (forall b. (a -> b -> b) -> b -> b) -> [a]
  byteArrayContents# :: ByteArray# -> Addr#
  byteSwap# :: Word# -> Word#
  byteSwap16# :: Word# -> Word#
  byteSwap32# :: Word# -> Word#
  byteSwap64# :: Word64# -> Word64#
  casArray# :: forall {l :: Levity} d (a :: TYPE (BoxedRep l)). MutableArray# d a -> Int# -> a -> a -> State# d -> (# State# d, Int#, a #)
  casInt16Array# :: forall d. MutableByteArray# d -> Int# -> Int16# -> Int16# -> State# d -> (# State# d, Int16# #)
  casInt32Array# :: forall d. MutableByteArray# d -> Int# -> Int32# -> Int32# -> State# d -> (# State# d, Int32# #)
  casInt64Array# :: forall d. MutableByteArray# d -> Int# -> Int64# -> Int64# -> State# d -> (# State# d, Int64# #)
  casInt8Array# :: forall d. MutableByteArray# d -> Int# -> Int8# -> Int8# -> State# d -> (# State# d, Int8# #)
  casIntArray# :: forall d. MutableByteArray# d -> Int# -> Int# -> Int# -> State# d -> (# State# d, Int# #)
  casMutVar# :: forall {l :: Levity} d (a :: TYPE (BoxedRep l)). MutVar# d a -> a -> a -> State# d -> (# State# d, Int#, a #)
  casSmallArray# :: forall {l :: Levity} d (a :: TYPE (BoxedRep l)). SmallMutableArray# d a -> Int# -> a -> a -> State# d -> (# State# d, Int#, a #)
  catch# :: forall {q :: RuntimeRep} {k :: Levity} (a :: TYPE q) (b :: TYPE (BoxedRep k)). (State# RealWorld -> (# State# RealWorld, a #)) -> (b -> State# RealWorld -> (# State# RealWorld, a #)) -> State# RealWorld -> (# State# RealWorld, a #)
  catchRetry# :: forall {l :: Levity} (a :: TYPE (BoxedRep l)). (State# RealWorld -> (# State# RealWorld, a #)) -> (State# RealWorld -> (# State# RealWorld, a #)) -> State# RealWorld -> (# State# RealWorld, a #)
  catchSTM# :: forall {l :: Levity} (a :: TYPE (BoxedRep l)) b. (State# RealWorld -> (# State# RealWorld, a #)) -> (b -> State# RealWorld -> (# State# RealWorld, a #)) -> State# RealWorld -> (# State# RealWorld, a #)
  chr# :: Int# -> Char#
  clearCCS# :: forall d a. (State# d -> (# State# d, a #)) -> State# d -> (# State# d, a #)
  cloneArray# :: forall {l :: Levity} (a :: TYPE (BoxedRep l)). Array# a -> Int# -> Int# -> Array# a
  cloneMutableArray# :: forall {l :: Levity} d (a :: TYPE (BoxedRep l)). MutableArray# d a -> Int# -> Int# -> State# d -> (# State# d, MutableArray# d a #)
  cloneSmallArray# :: forall {l :: Levity} (a :: TYPE (BoxedRep l)). SmallArray# a -> Int# -> Int# -> SmallArray# a
  cloneSmallMutableArray# :: forall {l :: Levity} d (a :: TYPE (BoxedRep l)). SmallMutableArray# d a -> Int# -> Int# -> State# d -> (# State# d, SmallMutableArray# d a #)
  closureSize# :: forall a. a -> Int#
  clz# :: Word# -> Word#
  clz16# :: Word# -> Word#
  clz32# :: Word# -> Word#
  clz64# :: Word64# -> Word#
  clz8# :: Word# -> Word#
  coerce :: forall {k :: RuntimeRep} (a :: TYPE k) (b :: TYPE k). Coercible a b => a -> b
  compactAdd# :: forall a. Compact# -> a -> State# RealWorld -> (# State# RealWorld, a #)
  compactAddWithSharing# :: forall a. Compact# -> a -> State# RealWorld -> (# State# RealWorld, a #)
  compactAllocateBlock# :: Word# -> Addr# -> State# RealWorld -> (# State# RealWorld, Addr# #)
  compactContains# :: forall a. Compact# -> a -> State# RealWorld -> (# State# RealWorld, Int# #)
  compactContainsAny# :: forall a. a -> State# RealWorld -> (# State# RealWorld, Int# #)
  compactFixupPointers# :: Addr# -> Addr# -> State# RealWorld -> (# State# RealWorld, Compact#, Addr# #)
  compactGetFirstBlock# :: Compact# -> State# RealWorld -> (# State# RealWorld, Addr#, Word# #)
  compactGetNextBlock# :: Compact# -> Addr# -> State# RealWorld -> (# State# RealWorld, Addr#, Word# #)
  compactNew# :: Word# -> State# RealWorld -> (# State# RealWorld, Compact# #)
  compactResize# :: Compact# -> Word# -> State# RealWorld -> State# RealWorld
  compactSize# :: Compact# -> State# RealWorld -> (# State# RealWorld, Word# #)
  compareByteArrays# :: ByteArray# -> Int# -> ByteArray# -> Int# -> Int# -> Int#
  considerAccessible :: Bool
  control0# :: forall {r :: RuntimeRep} a (b :: TYPE r). PromptTag# a -> (((State# RealWorld -> (# State# RealWorld, b #)) -> State# RealWorld -> (# State# RealWorld, a #)) -> State# RealWorld -> (# State# RealWorld, a #)) -> State# RealWorld -> (# State# RealWorld, b #)
  copyAddrToAddr# :: Addr# -> Addr# -> Int# -> State# RealWorld -> State# RealWorld
  copyAddrToAddrNonOverlapping# :: Addr# -> Addr# -> Int# -> State# RealWorld -> State# RealWorld
  copyAddrToByteArray# :: forall d. Addr# -> MutableByteArray# d -> Int# -> Int# -> State# d -> State# d
  copyArray# :: forall {l :: Levity} (a :: TYPE (BoxedRep l)) d. Array# a -> Int# -> MutableArray# d a -> Int# -> Int# -> State# d -> State# d
  copyArrayArray# :: forall s. ArrayArray# -> Int# -> MutableArrayArray# s -> Int# -> Int# -> State# s -> State# s
  copyByteArray# :: forall d. ByteArray# -> Int# -> MutableByteArray# d -> Int# -> Int# -> State# d -> State# d
  copyByteArrayToAddr# :: forall d. ByteArray# -> Int# -> Addr# -> Int# -> State# d -> State# d
  copyMutableArray# :: forall {l :: Levity} d (a :: TYPE (BoxedRep l)). MutableArray# d a -> Int# -> MutableArray# d a -> Int# -> Int# -> State# d -> State# d
  copyMutableArrayArray# :: forall s. MutableArrayArray# s -> Int# -> MutableArrayArray# s -> Int# -> Int# -> State# s -> State# s
  copyMutableByteArray# :: forall d. MutableByteArray# d -> Int# -> MutableByteArray# d -> Int# -> Int# -> State# d -> State# d
  copyMutableByteArrayNonOverlapping# :: forall d. MutableByteArray# d -> Int# -> MutableByteArray# d -> Int# -> Int# -> State# d -> State# d
  copyMutableByteArrayToAddr# :: forall d. MutableByteArray# d -> Int# -> Addr# -> Int# -> State# d -> State# d
  copySmallArray# :: forall {l :: Levity} (a :: TYPE (BoxedRep l)) d. SmallArray# a -> Int# -> SmallMutableArray# d a -> Int# -> Int# -> State# d -> State# d
  copySmallMutableArray# :: forall {l :: Levity} d (a :: TYPE (BoxedRep l)). SmallMutableArray# d a -> Int# -> SmallMutableArray# d a -> Int# -> Int# -> State# d -> State# d
  cosDouble# :: Double# -> Double#
  cosFloat# :: Float# -> Float#
  coshDouble# :: Double# -> Double#
  coshFloat# :: Float# -> Float#
  cstringLength# :: Addr# -> Int#
  ctz# :: Word# -> Word#
  ctz16# :: Word# -> Word#
  ctz32# :: Word# -> Word#
  ctz64# :: Word64# -> Word#
  ctz8# :: Word# -> Word#
  currentCallStack :: GHC.Types.IO [GHC.Base.String]
  dataToTag# :: forall a. a -> Int#
  deRefStablePtr# :: forall {l :: Levity} (a :: TYPE (BoxedRep l)). StablePtr# a -> State# RealWorld -> (# State# RealWorld, a #)
  deRefWeak# :: forall {l :: Levity} (a :: TYPE (BoxedRep l)). Weak# a -> State# RealWorld -> (# State# RealWorld, Int#, a #)
  decodeDouble_2Int# :: Double# -> (# Int#, Word#, Word#, Int# #)
  decodeDouble_Int64# :: Double# -> (# Int64#, Int# #)
  decodeFloat_Int# :: Float# -> (# Int#, Int# #)
  delay# :: forall d. Int# -> State# d -> State# d
  divideDoubleX2# :: DoubleX2# -> DoubleX2# -> DoubleX2#
  divideDoubleX4# :: DoubleX4# -> DoubleX4# -> DoubleX4#
  divideDoubleX8# :: DoubleX8# -> DoubleX8# -> DoubleX8#
  divideFloat# :: Float# -> Float# -> Float#
  divideFloatX16# :: FloatX16# -> FloatX16# -> FloatX16#
  divideFloatX4# :: FloatX4# -> FloatX4# -> FloatX4#
  divideFloatX8# :: FloatX8# -> FloatX8# -> FloatX8#
  double2Float# :: Double# -> Float#
  double2Int# :: Double# -> Int#
  eqAddr# :: Addr# -> Addr# -> Int#
  eqChar# :: Char# -> Char# -> Int#
  eqFloat# :: Float# -> Float# -> Int#
  eqInt16# :: Int16# -> Int16# -> Int#
  eqInt32# :: Int32# -> Int32# -> Int#
  eqInt64# :: Int64# -> Int64# -> Int#
  eqInt8# :: Int8# -> Int8# -> Int#
  eqStableName# :: forall {k :: Levity} {l :: Levity} (a :: TYPE (BoxedRep k)) (b :: TYPE (BoxedRep l)). StableName# a -> StableName# b -> Int#
  eqStablePtr# :: forall {l :: Levity} (a :: TYPE (BoxedRep l)). StablePtr# a -> StablePtr# a -> Int#
  eqWord# :: Word# -> Word# -> Int#
  eqWord16# :: Word16# -> Word16# -> Int#
  eqWord32# :: Word32# -> Word32# -> Int#
  eqWord64# :: Word64# -> Word64# -> Int#
  eqWord8# :: Word8# -> Word8# -> Int#
  expDouble# :: Double# -> Double#
  expFloat# :: Float# -> Float#
  expm1Double# :: Double# -> Double#
  expm1Float# :: Float# -> Float#
  fabsDouble# :: Double# -> Double#
  fabsFloat# :: Float# -> Float#
  fetchAddIntArray# :: forall d. MutableByteArray# d -> Int# -> Int# -> State# d -> (# State# d, Int# #)
  fetchAddWordAddr# :: forall d. Addr# -> Word# -> State# d -> (# State# d, Word# #)
  fetchAndIntArray# :: forall d. MutableByteArray# d -> Int# -> Int# -> State# d -> (# State# d, Int# #)
  fetchAndWordAddr# :: forall d. Addr# -> Word# -> State# d -> (# State# d, Word# #)
  fetchNandIntArray# :: forall d. MutableByteArray# d -> Int# -> Int# -> State# d -> (# State# d, Int# #)
  fetchNandWordAddr# :: forall d. Addr# -> Word# -> State# d -> (# State# d, Word# #)
  fetchOrIntArray# :: forall d. MutableByteArray# d -> Int# -> Int# -> State# d -> (# State# d, Int# #)
  fetchOrWordAddr# :: forall d. Addr# -> Word# -> State# d -> (# State# d, Word# #)
  fetchSubIntArray# :: forall d. MutableByteArray# d -> Int# -> Int# -> State# d -> (# State# d, Int# #)
  fetchSubWordAddr# :: forall d. Addr# -> Word# -> State# d -> (# State# d, Word# #)
  fetchXorIntArray# :: forall d. MutableByteArray# d -> Int# -> Int# -> State# d -> (# State# d, Int# #)
  fetchXorWordAddr# :: forall d. Addr# -> Word# -> State# d -> (# State# d, Word# #)
  finalizeWeak# :: forall {l :: Levity} (a :: TYPE (BoxedRep l)) b. Weak# a -> State# RealWorld -> (# State# RealWorld, Int#, State# RealWorld -> (# State# RealWorld, b #) #)
  float2Double# :: Float# -> Double#
  float2Int# :: Float# -> Int#
  fmaddDouble# :: Double# -> Double# -> Double# -> Double#
  fmaddFloat# :: Float# -> Float# -> Float# -> Float#
  fmsubDouble# :: Double# -> Double# -> Double# -> Double#
  fmsubFloat# :: Float# -> Float# -> Float# -> Float#
  fnmaddDouble# :: Double# -> Double# -> Double# -> Double#
  fnmaddFloat# :: Float# -> Float# -> Float# -> Float#
  fnmsubDouble# :: Double# -> Double# -> Double# -> Double#
  fnmsubFloat# :: Float# -> Float# -> Float# -> Float#
  fork# :: forall {q :: RuntimeRep} (a :: TYPE q). (State# RealWorld -> (# State# RealWorld, a #)) -> State# RealWorld -> (# State# RealWorld, ThreadId# #)
  forkOn# :: forall {q :: RuntimeRep} (a :: TYPE q). Int# -> (State# RealWorld -> (# State# RealWorld, a #)) -> State# RealWorld -> (# State# RealWorld, ThreadId# #)
  freezeArray# :: forall {l :: Levity} d (a :: TYPE (BoxedRep l)). MutableArray# d a -> Int# -> Int# -> State# d -> (# State# d, Array# a #)
  freezeSmallArray# :: forall {l :: Levity} d (a :: TYPE (BoxedRep l)). SmallMutableArray# d a -> Int# -> Int# -> State# d -> (# State# d, SmallArray# a #)
  geAddr# :: Addr# -> Addr# -> Int#
  geChar# :: Char# -> Char# -> Int#
  geFloat# :: Float# -> Float# -> Int#
  geInt16# :: Int16# -> Int16# -> Int#
  geInt32# :: Int32# -> Int32# -> Int#
  geInt64# :: Int64# -> Int64# -> Int#
  geInt8# :: Int8# -> Int8# -> Int#
  geWord# :: Word# -> Word# -> Int#
  geWord16# :: Word16# -> Word16# -> Int#
  geWord32# :: Word32# -> Word32# -> Int#
  geWord64# :: Word64# -> Word64# -> Int#
  geWord8# :: Word8# -> Word8# -> Int#
  getApStackVal# :: forall a b. a -> Int# -> (# Int#, b #)
  getCCSOf# :: forall a d. a -> State# d -> (# State# d, Addr# #)
  getCurrentCCS# :: forall a d. a -> State# d -> (# State# d, Addr# #)
  getMaskingState# :: State# RealWorld -> (# State# RealWorld, Int# #)
  getSizeofMutableByteArray# :: forall d. MutableByteArray# d -> State# d -> (# State# d, Int# #)
  getSizeofSmallMutableArray# :: forall {l :: Levity} d (a :: TYPE (BoxedRep l)). SmallMutableArray# d a -> State# d -> (# State# d, Int# #)
  getSpark# :: forall d a. State# d -> (# State# d, Int#, a #)
  getThreadAllocationCounter# :: State# RealWorld -> (# State# RealWorld, Int64# #)
  groupWith :: forall b a. GHC.Classes.Ord b => (a -> b) -> [a] -> [[a]]
  gtAddr# :: Addr# -> Addr# -> Int#
  gtChar# :: Char# -> Char# -> Int#
  gtFloat# :: Float# -> Float# -> Int#
  gtInt16# :: Int16# -> Int16# -> Int#
  gtInt32# :: Int32# -> Int32# -> Int#
  gtInt64# :: Int64# -> Int64# -> Int#
  gtInt8# :: Int8# -> Int8# -> Int#
  gtWord# :: Word# -> Word# -> Int#
  gtWord16# :: Word16# -> Word16# -> Int#
  gtWord32# :: Word32# -> Word32# -> Int#
  gtWord64# :: Word64# -> Word64# -> Int#
  gtWord8# :: Word8# -> Word8# -> Int#
  iShiftL# :: Int# -> Int# -> Int#
  iShiftRA# :: Int# -> Int# -> Int#
  iShiftRL# :: Int# -> Int# -> Int#
  indexAddrArray# :: ByteArray# -> Int# -> Addr#
  indexAddrOffAddr# :: Addr# -> Int# -> Addr#
  indexArray# :: forall {l :: Levity} (a :: TYPE (BoxedRep l)). Array# a -> Int# -> (# a #)
  indexArrayArrayArray# :: ArrayArray# -> Int# -> ArrayArray#
  indexByteArrayArray# :: ArrayArray# -> Int# -> ByteArray#
  indexCharArray# :: ByteArray# -> Int# -> Char#
  indexCharOffAddr# :: Addr# -> Int# -> Char#
  indexDoubleArray# :: ByteArray# -> Int# -> Double#
  indexDoubleArrayAsDoubleX2# :: ByteArray# -> Int# -> DoubleX2#
  indexDoubleArrayAsDoubleX4# :: ByteArray# -> Int# -> DoubleX4#
  indexDoubleArrayAsDoubleX8# :: ByteArray# -> Int# -> DoubleX8#
  indexDoubleOffAddr# :: Addr# -> Int# -> Double#
  indexDoubleOffAddrAsDoubleX2# :: Addr# -> Int# -> DoubleX2#
  indexDoubleOffAddrAsDoubleX4# :: Addr# -> Int# -> DoubleX4#
  indexDoubleOffAddrAsDoubleX8# :: Addr# -> Int# -> DoubleX8#
  indexDoubleX2Array# :: ByteArray# -> Int# -> DoubleX2#
  indexDoubleX2OffAddr# :: Addr# -> Int# -> DoubleX2#
  indexDoubleX4Array# :: ByteArray# -> Int# -> DoubleX4#
  indexDoubleX4OffAddr# :: Addr# -> Int# -> DoubleX4#
  indexDoubleX8Array# :: ByteArray# -> Int# -> DoubleX8#
  indexDoubleX8OffAddr# :: Addr# -> Int# -> DoubleX8#
  indexFloatArray# :: ByteArray# -> Int# -> Float#
  indexFloatArrayAsFloatX16# :: ByteArray# -> Int# -> FloatX16#
  indexFloatArrayAsFloatX4# :: ByteArray# -> Int# -> FloatX4#
  indexFloatArrayAsFloatX8# :: ByteArray# -> Int# -> FloatX8#
  indexFloatOffAddr# :: Addr# -> Int# -> Float#
  indexFloatOffAddrAsFloatX16# :: Addr# -> Int# -> FloatX16#
  indexFloatOffAddrAsFloatX4# :: Addr# -> Int# -> FloatX4#
  indexFloatOffAddrAsFloatX8# :: Addr# -> Int# -> FloatX8#
  indexFloatX16Array# :: ByteArray# -> Int# -> FloatX16#
  indexFloatX16OffAddr# :: Addr# -> Int# -> FloatX16#
  indexFloatX4Array# :: ByteArray# -> Int# -> FloatX4#
  indexFloatX4OffAddr# :: Addr# -> Int# -> FloatX4#
  indexFloatX8Array# :: ByteArray# -> Int# -> FloatX8#
  indexFloatX8OffAddr# :: Addr# -> Int# -> FloatX8#
  indexInt16Array# :: ByteArray# -> Int# -> Int16#
  indexInt16ArrayAsInt16X16# :: ByteArray# -> Int# -> Int16X16#
  indexInt16ArrayAsInt16X32# :: ByteArray# -> Int# -> Int16X32#
  indexInt16ArrayAsInt16X8# :: ByteArray# -> Int# -> Int16X8#
  indexInt16OffAddr# :: Addr# -> Int# -> Int16#
  indexInt16OffAddrAsInt16X16# :: Addr# -> Int# -> Int16X16#
  indexInt16OffAddrAsInt16X32# :: Addr# -> Int# -> Int16X32#
  indexInt16OffAddrAsInt16X8# :: Addr# -> Int# -> Int16X8#
  indexInt16X16Array# :: ByteArray# -> Int# -> Int16X16#
  indexInt16X16OffAddr# :: Addr# -> Int# -> Int16X16#
  indexInt16X32Array# :: ByteArray# -> Int# -> Int16X32#
  indexInt16X32OffAddr# :: Addr# -> Int# -> Int16X32#
  indexInt16X8Array# :: ByteArray# -> Int# -> Int16X8#
  indexInt16X8OffAddr# :: Addr# -> Int# -> Int16X8#
  indexInt32Array# :: ByteArray# -> Int# -> Int32#
  indexInt32ArrayAsInt32X16# :: ByteArray# -> Int# -> Int32X16#
  indexInt32ArrayAsInt32X4# :: ByteArray# -> Int# -> Int32X4#
  indexInt32ArrayAsInt32X8# :: ByteArray# -> Int# -> Int32X8#
  indexInt32OffAddr# :: Addr# -> Int# -> Int32#
  indexInt32OffAddrAsInt32X16# :: Addr# -> Int# -> Int32X16#
  indexInt32OffAddrAsInt32X4# :: Addr# -> Int# -> Int32X4#
  indexInt32OffAddrAsInt32X8# :: Addr# -> Int# -> Int32X8#
  indexInt32X16Array# :: ByteArray# -> Int# -> Int32X16#
  indexInt32X16OffAddr# :: Addr# -> Int# -> Int32X16#
  indexInt32X4Array# :: ByteArray# -> Int# -> Int32X4#
  indexInt32X4OffAddr# :: Addr# -> Int# -> Int32X4#
  indexInt32X8Array# :: ByteArray# -> Int# -> Int32X8#
  indexInt32X8OffAddr# :: Addr# -> Int# -> Int32X8#
  indexInt64Array# :: ByteArray# -> Int# -> Int64#
  indexInt64ArrayAsInt64X2# :: ByteArray# -> Int# -> Int64X2#
  indexInt64ArrayAsInt64X4# :: ByteArray# -> Int# -> Int64X4#
  indexInt64ArrayAsInt64X8# :: ByteArray# -> Int# -> Int64X8#
  indexInt64OffAddr# :: Addr# -> Int# -> Int64#
  indexInt64OffAddrAsInt64X2# :: Addr# -> Int# -> Int64X2#
  indexInt64OffAddrAsInt64X4# :: Addr# -> Int# -> Int64X4#
  indexInt64OffAddrAsInt64X8# :: Addr# -> Int# -> Int64X8#
  indexInt64X2Array# :: ByteArray# -> Int# -> Int64X2#
  indexInt64X2OffAddr# :: Addr# -> Int# -> Int64X2#
  indexInt64X4Array# :: ByteArray# -> Int# -> Int64X4#
  indexInt64X4OffAddr# :: Addr# -> Int# -> Int64X4#
  indexInt64X8Array# :: ByteArray# -> Int# -> Int64X8#
  indexInt64X8OffAddr# :: Addr# -> Int# -> Int64X8#
  indexInt8Array# :: ByteArray# -> Int# -> Int8#
  indexInt8ArrayAsInt8X16# :: ByteArray# -> Int# -> Int8X16#
  indexInt8ArrayAsInt8X32# :: ByteArray# -> Int# -> Int8X32#
  indexInt8ArrayAsInt8X64# :: ByteArray# -> Int# -> Int8X64#
  indexInt8OffAddr# :: Addr# -> Int# -> Int8#
  indexInt8OffAddrAsInt8X16# :: Addr# -> Int# -> Int8X16#
  indexInt8OffAddrAsInt8X32# :: Addr# -> Int# -> Int8X32#
  indexInt8OffAddrAsInt8X64# :: Addr# -> Int# -> Int8X64#
  indexInt8X16Array# :: ByteArray# -> Int# -> Int8X16#
  indexInt8X16OffAddr# :: Addr# -> Int# -> Int8X16#
  indexInt8X32Array# :: ByteArray# -> Int# -> Int8X32#
  indexInt8X32OffAddr# :: Addr# -> Int# -> Int8X32#
  indexInt8X64Array# :: ByteArray# -> Int# -> Int8X64#
  indexInt8X64OffAddr# :: Addr# -> Int# -> Int8X64#
  indexIntArray# :: ByteArray# -> Int# -> Int#
  indexIntOffAddr# :: Addr# -> Int# -> Int#
  indexSmallArray# :: forall {l :: Levity} (a :: TYPE (BoxedRep l)). SmallArray# a -> Int# -> (# a #)
  indexStablePtrArray# :: forall a. ByteArray# -> Int# -> StablePtr# a
  indexStablePtrOffAddr# :: forall a. Addr# -> Int# -> StablePtr# a
  indexWideCharArray# :: ByteArray# -> Int# -> Char#
  indexWideCharOffAddr# :: Addr# -> Int# -> Char#
  indexWord16Array# :: ByteArray# -> Int# -> Word16#
  indexWord16ArrayAsWord16X16# :: ByteArray# -> Int# -> Word16X16#
  indexWord16ArrayAsWord16X32# :: ByteArray# -> Int# -> Word16X32#
  indexWord16ArrayAsWord16X8# :: ByteArray# -> Int# -> Word16X8#
  indexWord16OffAddr# :: Addr# -> Int# -> Word16#
  indexWord16OffAddrAsWord16X16# :: Addr# -> Int# -> Word16X16#
  indexWord16OffAddrAsWord16X32# :: Addr# -> Int# -> Word16X32#
  indexWord16OffAddrAsWord16X8# :: Addr# -> Int# -> Word16X8#
  indexWord16X16Array# :: ByteArray# -> Int# -> Word16X16#
  indexWord16X16OffAddr# :: Addr# -> Int# -> Word16X16#
  indexWord16X32Array# :: ByteArray# -> Int# -> Word16X32#
  indexWord16X32OffAddr# :: Addr# -> Int# -> Word16X32#
  indexWord16X8Array# :: ByteArray# -> Int# -> Word16X8#
  indexWord16X8OffAddr# :: Addr# -> Int# -> Word16X8#
  indexWord32Array# :: ByteArray# -> Int# -> Word32#
  indexWord32ArrayAsWord32X16# :: ByteArray# -> Int# -> Word32X16#
  indexWord32ArrayAsWord32X4# :: ByteArray# -> Int# -> Word32X4#
  indexWord32ArrayAsWord32X8# :: ByteArray# -> Int# -> Word32X8#
  indexWord32OffAddr# :: Addr# -> Int# -> Word32#
  indexWord32OffAddrAsWord32X16# :: Addr# -> Int# -> Word32X16#
  indexWord32OffAddrAsWord32X4# :: Addr# -> Int# -> Word32X4#
  indexWord32OffAddrAsWord32X8# :: Addr# -> Int# -> Word32X8#
  indexWord32X16Array# :: ByteArray# -> Int# -> Word32X16#
  indexWord32X16OffAddr# :: Addr# -> Int# -> Word32X16#
  indexWord32X4Array# :: ByteArray# -> Int# -> Word32X4#
  indexWord32X4OffAddr# :: Addr# -> Int# -> Word32X4#
  indexWord32X8Array# :: ByteArray# -> Int# -> Word32X8#
  indexWord32X8OffAddr# :: Addr# -> Int# -> Word32X8#
  indexWord64Array# :: ByteArray# -> Int# -> Word64#
  indexWord64ArrayAsWord64X2# :: ByteArray# -> Int# -> Word64X2#
  indexWord64ArrayAsWord64X4# :: ByteArray# -> Int# -> Word64X4#
  indexWord64ArrayAsWord64X8# :: ByteArray# -> Int# -> Word64X8#
  indexWord64OffAddr# :: Addr# -> Int# -> Word64#
  indexWord64OffAddrAsWord64X2# :: Addr# -> Int# -> Word64X2#
  indexWord64OffAddrAsWord64X4# :: Addr# -> Int# -> Word64X4#
  indexWord64OffAddrAsWord64X8# :: Addr# -> Int# -> Word64X8#
  indexWord64X2Array# :: ByteArray# -> Int# -> Word64X2#
  indexWord64X2OffAddr# :: Addr# -> Int# -> Word64X2#
  indexWord64X4Array# :: ByteArray# -> Int# -> Word64X4#
  indexWord64X4OffAddr# :: Addr# -> Int# -> Word64X4#
  indexWord64X8Array# :: ByteArray# -> Int# -> Word64X8#
  indexWord64X8OffAddr# :: Addr# -> Int# -> Word64X8#
  indexWord8Array# :: ByteArray# -> Int# -> Word8#
  indexWord8ArrayAsAddr# :: ByteArray# -> Int# -> Addr#
  indexWord8ArrayAsChar# :: ByteArray# -> Int# -> Char#
  indexWord8ArrayAsDouble# :: ByteArray# -> Int# -> Double#
  indexWord8ArrayAsFloat# :: ByteArray# -> Int# -> Float#
  indexWord8ArrayAsInt# :: ByteArray# -> Int# -> Int#
  indexWord8ArrayAsInt16# :: ByteArray# -> Int# -> Int16#
  indexWord8ArrayAsInt32# :: ByteArray# -> Int# -> Int32#
  indexWord8ArrayAsInt64# :: ByteArray# -> Int# -> Int64#
  indexWord8ArrayAsStablePtr# :: forall a. ByteArray# -> Int# -> StablePtr# a
  indexWord8ArrayAsWideChar# :: ByteArray# -> Int# -> Char#
  indexWord8ArrayAsWord# :: ByteArray# -> Int# -> Word#
  indexWord8ArrayAsWord16# :: ByteArray# -> Int# -> Word16#
  indexWord8ArrayAsWord32# :: ByteArray# -> Int# -> Word32#
  indexWord8ArrayAsWord64# :: ByteArray# -> Int# -> Word64#
  indexWord8ArrayAsWord8X16# :: ByteArray# -> Int# -> Word8X16#
  indexWord8ArrayAsWord8X32# :: ByteArray# -> Int# -> Word8X32#
  indexWord8ArrayAsWord8X64# :: ByteArray# -> Int# -> Word8X64#
  indexWord8OffAddr# :: Addr# -> Int# -> Word8#
  indexWord8OffAddrAsWord8X16# :: Addr# -> Int# -> Word8X16#
  indexWord8OffAddrAsWord8X32# :: Addr# -> Int# -> Word8X32#
  indexWord8OffAddrAsWord8X64# :: Addr# -> Int# -> Word8X64#
  indexWord8X16Array# :: ByteArray# -> Int# -> Word8X16#
  indexWord8X16OffAddr# :: Addr# -> Int# -> Word8X16#
  indexWord8X32Array# :: ByteArray# -> Int# -> Word8X32#
  indexWord8X32OffAddr# :: Addr# -> Int# -> Word8X32#
  indexWord8X64Array# :: ByteArray# -> Int# -> Word8X64#
  indexWord8X64OffAddr# :: Addr# -> Int# -> Word8X64#
  indexWordArray# :: ByteArray# -> Int# -> Word#
  indexWordOffAddr# :: Addr# -> Int# -> Word#
  inline :: forall a. a -> a
  insertDoubleX2# :: DoubleX2# -> Double# -> Int# -> DoubleX2#
  insertDoubleX4# :: DoubleX4# -> Double# -> Int# -> DoubleX4#
  insertDoubleX8# :: DoubleX8# -> Double# -> Int# -> DoubleX8#
  insertFloatX16# :: FloatX16# -> Float# -> Int# -> FloatX16#
  insertFloatX4# :: FloatX4# -> Float# -> Int# -> FloatX4#
  insertFloatX8# :: FloatX8# -> Float# -> Int# -> FloatX8#
  insertInt16X16# :: Int16X16# -> Int16# -> Int# -> Int16X16#
  insertInt16X32# :: Int16X32# -> Int16# -> Int# -> Int16X32#
  insertInt16X8# :: Int16X8# -> Int16# -> Int# -> Int16X8#
  insertInt32X16# :: Int32X16# -> Int32# -> Int# -> Int32X16#
  insertInt32X4# :: Int32X4# -> Int32# -> Int# -> Int32X4#
  insertInt32X8# :: Int32X8# -> Int32# -> Int# -> Int32X8#
  insertInt64X2# :: Int64X2# -> Int64# -> Int# -> Int64X2#
  insertInt64X4# :: Int64X4# -> Int64# -> Int# -> Int64X4#
  insertInt64X8# :: Int64X8# -> Int64# -> Int# -> Int64X8#
  insertInt8X16# :: Int8X16# -> Int8# -> Int# -> Int8X16#
  insertInt8X32# :: Int8X32# -> Int8# -> Int# -> Int8X32#
  insertInt8X64# :: Int8X64# -> Int8# -> Int# -> Int8X64#
  insertWord16X16# :: Word16X16# -> Word16# -> Int# -> Word16X16#
  insertWord16X32# :: Word16X32# -> Word16# -> Int# -> Word16X32#
  insertWord16X8# :: Word16X8# -> Word16# -> Int# -> Word16X8#
  insertWord32X16# :: Word32X16# -> Word32# -> Int# -> Word32X16#
  insertWord32X4# :: Word32X4# -> Word32# -> Int# -> Word32X4#
  insertWord32X8# :: Word32X8# -> Word32# -> Int# -> Word32X8#
  insertWord64X2# :: Word64X2# -> Word64# -> Int# -> Word64X2#
  insertWord64X4# :: Word64X4# -> Word64# -> Int# -> Word64X4#
  insertWord64X8# :: Word64X8# -> Word64# -> Int# -> Word64X8#
  insertWord8X16# :: Word8X16# -> Word8# -> Int# -> Word8X16#
  insertWord8X32# :: Word8X32# -> Word8# -> Int# -> Word8X32#
  insertWord8X64# :: Word8X64# -> Word8# -> Int# -> Word8X64#
  int16ToInt# :: Int16# -> Int#
  int16ToWord16# :: Int16# -> Word16#
  int2Addr# :: Int# -> Addr#
  int2Double# :: Int# -> Double#
  int2Float# :: Int# -> Float#
  int2Word# :: Int# -> Word#
  int32ToInt# :: Int32# -> Int#
  int32ToWord32# :: Int32# -> Word32#
  int64ToInt# :: Int64# -> Int#
  int64ToWord64# :: Int64# -> Word64#
  int8ToInt# :: Int8# -> Int#
  int8ToWord8# :: Int8# -> Word8#
  intToInt16# :: Int# -> Int16#
  intToInt32# :: Int# -> Int32#
  intToInt64# :: Int# -> Int64#
  intToInt8# :: Int# -> Int8#
  isByteArrayPinned# :: ByteArray# -> Int#
  isCurrentThreadBound# :: State# RealWorld -> (# State# RealWorld, Int# #)
  isEmptyMVar# :: forall {l :: Levity} d (a :: TYPE (BoxedRep l)). MVar# d a -> State# d -> (# State# d, Int# #)
  isMutableByteArrayPinned# :: forall d. MutableByteArray# d -> Int#
  isTrue# :: Int# -> Bool
  keepAlive# :: forall {l :: Levity} {r :: RuntimeRep} (a :: TYPE (BoxedRep l)) d (b :: TYPE r). a -> State# d -> (State# d -> b) -> b
  killThread# :: forall a. ThreadId# -> a -> State# RealWorld -> State# RealWorld
  labelThread# :: ThreadId# -> ByteArray# -> State# RealWorld -> State# RealWorld
  lazy :: forall a. a -> a
  leAddr# :: Addr# -> Addr# -> Int#
  leChar# :: Char# -> Char# -> Int#
  leFloat# :: Float# -> Float# -> Int#
  leInt16# :: Int16# -> Int16# -> Int#
  leInt32# :: Int32# -> Int32# -> Int#
  leInt64# :: Int64# -> Int64# -> Int#
  leInt8# :: Int8# -> Int8# -> Int#
  leWord# :: Word# -> Word# -> Int#
  leWord16# :: Word16# -> Word16# -> Int#
  leWord32# :: Word32# -> Word32# -> Int#
  leWord64# :: Word64# -> Word64# -> Int#
  leWord8# :: Word8# -> Word8# -> Int#
  leftSection :: forall {q :: RuntimeRep} {r :: RuntimeRep} (a :: TYPE q) (b :: TYPE r). (a -> b) -> a -> b
  listThreads# :: State# RealWorld -> (# State# RealWorld, Array# ThreadId# #)
  log1pDouble# :: Double# -> Double#
  log1pFloat# :: Float# -> Float#
  logDouble# :: Double# -> Double#
  logFloat# :: Float# -> Float#
  ltAddr# :: Addr# -> Addr# -> Int#
  ltChar# :: Char# -> Char# -> Int#
  ltFloat# :: Float# -> Float# -> Int#
  ltInt16# :: Int16# -> Int16# -> Int#
  ltInt32# :: Int32# -> Int32# -> Int#
  ltInt64# :: Int64# -> Int64# -> Int#
  ltInt8# :: Int8# -> Int8# -> Int#
  ltWord# :: Word# -> Word# -> Int#
  ltWord16# :: Word16# -> Word16# -> Int#
  ltWord32# :: Word32# -> Word32# -> Int#