base-exports.stdout-ws-32

module Control.Applicative where
  -- Safety: Trustworthy
  (<$) :: forall (f :: * -> *) a b. GHC.Internal.Base.Functor f => a -> f b -> f a
  (<$>) :: forall (f :: * -> *) a b. GHC.Internal.Base.Functor f => (a -> b) -> f a -> f b
  (<**>) :: forall (f :: * -> *) a b. Applicative f => f a -> f (a -> b) -> f b
  type Alternative :: (* -> *) -> Constraint
  class Applicative f => Alternative f where
    empty :: forall a. f a
    (<|>) :: forall a. f a -> f a -> f a
    some :: forall a. f a -> f [a]
    many :: forall a. f a -> f [a]
    {-# MINIMAL empty, (<|>) #-}
  type Applicative :: (* -> *) -> Constraint
  class GHC.Internal.Base.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 role Const representational phantom
  type Const :: forall {k}. * -> k -> *
  newtype Const a b = Const {getConst :: a}
  type role WrappedArrow representational nominal nominal
  type WrappedArrow :: (* -> * -> *) -> * -> * -> *
  newtype WrappedArrow a b c = WrapArrow {unwrapArrow :: a b c}
  type role WrappedMonad representational nominal
  type WrappedMonad :: (* -> *) -> * -> *
  newtype WrappedMonad m a = WrapMonad {unwrapMonad :: m a}
  type ZipList :: * -> *
  newtype ZipList a = ZipList {getZipList :: [a]}
  asum :: forall (t :: * -> *) (f :: * -> *) a. (GHC.Internal.Data.Foldable.Foldable t, Alternative f) => t (f a) -> f a
  liftA :: forall (f :: * -> *) a b. Applicative f => (a -> b) -> f a -> f b
  liftA3 :: forall (f :: * -> *) a b c d. Applicative f => (a -> b -> c -> d) -> f a -> f b -> f c -> f d
  optional :: forall (f :: * -> *) a. Alternative f => f a -> f (GHC.Internal.Maybe.Maybe a)

module Control.Arrow where
  -- Safety: Safe
  (<<<) :: forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k). GHC.Internal.Control.Category.Category cat => cat b c -> cat a b -> cat a c
  (<<^) :: forall (a :: * -> * -> *) c d b. Arrow a => a c d -> (b -> c) -> a b d
  (>>>) :: forall {k} (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k). GHC.Internal.Control.Category.Category cat => cat a b -> cat b c -> cat a c
  (>>^) :: forall (a :: * -> * -> *) b c d. Arrow a => a b c -> (c -> d) -> a b d
  type Arrow :: (* -> * -> *) -> Constraint
  class GHC.Internal.Control.Category.Category a => Arrow a where
    arr :: forall b c. (b -> c) -> a b c
    first :: forall b c d. a b c -> a (b, d) (c, d)
    second :: forall b c d. a b c -> a (d, b) (d, c)
    (***) :: forall b c b' c'. a b c -> a b' c' -> a (b, b') (c, c')
    (&&&) :: forall b c c'. a b c -> a b c' -> a b (c, c')
    {-# MINIMAL arr, (first | (***)) #-}
  type ArrowApply :: (* -> * -> *) -> Constraint
  class Arrow a => ArrowApply a where
    app :: forall b c. a (a b c, b) c
    {-# MINIMAL app #-}
  type ArrowChoice :: (* -> * -> *) -> Constraint
  class Arrow a => ArrowChoice a where
    left :: forall b c d. a b c -> a (GHC.Internal.Data.Either.Either b d) (GHC.Internal.Data.Either.Either c d)
    right :: forall b c d. a b c -> a (GHC.Internal.Data.Either.Either d b) (GHC.Internal.Data.Either.Either d c)
    (+++) :: forall b c b' c'. a b c -> a b' c' -> a (GHC.Internal.Data.Either.Either b b') (GHC.Internal.Data.Either.Either c c')
    (|||) :: forall b d c. a b d -> a c d -> a (GHC.Internal.Data.Either.Either b c) d
    {-# MINIMAL (left | (+++)) #-}
  type ArrowLoop :: (* -> * -> *) -> Constraint
  class Arrow a => ArrowLoop a where
    loop :: forall b d c. a (b, d) (c, d) -> a b c
    {-# MINIMAL loop #-}
  type role ArrowMonad representational nominal
  type ArrowMonad :: (* -> * -> *) -> * -> *
  newtype ArrowMonad a b = ArrowMonad (a () b)
  type ArrowPlus :: (* -> * -> *) -> Constraint
  class ArrowZero a => ArrowPlus a where
    (<+>) :: forall b c. a b c -> a b c -> a b c
    {-# MINIMAL (<+>) #-}
  type ArrowZero :: (* -> * -> *) -> Constraint
  class Arrow a => ArrowZero a where
    zeroArrow :: forall b c. a b c
    {-# MINIMAL zeroArrow #-}
  type role Kleisli representational representational nominal
  type Kleisli :: (* -> *) -> * -> * -> *
  newtype Kleisli m a b = Kleisli {runKleisli :: a -> m b}
  (^<<) :: forall (a :: * -> * -> *) c d b. Arrow a => (c -> d) -> a b c -> a b d
  (^>>) :: forall (a :: * -> * -> *) b c d. Arrow a => (b -> c) -> a c d -> a b d
  leftApp :: forall (a :: * -> * -> *) b c d. ArrowApply a => a b c -> a (GHC.Internal.Data.Either.Either b d) (GHC.Internal.Data.Either.Either c d)
  returnA :: forall (a :: * -> * -> *) b. Arrow a => a b b

module Control.Category where
  -- Safety: Safe
  (<<<) :: forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k). Category cat => cat b c -> cat a b -> cat a c
  (>>>) :: forall {k} (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k). Category cat => cat a b -> cat b c -> cat a c
  type Category :: forall {k}. (k -> k -> *) -> Constraint
  class Category cat where
    id :: forall (a :: k). cat a a
    (.) :: forall (b :: k) (c :: k) (a :: k). cat b c -> cat a b -> cat a c
    {-# MINIMAL id, (.) #-}

module Control.Concurrent where
  -- Safety: Trustworthy
  type Chan :: * -> *
  data Chan a = ...
  type MVar :: * -> *
  data MVar a = ...
  type QSem :: *
  newtype QSem = ...
  type QSemN :: *
  data QSemN = ...
  type ThreadId :: *
  data ThreadId = ...
  addMVarFinalizer :: forall a. MVar a -> GHC.Types.IO () -> GHC.Types.IO ()
  dupChan :: forall a. Chan a -> GHC.Types.IO (Chan a)
  forkFinally :: forall a. GHC.Types.IO a -> (GHC.Internal.Data.Either.Either GHC.Internal.Exception.Type.SomeException a -> GHC.Types.IO ()) -> GHC.Types.IO ThreadId
  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
  forkOS :: GHC.Types.IO () -> GHC.Types.IO ThreadId
  forkOSWithUnmask :: ((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
  getChanContents :: forall a. Chan a -> GHC.Types.IO [a]
  getNumCapabilities :: GHC.Types.IO GHC.Types.Int
  isCurrentThreadBound :: GHC.Types.IO GHC.Types.Bool
  isEmptyMVar :: forall a. MVar a -> GHC.Types.IO GHC.Types.Bool
  killThread :: ThreadId -> GHC.Types.IO ()
  mkWeakMVar :: forall a. MVar a -> GHC.Types.IO () -> GHC.Types.IO (GHC.Internal.Weak.Weak (MVar a))
  mkWeakThreadId :: ThreadId -> GHC.Types.IO (GHC.Internal.Weak.Weak ThreadId)
  modifyMVar :: forall a b. MVar a -> (a -> GHC.Types.IO (a, b)) -> GHC.Types.IO b
  modifyMVarMasked :: forall a b. MVar a -> (a -> GHC.Types.IO (a, b)) -> GHC.Types.IO b
  modifyMVarMasked_ :: forall a. MVar a -> (a -> GHC.Types.IO a) -> GHC.Types.IO ()
  modifyMVar_ :: forall a. MVar a -> (a -> GHC.Types.IO a) -> GHC.Types.IO ()
  myThreadId :: GHC.Types.IO ThreadId
  newChan :: forall a. GHC.Types.IO (Chan a)
  newEmptyMVar :: forall a. GHC.Types.IO (MVar a)
  newMVar :: forall a. a -> GHC.Types.IO (MVar a)
  newQSem :: GHC.Types.Int -> GHC.Types.IO QSem
  newQSemN :: GHC.Types.Int -> GHC.Types.IO QSemN
  putMVar :: forall a. MVar a -> a -> GHC.Types.IO ()
  readChan :: forall a. Chan a -> GHC.Types.IO a
  readMVar :: forall a. MVar a -> GHC.Types.IO a
  rtsSupportsBoundThreads :: GHC.Types.Bool
  runInBoundThread :: forall a. GHC.Types.IO a -> GHC.Types.IO a
  runInUnboundThread :: forall a. GHC.Types.IO a -> GHC.Types.IO a
  setNumCapabilities :: GHC.Types.Int -> GHC.Types.IO ()
  signalQSem :: QSem -> GHC.Types.IO ()
  signalQSemN :: QSemN -> GHC.Types.Int -> GHC.Types.IO ()
  swapMVar :: forall a. MVar a -> a -> GHC.Types.IO a
  takeMVar :: forall a. MVar a -> GHC.Types.IO a
  threadCapability :: ThreadId -> GHC.Types.IO (GHC.Types.Int, GHC.Types.Bool)
  threadDelay :: GHC.Types.Int -> GHC.Types.IO ()
  threadWaitRead :: GHC.Internal.System.Posix.Types.Fd -> GHC.Types.IO ()
  threadWaitReadSTM :: GHC.Internal.System.Posix.Types.Fd -> GHC.Types.IO (GHC.Internal.Conc.Sync.STM (), GHC.Types.IO ())
  threadWaitWrite :: GHC.Internal.System.Posix.Types.Fd -> GHC.Types.IO ()
  threadWaitWriteSTM :: GHC.Internal.System.Posix.Types.Fd -> GHC.Types.IO (GHC.Internal.Conc.Sync.STM (), GHC.Types.IO ())
  throwTo :: forall e. GHC.Internal.Exception.Type.Exception e => ThreadId -> e -> GHC.Types.IO ()
  tryPutMVar :: forall a. MVar a -> a -> GHC.Types.IO GHC.Types.Bool
  tryReadMVar :: forall a. MVar a -> GHC.Types.IO (GHC.Internal.Maybe.Maybe a)
  tryTakeMVar :: forall a. MVar a -> GHC.Types.IO (GHC.Internal.Maybe.Maybe a)
  waitQSem :: QSem -> GHC.Types.IO ()
  waitQSemN :: QSemN -> GHC.Types.Int -> GHC.Types.IO ()
  withMVar :: forall a b. MVar a -> (a -> GHC.Types.IO b) -> GHC.Types.IO b
  withMVarMasked :: forall a b. MVar a -> (a -> GHC.Types.IO b) -> GHC.Types.IO b
  writeChan :: forall a. Chan a -> a -> GHC.Types.IO ()
  writeList2Chan :: forall a. Chan a -> [a] -> GHC.Types.IO ()
  yield :: GHC.Types.IO ()

module Control.Concurrent.Chan where
  -- Safety: Trustworthy
  type Chan :: * -> *
  data Chan a = ...
  dupChan :: forall a. Chan a -> GHC.Types.IO (Chan a)
  getChanContents :: forall a. Chan a -> GHC.Types.IO [a]
  newChan :: forall a. GHC.Types.IO (Chan a)
  readChan :: forall a. Chan a -> GHC.Types.IO a
  writeChan :: forall a. Chan a -> a -> GHC.Types.IO ()
  writeList2Chan :: forall a. Chan a -> [a] -> GHC.Types.IO ()

module Control.Concurrent.MVar where
  -- Safety: Safe
  type MVar :: * -> *
  data MVar a = ...
  addMVarFinalizer :: forall a. MVar a -> GHC.Types.IO () -> GHC.Types.IO ()
  isEmptyMVar :: forall a. MVar a -> GHC.Types.IO GHC.Types.Bool
  mkWeakMVar :: forall a. MVar a -> GHC.Types.IO () -> GHC.Types.IO (GHC.Internal.Weak.Weak (MVar a))
  modifyMVar :: forall a b. MVar a -> (a -> GHC.Types.IO (a, b)) -> GHC.Types.IO b
  modifyMVarMasked :: forall a b. MVar a -> (a -> GHC.Types.IO (a, b)) -> GHC.Types.IO b
  modifyMVarMasked_ :: forall a. MVar a -> (a -> GHC.Types.IO a) -> GHC.Types.IO ()
  modifyMVar_ :: forall a. MVar a -> (a -> GHC.Types.IO a) -> GHC.Types.IO ()
  newEmptyMVar :: forall a. GHC.Types.IO (MVar a)
  newMVar :: forall a. a -> GHC.Types.IO (MVar a)
  putMVar :: forall a. MVar a -> a -> GHC.Types.IO ()
  readMVar :: forall a. MVar a -> GHC.Types.IO a
  swapMVar :: forall a. MVar a -> a -> GHC.Types.IO a
  takeMVar :: forall a. MVar a -> GHC.Types.IO a
  tryPutMVar :: forall a. MVar a -> a -> GHC.Types.IO GHC.Types.Bool
  tryReadMVar :: forall a. MVar a -> GHC.Types.IO (GHC.Internal.Maybe.Maybe a)
  tryTakeMVar :: forall a. MVar a -> GHC.Types.IO (GHC.Internal.Maybe.Maybe a)
  withMVar :: forall a b. MVar a -> (a -> GHC.Types.IO b) -> GHC.Types.IO b
  withMVarMasked :: forall a b. MVar a -> (a -> GHC.Types.IO b) -> GHC.Types.IO b

module Control.Concurrent.QSem where
  -- Safety: Safe
  type QSem :: *
  newtype QSem = ...
  newQSem :: GHC.Types.Int -> GHC.Types.IO QSem
  signalQSem :: QSem -> GHC.Types.IO ()
  waitQSem :: QSem -> GHC.Types.IO ()

module Control.Concurrent.QSemN where
  -- Safety: Trustworthy
  type QSemN :: *
  data QSemN = ...
  newQSemN :: GHC.Types.Int -> GHC.Types.IO QSemN
  signalQSemN :: QSemN -> GHC.Types.Int -> GHC.Types.IO ()
  waitQSemN :: QSemN -> GHC.Types.Int -> GHC.Types.IO ()

module Control.Exception where
  -- Safety: Trustworthy
  type AllocationLimitExceeded :: *
  data AllocationLimitExceeded = AllocationLimitExceeded
  type ArithException :: *
  data ArithException = Overflow | Underflow | LossOfPrecision | DivideByZero | Denormal | RatioZeroDenominator
  type ArrayException :: *
  data ArrayException = IndexOutOfBounds GHC.Internal.Base.String | UndefinedElement GHC.Internal.Base.String
  type AssertionFailed :: *
  newtype AssertionFailed = AssertionFailed GHC.Internal.Base.String
  type AsyncException :: *
  data AsyncException = StackOverflow | HeapOverflow | ThreadKilled | UserInterrupt
  type BlockedIndefinitelyOnMVar :: *
  data BlockedIndefinitelyOnMVar = BlockedIndefinitelyOnMVar
  type BlockedIndefinitelyOnSTM :: *
  data BlockedIndefinitelyOnSTM = BlockedIndefinitelyOnSTM
  type CompactionFailed :: *
  newtype CompactionFailed = CompactionFailed GHC.Internal.Base.String
  type Deadlock :: *
  data Deadlock = Deadlock
  pattern ErrorCall :: GHC.Internal.Base.String -> ErrorCall
  type ErrorCall :: *
  data ErrorCall = ErrorCallWithLocation GHC.Internal.Base.String GHC.Internal.Base.String
  type Exception :: * -> Constraint
  class (ghc-internal-0.1.0.0:GHC.Internal.Data.Typeable.Internal.Typeable e, GHC.Internal.Show.Show e) => Exception e where
    toException :: e -> SomeException
    fromException :: SomeException -> GHC.Internal.Maybe.Maybe e
    displayException :: e -> GHC.Internal.Base.String
    backtraceDesired :: e -> GHC.Types.Bool
    {-# MINIMAL #-}
  type ExceptionWithContext :: * -> *
  data ExceptionWithContext a = ExceptionWithContext GHC.Internal.Exception.Context.ExceptionContext a
  type Handler :: * -> *
  data Handler a = forall e. Exception e => Handler (e -> GHC.Types.IO a)
  type IOException :: *
  data IOException = ...
  type MaskingState :: *
  data MaskingState = Unmasked | MaskedInterruptible | MaskedUninterruptible
  type NestedAtomically :: *
  data NestedAtomically = NestedAtomically
  type NoMethodError :: *
  newtype NoMethodError = NoMethodError GHC.Internal.Base.String
  type NonTermination :: *
  data NonTermination = NonTermination
  type PatternMatchFail :: *
  newtype PatternMatchFail = PatternMatchFail GHC.Internal.Base.String
  type RecConError :: *
  newtype RecConError = RecConError GHC.Internal.Base.String
  type RecSelError :: *
  newtype RecSelError = RecSelError GHC.Internal.Base.String
  type RecUpdError :: *
  newtype RecUpdError = RecUpdError GHC.Internal.Base.String
  type SomeAsyncException :: *
  data SomeAsyncException = forall e. Exception e => SomeAsyncException e
  type SomeException :: *
  data SomeException = forall e. (Exception e, GHC.Internal.Exception.Type.HasExceptionContext) => SomeException e
  type TypeError :: *
  newtype TypeError = TypeError GHC.Internal.Base.String
  addExceptionContext :: forall a. GHC.Internal.Exception.Context.ExceptionAnnotation a => a -> SomeException -> SomeException
  allowInterrupt :: GHC.Types.IO ()
  annotateIO :: forall e a. GHC.Internal.Exception.Context.ExceptionAnnotation e => e -> GHC.Types.IO a -> GHC.Types.IO a
  assert :: forall a. GHC.Types.Bool -> a -> a
  asyncExceptionFromException :: forall e. Exception e => SomeException -> GHC.Internal.Maybe.Maybe e
  asyncExceptionToException :: forall e. Exception e => e -> SomeException
  bracket :: forall a b c. GHC.Types.IO a -> (a -> GHC.Types.IO b) -> (a -> GHC.Types.IO c) -> GHC.Types.IO c
  bracketOnError :: forall a b c. GHC.Types.IO a -> (a -> GHC.Types.IO b) -> (a -> GHC.Types.IO c) -> GHC.Types.IO c
  bracket_ :: forall a b c. GHC.Types.IO a -> GHC.Types.IO b -> GHC.Types.IO c -> GHC.Types.IO c
  catch :: forall e a. Exception e => GHC.Types.IO a -> (e -> GHC.Types.IO a) -> GHC.Types.IO a
  catchJust :: forall e b a. Exception e => (e -> GHC.Internal.Maybe.Maybe b) -> GHC.Types.IO a -> (b -> GHC.Types.IO a) -> GHC.Types.IO a
  catches :: forall a. GHC.Types.IO a -> [Handler a] -> GHC.Types.IO a
  evaluate :: forall a. a -> GHC.Types.IO a
  finally :: forall a b. GHC.Types.IO a -> GHC.Types.IO b -> GHC.Types.IO a
  getMaskingState :: GHC.Types.IO MaskingState
  handle :: forall e a. Exception e => (e -> GHC.Types.IO a) -> GHC.Types.IO a -> GHC.Types.IO a
  handleJust :: forall e b a. Exception e => (e -> GHC.Internal.Maybe.Maybe b) -> (b -> GHC.Types.IO a) -> GHC.Types.IO a -> GHC.Types.IO a
  interruptible :: forall a. GHC.Types.IO a -> GHC.Types.IO a
  ioError :: forall a. GHC.Internal.IO.Exception.IOError -> GHC.Types.IO a
  mapException :: forall e1 e2 a. (Exception e1, Exception e2) => (e1 -> e2) -> a -> a
  mask :: forall b. ((forall a. GHC.Types.IO a -> GHC.Types.IO a) -> GHC.Types.IO b) -> GHC.Types.IO b
  mask_ :: forall a. GHC.Types.IO a -> GHC.Types.IO a
  onException :: forall a b. GHC.Types.IO a -> GHC.Types.IO b -> GHC.Types.IO a
  someExceptionContext :: SomeException -> GHC.Internal.Exception.Context.ExceptionContext
  throw :: forall (r :: GHC.Types.RuntimeRep) (a :: TYPE r) e. (?callStack::GHC.Internal.Stack.Types.CallStack, Exception e) => e -> a
  throwIO :: forall e a. (GHC.Internal.Stack.Types.HasCallStack, Exception e) => e -> GHC.Types.IO a
  throwTo :: forall e. Exception e => GHC.Internal.Conc.Sync.ThreadId -> e -> GHC.Types.IO ()
  try :: forall e a. Exception e => GHC.Types.IO a -> GHC.Types.IO (GHC.Internal.Data.Either.Either e a)
  tryJust :: forall e b a. Exception e => (e -> GHC.Internal.Maybe.Maybe b) -> GHC.Types.IO a -> GHC.Types.IO (GHC.Internal.Data.Either.Either b a)
  uninterruptibleMask :: forall b. ((forall a. GHC.Types.IO a -> GHC.Types.IO a) -> GHC.Types.IO b) -> GHC.Types.IO b
  uninterruptibleMask_ :: forall a. GHC.Types.IO a -> GHC.Types.IO a

module Control.Exception.Annotation where
  -- Safety: None
  type ExceptionAnnotation :: * -> Constraint
  class ghc-internal-0.1.0.0:GHC.Internal.Data.Typeable.Internal.Typeable a => ExceptionAnnotation a where
    displayExceptionAnnotation :: a -> GHC.Internal.Base.String
    default displayExceptionAnnotation :: GHC.Internal.Show.Show a => a -> GHC.Internal.Base.String
    {-# MINIMAL #-}
  type SomeExceptionAnnotation :: *
  data SomeExceptionAnnotation = forall a. ExceptionAnnotation a => SomeExceptionAnnotation a

module Control.Exception.Backtrace where
  -- Safety: None
  type BacktraceMechanism :: *
  data BacktraceMechanism = CostCentreBacktrace | HasCallStackBacktrace | ExecutionBacktrace | IPEBacktrace
  type Backtraces :: *
  data Backtraces = ...
  collectBacktraces :: (?callStack::GHC.Internal.Stack.Types.CallStack) => GHC.Types.IO Backtraces
  displayBacktraces :: Backtraces -> GHC.Internal.Base.String
  getBacktraceMechanismState :: BacktraceMechanism -> GHC.Types.IO GHC.Types.Bool
  setBacktraceMechanismState :: BacktraceMechanism -> GHC.Types.Bool -> GHC.Types.IO ()

module Control.Exception.Base where
  -- Safety: Safe
  type AllocationLimitExceeded :: *
  data AllocationLimitExceeded = AllocationLimitExceeded
  type ArithException :: *
  data ArithException = Overflow | Underflow | LossOfPrecision | DivideByZero | Denormal | RatioZeroDenominator
  type ArrayException :: *
  data ArrayException = IndexOutOfBounds GHC.Internal.Base.String | UndefinedElement GHC.Internal.Base.String
  type AssertionFailed :: *
  newtype AssertionFailed = AssertionFailed GHC.Internal.Base.String
  type AsyncException :: *
  data AsyncException = StackOverflow | HeapOverflow | ThreadKilled | UserInterrupt
  type BlockedIndefinitelyOnMVar :: *
  data BlockedIndefinitelyOnMVar = BlockedIndefinitelyOnMVar
  type BlockedIndefinitelyOnSTM :: *
  data BlockedIndefinitelyOnSTM = BlockedIndefinitelyOnSTM
  type CompactionFailed :: *
  newtype CompactionFailed = CompactionFailed GHC.Internal.Base.String
  type Deadlock :: *
  data Deadlock = Deadlock
  pattern ErrorCall :: GHC.Internal.Base.String -> ErrorCall
  type ErrorCall :: *
  data ErrorCall = ErrorCallWithLocation GHC.Internal.Base.String GHC.Internal.Base.String
  type Exception :: * -> Constraint
  class (ghc-internal-0.1.0.0:GHC.Internal.Data.Typeable.Internal.Typeable e, GHC.Internal.Show.Show e) => Exception e where
    toException :: e -> SomeException
    fromException :: SomeException -> GHC.Internal.Maybe.Maybe e
    displayException :: e -> GHC.Internal.Base.String
    backtraceDesired :: e -> GHC.Types.Bool
    {-# MINIMAL #-}
  type FixIOException :: *
  data FixIOException = FixIOException
  type IOException :: *
  data IOException = ...
  type MaskingState :: *
  data MaskingState = Unmasked | MaskedInterruptible | MaskedUninterruptible
  type NestedAtomically :: *
  data NestedAtomically = NestedAtomically
  type NoMatchingContinuationPrompt :: *
  data NoMatchingContinuationPrompt = NoMatchingContinuationPrompt
  type NoMethodError :: *
  newtype NoMethodError = NoMethodError GHC.Internal.Base.String
  type NonTermination :: *
  data NonTermination = NonTermination
  type PatternMatchFail :: *
  newtype PatternMatchFail = PatternMatchFail GHC.Internal.Base.String
  type RecConError :: *
  newtype RecConError = RecConError GHC.Internal.Base.String
  type RecSelError :: *
  newtype RecSelError = RecSelError GHC.Internal.Base.String
  type RecUpdError :: *
  newtype RecUpdError = RecUpdError GHC.Internal.Base.String
  type SomeAsyncException :: *
  data SomeAsyncException = forall e. Exception e => SomeAsyncException e
  type SomeException :: *
  data SomeException = forall e. (Exception e, GHC.Internal.Exception.Type.HasExceptionContext) => SomeException e
  type TypeError :: *
  newtype TypeError = TypeError GHC.Internal.Base.String
  assert :: forall a. GHC.Types.Bool -> a -> a
  asyncExceptionFromException :: forall e. Exception e => SomeException -> GHC.Internal.Maybe.Maybe e
  asyncExceptionToException :: forall e. Exception e => e -> SomeException
  bracket :: forall a b c. GHC.Types.IO a -> (a -> GHC.Types.IO b) -> (a -> GHC.Types.IO c) -> GHC.Types.IO c
  bracketOnError :: forall a b c. GHC.Types.IO a -> (a -> GHC.Types.IO b) -> (a -> GHC.Types.IO c) -> GHC.Types.IO c
  bracket_ :: forall a b c. GHC.Types.IO a -> GHC.Types.IO b -> GHC.Types.IO c -> GHC.Types.IO c
  catch :: forall e a. Exception e => GHC.Types.IO a -> (e -> GHC.Types.IO a) -> GHC.Types.IO a
  catchJust :: forall e b a. Exception e => (e -> GHC.Internal.Maybe.Maybe b) -> GHC.Types.IO a -> (b -> GHC.Types.IO a) -> GHC.Types.IO a
  evaluate :: forall a. a -> GHC.Types.IO a
  finally :: forall a b. GHC.Types.IO a -> GHC.Types.IO b -> GHC.Types.IO a
  getMaskingState :: GHC.Types.IO MaskingState
  handle :: forall e a. Exception e => (e -> GHC.Types.IO a) -> GHC.Types.IO a -> GHC.Types.IO a
  handleJust :: forall e b a. Exception e => (e -> GHC.Internal.Maybe.Maybe b) -> (b -> GHC.Types.IO a) -> GHC.Types.IO a -> GHC.Types.IO a
  impossibleConstraintError :: forall (q :: GHC.Types.RuntimeRep) (a :: GHC.Prim.CONSTRAINT q). GHC.Prim.Addr# -=> a
  impossibleError :: forall (q :: GHC.Types.RuntimeRep) (a :: TYPE q). GHC.Prim.Addr# -> a
  ioError :: forall a. GHC.Internal.IO.Exception.IOError -> GHC.Types.IO a
  mapException :: forall e1 e2 a. (Exception e1, Exception e2) => (e1 -> e2) -> a -> a
  mask :: forall b. ((forall a. GHC.Types.IO a -> GHC.Types.IO a) -> GHC.Types.IO b) -> GHC.Types.IO b
  mask_ :: forall a. GHC.Types.IO a -> GHC.Types.IO a
  nestedAtomically :: SomeException
  noMatchingContinuationPrompt :: SomeException
  noMethodBindingError :: forall (q :: GHC.Types.RuntimeRep) (a :: TYPE q). GHC.Prim.Addr# -> a
  nonExhaustiveGuardsError :: forall (q :: GHC.Types.RuntimeRep) (a :: TYPE q). GHC.Prim.Addr# -> a
  nonTermination :: SomeException
  onException :: forall a b. GHC.Types.IO a -> GHC.Types.IO b -> GHC.Types.IO a
  patError :: forall (q :: GHC.Types.RuntimeRep) (a :: TYPE q). GHC.Prim.Addr# -> a
  recConError :: forall (q :: GHC.Types.RuntimeRep) (a :: TYPE q). GHC.Prim.Addr# -> a
  recSelError :: forall (q :: GHC.Types.RuntimeRep) (a :: TYPE q). GHC.Prim.Addr# -> a
  throw :: forall (r :: GHC.Types.RuntimeRep) (a :: TYPE r) e. (?callStack::GHC.Internal.Stack.Types.CallStack, Exception e) => e -> a
  throwIO :: forall e a. (GHC.Internal.Stack.Types.HasCallStack, Exception e) => e -> GHC.Types.IO a
  throwTo :: forall e. Exception e => GHC.Internal.Conc.Sync.ThreadId -> e -> GHC.Types.IO ()
  try :: forall e a. Exception e => GHC.Types.IO a -> GHC.Types.IO (GHC.Internal.Data.Either.Either e a)
  tryJust :: forall e b a. Exception e => (e -> GHC.Internal.Maybe.Maybe b) -> GHC.Types.IO a -> GHC.Types.IO (GHC.Internal.Data.Either.Either b a)
  typeError :: forall (q :: GHC.Types.RuntimeRep) (a :: TYPE q). GHC.Prim.Addr# -> a
  uninterruptibleMask :: forall b. ((forall a. GHC.Types.IO a -> GHC.Types.IO a) -> GHC.Types.IO b) -> GHC.Types.IO b
  uninterruptibleMask_ :: forall a. GHC.Types.IO a -> GHC.Types.IO a

module Control.Exception.Context where
  -- Safety: None
  type ExceptionContext :: *
  data ExceptionContext = ExceptionContext [GHC.Internal.Exception.Context.SomeExceptionAnnotation]
  addExceptionAnnotation :: forall a. GHC.Internal.Exception.Context.ExceptionAnnotation a => a -> ExceptionContext -> ExceptionContext
  displayExceptionContext :: ExceptionContext -> GHC.Internal.Base.String
  emptyExceptionContext :: ExceptionContext
  getAllExceptionAnnotations :: ExceptionContext -> [GHC.Internal.Exception.Context.SomeExceptionAnnotation]
  getExceptionAnnotations :: forall a. GHC.Internal.Exception.Context.ExceptionAnnotation a => ExceptionContext -> [a]

module Control.Monad where
  -- Safety: Safe
  (<$!>) :: forall (m :: * -> *) a b. Monad m => (a -> b) -> m a -> m b
  (<=<) :: forall (m :: * -> *) b c a. Monad m => (b -> m c) -> (a -> m b) -> a -> m c
  (=<<) :: forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
  (>=>) :: forall (m :: * -> *) a b c. Monad m => (a -> m b) -> (b -> m c) -> a -> m c
  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 Monad :: (* -> *) -> Constraint
  class GHC.Internal.Base.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. GHC.Internal.Base.String -> m a
    {-# MINIMAL fail #-}
  type MonadPlus :: (* -> *) -> Constraint
  class (GHC.Internal.Base.Alternative m, Monad m) => MonadPlus m where
    mzero :: forall a. m a
    mplus :: forall a. m a -> m a -> m a
    {-# MINIMAL #-}
  ap :: forall (m :: * -> *) a b. Monad m => m (a -> b) -> m a -> m b
  filterM :: forall (m :: * -> *) a. GHC.Internal.Base.Applicative m => (a -> m GHC.Types.Bool) -> [a] -> m [a]
  foldM :: forall (t :: * -> *) (m :: * -> *) b a. (GHC.Internal.Data.Foldable.Foldable t, Monad m) => (b -> a -> m b) -> b -> t a -> m b
  foldM_ :: forall (t :: * -> *) (m :: * -> *) b a. (GHC.Internal.Data.Foldable.Foldable t, Monad m) => (b -> a -> m b) -> b -> t a -> m ()
  forM :: forall (t :: * -> *) (m :: * -> *) a b. (GHC.Internal.Data.Traversable.Traversable t, Monad m) => t a -> (a -> m b) -> m (t b)
  forM_ :: forall (t :: * -> *) (m :: * -> *) a b. (GHC.Internal.Data.Foldable.Foldable t, Monad m) => t a -> (a -> m b) -> m ()
  forever :: forall (f :: * -> *) a b. GHC.Internal.Base.Applicative f => f a -> f b
  guard :: forall (f :: * -> *). GHC.Internal.Base.Alternative f => GHC.Types.Bool -> f ()
  join :: forall (m :: * -> *) a. Monad m => m (m a) -> m a
  liftM :: forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
  liftM2 :: forall (m :: * -> *) a1 a2 r. Monad m => (a1 -> a2 -> r) -> m a1 -> m a2 -> m r
  liftM3 :: forall (m :: * -> *) a1 a2 a3 r. Monad m => (a1 -> a2 -> a3 -> r) -> m a1 -> m a2 -> m a3 -> m r
  liftM4 :: forall (m :: * -> *) a1 a2 a3 a4 r. Monad m => (a1 -> a2 -> a3 -> a4 -> r) -> m a1 -> m a2 -> m a3 -> m a4 -> m r
  liftM5 :: forall (m :: * -> *) a1 a2 a3 a4 a5 r. Monad m => (a1 -> a2 -> a3 -> a4 -> a5 -> r) -> m a1 -> m a2 -> m a3 -> m a4 -> m a5 -> m r
  mapAndUnzipM :: forall (m :: * -> *) a b c. GHC.Internal.Base.Applicative m => (a -> m (b, c)) -> [a] -> m ([b], [c])
  mapM :: forall (t :: * -> *) (m :: * -> *) a b. (GHC.Internal.Data.Traversable.Traversable t, Monad m) => (a -> m b) -> t a -> m (t b)
  mapM_ :: forall (t :: * -> *) (m :: * -> *) a b. (GHC.Internal.Data.Foldable.Foldable t, Monad m) => (a -> m b) -> t a -> m ()
  mfilter :: forall (m :: * -> *) a. MonadPlus m => (a -> GHC.Types.Bool) -> m a -> m a
  msum :: forall (t :: * -> *) (m :: * -> *) a. (GHC.Internal.Data.Foldable.Foldable t, MonadPlus m) => t (m a) -> m a
  replicateM :: forall (m :: * -> *) a. GHC.Internal.Base.Applicative m => GHC.Types.Int -> m a -> m [a]
  replicateM_ :: forall (m :: * -> *) a. GHC.Internal.Base.Applicative m => GHC.Types.Int -> m a -> m ()
  sequence :: forall (t :: * -> *) (m :: * -> *) a. (GHC.Internal.Data.Traversable.Traversable t, Monad m) => t (m a) -> m (t a)
  sequence_ :: forall (t :: * -> *) (m :: * -> *) a. (GHC.Internal.Data.Foldable.Foldable t, Monad m) => t (m a) -> m ()
  unless :: forall (f :: * -> *). GHC.Internal.Base.Applicative f => GHC.Types.Bool -> f () -> f ()
  void :: forall (f :: * -> *) a. Functor f => f a -> f ()
  when :: forall (f :: * -> *). GHC.Internal.Base.Applicative f => GHC.Types.Bool -> f () -> f ()
  zipWithM :: forall (m :: * -> *) a b c. GHC.Internal.Base.Applicative m => (a -> b -> m c) -> [a] -> [b] -> m [c]
  zipWithM_ :: forall (m :: * -> *) a b c. GHC.Internal.Base.Applicative m => (a -> b -> m c) -> [a] -> [b] -> m ()

module Control.Monad.Fail where
  -- Safety: Safe
  type MonadFail :: (* -> *) -> Constraint
  class GHC.Internal.Base.Monad m => MonadFail m where
    fail :: forall a. GHC.Internal.Base.String -> m a
    {-# MINIMAL fail #-}

module Control.Monad.Fix where
  -- Safety: Safe
  type MonadFix :: (* -> *) -> Constraint
  class GHC.Internal.Base.Monad m => MonadFix m where
    mfix :: forall a. (a -> m a) -> m a
    {-# MINIMAL mfix #-}
  fix :: forall a. (a -> a) -> a

module Control.Monad.IO.Class where
  -- Safety: Trustworthy
  type MonadIO :: (* -> *) -> Constraint
  class GHC.Internal.Base.Monad m => MonadIO m where
    liftIO :: forall a. GHC.Types.IO a -> m a
    {-# MINIMAL liftIO #-}

module Control.Monad.Instances where
  -- Safety: Trustworthy
  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 Monad :: (* -> *) -> Constraint
  class GHC.Internal.Base.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 (>>=) #-}

module Control.Monad.ST where
  -- Safety: Safe
  type RealWorld :: *
  data RealWorld
  type role ST nominal representational
  type ST :: * -> * -> *
  newtype ST s a = ...
  fixST :: forall a s. (a -> ST s a) -> ST s a
  runST :: forall a. (forall s. ST s a) -> a
  stToIO :: forall a. ST RealWorld a -> GHC.Types.IO a

module Control.Monad.ST.Lazy where
  -- Safety: Safe
  type RealWorld :: *
  data RealWorld
  type role ST nominal representational
  type ST :: * -> * -> *
  newtype ST s a = ...
  fixST :: forall a s. (a -> ST s a) -> ST s a
  lazyToStrictST :: forall s a. ST s a -> GHC.Internal.ST.ST s a
  runST :: forall a. (forall s. ST s a) -> a
  stToIO :: forall a. ST RealWorld a -> GHC.Types.IO a
  strictToLazyST :: forall s a. GHC.Internal.ST.ST s a -> ST s a

module Control.Monad.ST.Lazy.Safe where
  -- Safety: Trustworthy
  type RealWorld :: *
  data RealWorld
  type role ST nominal representational
  type ST :: * -> * -> *
  newtype ST s a = ...
  fixST :: forall a s. (a -> ST s a) -> ST s a
  lazyToStrictST :: forall s a. ST s a -> GHC.Internal.ST.ST s a
  runST :: forall a. (forall s. ST s a) -> a
  stToIO :: forall a. ST RealWorld a -> GHC.Types.IO a
  strictToLazyST :: forall s a. GHC.Internal.ST.ST s a -> ST s a

module Control.Monad.ST.Lazy.Unsafe where
  -- Safety: Unsafe
  unsafeIOToST :: forall a s. GHC.Types.IO a -> GHC.Internal.Control.Monad.ST.Lazy.Imp.ST s a
  unsafeInterleaveST :: forall s a. GHC.Internal.Control.Monad.ST.Lazy.Imp.ST s a -> GHC.Internal.Control.Monad.ST.Lazy.Imp.ST s a

module Control.Monad.ST.Safe where
  -- Safety: Trustworthy
  type RealWorld :: *
  data RealWorld
  type role ST nominal representational
  type ST :: * -> * -> *
  newtype ST s a = ...
  fixST :: forall a s. (a -> ST s a) -> ST s a
  runST :: forall a. (forall s. ST s a) -> a
  stToIO :: forall a. ST RealWorld a -> GHC.Types.IO a

module Control.Monad.ST.Strict where
  -- Safety: Safe
  type RealWorld :: *
  data RealWorld
  type role ST nominal representational
  type ST :: * -> * -> *
  newtype ST s a = ...
  fixST :: forall a s. (a -> ST s a) -> ST s a
  runST :: forall a. (forall s. ST s a) -> a
  stToIO :: forall a. ST RealWorld a -> GHC.Types.IO a

module Control.Monad.ST.Unsafe where
  -- Safety: Unsafe
  unsafeDupableInterleaveST :: forall s a. GHC.Internal.ST.ST s a -> GHC.Internal.ST.ST s a
  unsafeIOToST :: forall a s. GHC.Types.IO a -> GHC.Internal.ST.ST s a
  unsafeInterleaveST :: forall s a. GHC.Internal.ST.ST s a -> GHC.Internal.ST.ST s a
  unsafeSTToIO :: forall s a. GHC.Internal.ST.ST s a -> GHC.Types.IO a

module Control.Monad.Zip where
  -- Safety: Safe
  type MonadZip :: (* -> *) -> Constraint
  class GHC.Internal.Base.Monad m => MonadZip m where
    mzip :: forall a b. m a -> m b -> m (a, b)
    mzipWith :: forall a b c. (a -> b -> c) -> m a -> m b -> m c
    munzip :: forall a b. m (a, b) -> (m a, m b)
    {-# MINIMAL mzip | mzipWith #-}

module Data.Array.Byte where
  -- Safety: Trustworthy
  type ByteArray :: *
  data ByteArray = ByteArray GHC.Prim.ByteArray#
  type role MutableByteArray nominal
  type MutableByteArray :: * -> *
  data MutableByteArray s = MutableByteArray (GHC.Prim.MutableByteArray# s)

module Data.Bifoldable where
  -- Safety: Safe
  type Bifoldable :: (* -> * -> *) -> Constraint
  class Bifoldable p where
    bifold :: forall m. GHC.Internal.Base.Monoid m => p m m -> m
    bifoldMap :: forall m a b. GHC.Internal.Base.Monoid m => (a -> m) -> (b -> m) -> p a b -> m
    bifoldr :: forall a c b. (a -> c -> c) -> (b -> c -> c) -> c -> p a b -> c
    bifoldl :: forall c a b. (c -> a -> c) -> (c -> b -> c) -> c -> p a b -> c
    {-# MINIMAL bifoldr | bifoldMap #-}
  biList :: forall (t :: * -> * -> *) a. Bifoldable t => t a a -> [a]
  biall :: forall (t :: * -> * -> *) a b. Bifoldable t => (a -> GHC.Types.Bool) -> (b -> GHC.Types.Bool) -> t a b -> GHC.Types.Bool
  biand :: forall (t :: * -> * -> *). Bifoldable t => t GHC.Types.Bool GHC.Types.Bool -> GHC.Types.Bool
  biany :: forall (t :: * -> * -> *) a b. Bifoldable t => (a -> GHC.Types.Bool) -> (b -> GHC.Types.Bool) -> t a b -> GHC.Types.Bool
  biasum :: forall (t :: * -> * -> *) (f :: * -> *) a. (Bifoldable t, GHC.Internal.Base.Alternative f) => t (f a) (f a) -> f a
  biconcat :: forall (t :: * -> * -> *) a. Bifoldable t => t [a] [a] -> [a]
  biconcatMap :: forall (t :: * -> * -> *) a c b. Bifoldable t => (a -> [c]) -> (b -> [c]) -> t a b -> [c]
  bielem :: forall (t :: * -> * -> *) a. (Bifoldable t, GHC.Classes.Eq a) => a -> t a a -> GHC.Types.Bool
  bifind :: forall (t :: * -> * -> *) a. Bifoldable t => (a -> GHC.Types.Bool) -> t a a -> GHC.Internal.Maybe.Maybe a
  bifoldl' :: forall (t :: * -> * -> *) a b c. Bifoldable t => (a -> b -> a) -> (a -> c -> a) -> a -> t b c -> a
  bifoldl1 :: forall (t :: * -> * -> *) a. Bifoldable t => (a -> a -> a) -> t a a -> a
  bifoldlM :: forall (t :: * -> * -> *) (m :: * -> *) a b c. (Bifoldable t, GHC.Internal.Base.Monad m) => (a -> b -> m a) -> (a -> c -> m a) -> a -> t b c -> m a
  bifoldr' :: forall (t :: * -> * -> *) a c b. Bifoldable t => (a -> c -> c) -> (b -> c -> c) -> c -> t a b -> c
  bifoldr1 :: forall (t :: * -> * -> *) a. Bifoldable t => (a -> a -> a) -> t a a -> a
  bifoldrM :: forall (t :: * -> * -> *) (m :: * -> *) a c b. (Bifoldable t, GHC.Internal.Base.Monad m) => (a -> c -> m c) -> (b -> c -> m c) -> c -> t a b -> m c
  biforM_ :: forall (t :: * -> * -> *) (f :: * -> *) a b c d. (Bifoldable t, GHC.Internal.Base.Applicative f) => t a b -> (a -> f c) -> (b -> f d) -> f ()
  bifor_ :: forall (t :: * -> * -> *) (f :: * -> *) a b c d. (Bifoldable t, GHC.Internal.Base.Applicative f) => t a b -> (a -> f c) -> (b -> f d) -> f ()
  bilength :: forall (t :: * -> * -> *) a b. Bifoldable t => t a b -> GHC.Types.Int
  bimapM_ :: forall (t :: * -> * -> *) (f :: * -> *) a c b d. (Bifoldable t, GHC.Internal.Base.Applicative f) => (a -> f c) -> (b -> f d) -> t a b -> f ()
  bimaximum :: forall (t :: * -> * -> *) a. (Bifoldable t, GHC.Classes.Ord a) => t a a -> a
  bimaximumBy :: forall (t :: * -> * -> *) a. Bifoldable t => (a -> a -> GHC.Types.Ordering) -> t a a -> a
  biminimum :: forall (t :: * -> * -> *) a. (Bifoldable t, GHC.Classes.Ord a) => t a a -> a
  biminimumBy :: forall (t :: * -> * -> *) a. Bifoldable t => (a -> a -> GHC.Types.Ordering) -> t a a -> a
  bimsum :: forall (t :: * -> * -> *) (f :: * -> *) a. (Bifoldable t, GHC.Internal.Base.Alternative f) => t (f a) (f a) -> f a
  binotElem :: forall (t :: * -> * -> *) a. (Bifoldable t, GHC.Classes.Eq a) => a -> t a a -> GHC.Types.Bool
  binull :: forall (t :: * -> * -> *) a b. Bifoldable t => t a b -> GHC.Types.Bool
  bior :: forall (t :: * -> * -> *). Bifoldable t => t GHC.Types.Bool GHC.Types.Bool -> GHC.Types.Bool
  biproduct :: forall (t :: * -> * -> *) a. (Bifoldable t, GHC.Internal.Num.Num a) => t a a -> a
  bisequenceA_ :: forall (t :: * -> * -> *) (f :: * -> *) a b. (Bifoldable t, GHC.Internal.Base.Applicative f) => t (f a) (f b) -> f ()
  bisequence_ :: forall (t :: * -> * -> *) (f :: * -> *) a b. (Bifoldable t, GHC.Internal.Base.Applicative f) => t (f a) (f b) -> f ()
  bisum :: forall (t :: * -> * -> *) a. (Bifoldable t, GHC.Internal.Num.Num a) => t a a -> a
  bitraverse_ :: forall (t :: * -> * -> *) (f :: * -> *) a c b d. (Bifoldable t, GHC.Internal.Base.Applicative f) => (a -> f c) -> (b -> f d) -> t a b -> f ()

module Data.Bifoldable1 where
  -- Safety: Safe
  type Bifoldable1 :: (* -> * -> *) -> Constraint
  class Data.Bifoldable.Bifoldable t => Bifoldable1 t where
    bifold1 :: forall m. GHC.Internal.Base.Semigroup m => t m m -> m
    bifoldMap1 :: forall m a b. GHC.Internal.Base.Semigroup m => (a -> m) -> (b -> m) -> t a b -> m
    {-# MINIMAL bifoldMap1 #-}

module Data.Bifunctor where
  -- Safety: Safe
  type Bifunctor :: (* -> * -> *) -> Constraint
  class (forall a. GHC.Internal.Base.Functor (p a)) => Bifunctor p where
    bimap :: forall a b c d. (a -> b) -> (c -> d) -> p a c -> p b d
    first :: forall a b c. (a -> b) -> p a c -> p b c
    second :: forall b c a. (b -> c) -> p a b -> p a c
    {-# MINIMAL bimap | first, second #-}

module Data.Bitraversable where
  -- Safety: Trustworthy
  type Bitraversable :: (* -> * -> *) -> Constraint
  class (Data.Bifunctor.Bifunctor t, Data.Bifoldable.Bifoldable t) => Bitraversable t where
    bitraverse :: forall (f :: * -> *) a c b d. GHC.Internal.Base.Applicative f => (a -> f c) -> (b -> f d) -> t a b -> f (t c d)
    {-# MINIMAL bitraverse #-}
  bifoldMapDefault :: forall (t :: * -> * -> *) m a b. (Bitraversable t, GHC.Internal.Base.Monoid m) => (a -> m) -> (b -> m) -> t a b -> m
  bifor :: forall (t :: * -> * -> *) (f :: * -> *) a b c d. (Bitraversable t, GHC.Internal.Base.Applicative f) => t a b -> (a -> f c) -> (b -> f d) -> f (t c d)
  biforM :: forall (t :: * -> * -> *) (f :: * -> *) a b c d. (Bitraversable t, GHC.Internal.Base.Applicative f) => t a b -> (a -> f c) -> (b -> f d) -> f (t c d)
  bimapAccumL :: forall (t :: * -> * -> *) a b c d e. Bitraversable t => (a -> b -> (a, c)) -> (a -> d -> (a, e)) -> a -> t b d -> (a, t c e)
  bimapAccumR :: forall (t :: * -> * -> *) a b c d e. Bitraversable t => (a -> b -> (a, c)) -> (a -> d -> (a, e)) -> a -> t b d -> (a, t c e)
  bimapDefault :: forall (t :: * -> * -> *) a b c d. Bitraversable t => (a -> b) -> (c -> d) -> t a c -> t b d
  bimapM :: forall (t :: * -> * -> *) (f :: * -> *) a c b d. (Bitraversable t, GHC.Internal.Base.Applicative f) => (a -> f c) -> (b -> f d) -> t a b -> f (t c d)
  bisequence :: forall (t :: * -> * -> *) (f :: * -> *) a b. (Bitraversable t, GHC.Internal.Base.Applicative f) => t (f a) (f b) -> f (t a b)
  bisequenceA :: forall (t :: * -> * -> *) (f :: * -> *) a b. (Bitraversable t, GHC.Internal.Base.Applicative f) => t (f a) (f b) -> f (t a b)

module Data.Bits where
  -- Safety: Safe
  (!<<.) :: forall a. Bits a => a -> GHC.Types.Int -> a
  (!>>.) :: forall a. Bits a => a -> GHC.Types.Int -> a
  (.<<.) :: forall a. Bits a => a -> GHC.Types.Int -> a
  (.>>.) :: forall a. Bits a => a -> GHC.Types.Int -> a
  (.^.) :: forall a. Bits a => a -> a -> a
  type And :: * -> *
  newtype And a = And {getAnd :: a}
  type Bits :: * -> Constraint
  class GHC.Classes.Eq a => Bits a where
    (.&.) :: a -> a -> a
    (.|.) :: a -> a -> a
    xor :: a -> a -> a
    complement :: a -> a
    shift :: a -> GHC.Types.Int -> a
    rotate :: a -> GHC.Types.Int -> a
    zeroBits :: a
    bit :: GHC.Types.Int -> a
    setBit :: a -> GHC.Types.Int -> a
    clearBit :: a -> GHC.Types.Int -> a
    complementBit :: a -> GHC.Types.Int -> a
    testBit :: a -> GHC.Types.Int -> GHC.Types.Bool
    bitSizeMaybe :: a -> GHC.Internal.Maybe.Maybe GHC.Types.Int
    bitSize :: a -> GHC.Types.Int
    isSigned :: a -> GHC.Types.Bool
    shiftL :: a -> GHC.Types.Int -> a
    unsafeShiftL :: a -> GHC.Types.Int -> a
    shiftR :: a -> GHC.Types.Int -> a
    unsafeShiftR :: a -> GHC.Types.Int -> a
    rotateL :: a -> GHC.Types.Int -> a
    rotateR :: a -> GHC.Types.Int -> a
    popCount :: a -> GHC.Types.Int
    {-# MINIMAL (.&.), (.|.), xor, complement, (shift | (shiftL, shiftR)), (rotate | (rotateL, rotateR)), bitSize, bitSizeMaybe, isSigned, testBit, bit, popCount #-}
  type FiniteBits :: * -> Constraint
  class Bits b => FiniteBits b where
    finiteBitSize :: b -> GHC.Types.Int
    countLeadingZeros :: b -> GHC.Types.Int
    countTrailingZeros :: b -> GHC.Types.Int
    {-# MINIMAL finiteBitSize #-}
  type Iff :: * -> *
  newtype Iff a = Iff {getIff :: a}
  type Ior :: * -> *
  newtype Ior a = Ior {getIor :: a}
  type Xor :: * -> *
  newtype Xor a = Xor {getXor :: a}
  bitDefault :: forall a. (Bits a, GHC.Internal.Num.Num a) => GHC.Types.Int -> a
  oneBits :: forall a. FiniteBits a => a
  popCountDefault :: forall a. (Bits a, GHC.Internal.Num.Num a) => a -> GHC.Types.Int
  testBitDefault :: forall a. (Bits a, GHC.Internal.Num.Num a) => a -> GHC.Types.Int -> GHC.Types.Bool
  toIntegralSized :: forall a b. (GHC.Internal.Real.Integral a, GHC.Internal.Real.Integral b, Bits a, Bits b) => a -> GHC.Internal.Maybe.Maybe b

module Data.Bool where
  -- Safety: Safe
  (&&) :: Bool -> Bool -> Bool
  type Bool :: *
  data Bool = False | True
  bool :: forall a. a -> a -> Bool -> a
  not :: Bool -> Bool
  otherwise :: Bool
  (||) :: Bool -> Bool -> Bool

module Data.Char where
  -- Safety: Trustworthy
  type Char :: *
  data Char = ...
  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
  chr :: GHC.Types.Int -> Char
  digitToInt :: Char -> GHC.Types.Int
  generalCategory :: Char -> GeneralCategory
  intToDigit :: GHC.Types.Int -> Char
  isAlpha :: Char -> GHC.Types.Bool
  isAlphaNum :: Char -> GHC.Types.Bool
  isAscii :: Char -> GHC.Types.Bool
  isAsciiLower :: Char -> GHC.Types.Bool
  isAsciiUpper :: Char -> GHC.Types.Bool
  isControl :: Char -> GHC.Types.Bool
  isDigit :: Char -> GHC.Types.Bool
  isHexDigit :: Char -> GHC.Types.Bool
  isLatin1 :: Char -> GHC.Types.Bool
  isLetter :: Char -> GHC.Types.Bool
  isLower :: Char -> GHC.Types.Bool
  isLowerCase :: Char -> GHC.Types.Bool
  isMark :: Char -> GHC.Types.Bool
  isNumber :: Char -> GHC.Types.Bool
  isOctDigit :: Char -> GHC.Types.Bool
  isPrint :: Char -> GHC.Types.Bool
  isPunctuation :: Char -> GHC.Types.Bool
  isSeparator :: Char -> GHC.Types.Bool
  isSpace :: Char -> GHC.Types.Bool
  isSymbol :: Char -> GHC.Types.Bool
  isUpper :: Char -> GHC.Types.Bool
  isUpperCase :: Char -> GHC.Types.Bool
  lexLitChar :: GHC.Internal.Text.ParserCombinators.ReadP.ReadS GHC.Internal.Base.String
  ord :: Char -> GHC.Types.Int
  readLitChar :: GHC.Internal.Text.ParserCombinators.ReadP.ReadS Char
  showLitChar :: Char -> GHC.Internal.Show.ShowS
  toLower :: Char -> Char
  toTitle :: Char -> Char
  toUpper :: Char -> Char

module Data.Coerce where
  -- Safety: None
  type role Coercible representational representational
  type Coercible :: forall k. k -> k -> Constraint
  class Coercible a b => Coercible a b
    {-# MINIMAL #-}
  coerce :: forall {k :: GHC.Types.RuntimeRep} (a :: TYPE k) (b :: TYPE k). Coercible a b => a -> b

module Data.Complex where
  -- Safety: Trustworthy
  type Complex :: * -> *
  data Complex a = !a :+ !a
  cis :: forall a. GHC.Internal.Float.Floating a => a -> Complex a
  conjugate :: forall a. GHC.Internal.Num.Num a => Complex a -> Complex a
  imagPart :: forall a. Complex a -> a
  magnitude :: forall a. GHC.Internal.Float.RealFloat a => Complex a -> a
  mkPolar :: forall a. GHC.Internal.Float.Floating a => a -> a -> Complex a
  phase :: forall a. GHC.Internal.Float.RealFloat a => Complex a -> a
  polar :: forall a. GHC.Internal.Float.RealFloat a => Complex a -> (a, a)
  realPart :: forall a. Complex a -> a

module Data.Data where
  -- Safety: Safe
  type role (:~:) nominal nominal
  type (:~:) :: forall {k}. k -> k -> *
  data (:~:) a b where
    Refl :: forall {k} (a :: k). (:~:) a a
  type role (:~~:) nominal nominal
  type (:~~:) :: forall k1 k2. k1 -> k2 -> *
  data (:~~:) a b where
    HRefl :: forall {k1} (a :: k1). (:~~:) a a
  type ConIndex :: *
  type ConIndex = GHC.Types.Int
  type Constr :: *
  data Constr = ...
  type ConstrRep :: *
  data ConstrRep = AlgConstr ConIndex | IntConstr GHC.Num.Integer.Integer | FloatConstr GHC.Internal.Real.Rational | CharConstr GHC.Types.Char
  type Data :: * -> Constraint
  class Typeable a => Data a where
    gfoldl :: forall (c :: * -> *). (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> a -> c a
    gunfold :: forall (c :: * -> *). (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c a
    toConstr :: a -> Constr
    dataTypeOf :: a -> DataType
    dataCast1 :: forall (t :: * -> *) (c :: * -> *). Typeable t => (forall d. Data d => c (t d)) -> GHC.Internal.Maybe.Maybe (c a)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *). Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> GHC.Internal.Maybe.Maybe (c a)
    gmapT :: (forall b. Data b => b -> b) -> a -> a
    gmapQl :: forall r r'. (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r
    gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r
    gmapQ :: forall u. (forall d. Data d => d -> u) -> a -> [u]
    gmapQi :: forall u. GHC.Types.Int -> (forall d. Data d => d -> u) -> a -> u
    gmapM :: forall (m :: * -> *). GHC.Internal.Base.Monad m => (forall d. Data d => d -> m d) -> a -> m a
    gmapMp :: forall (m :: * -> *). GHC.Internal.Base.MonadPlus m => (forall d. Data d => d -> m d) -> a -> m a
    gmapMo :: forall (m :: * -> *). GHC.Internal.Base.MonadPlus m => (forall d. Data d => d -> m d) -> a -> m a
    {-# MINIMAL gunfold, toConstr, dataTypeOf #-}
  type DataRep :: *
  data DataRep = AlgRep [Constr] | IntRep | FloatRep | CharRep | NoRep
  type DataType :: *
  data DataType = ...
  type Fixity :: *
  data Fixity = Prefix | Infix
  type role Proxy phantom
  type Proxy :: forall {k}. k -> *
  data Proxy t = Proxy
  type TyCon :: *
  data TyCon = ...
  type TypeRep :: *
  type TypeRep = ghc-internal-0.1.0.0:GHC.Internal.Data.Typeable.Internal.SomeTypeRep
  type Typeable :: forall k. k -> Constraint
  class Typeable a where
    ...
    {-# MINIMAL ghc-internal-0.1.0.0:GHC.Internal.Data.Typeable.Internal.typeRep# #-}
  cast :: forall a b. (Typeable a, Typeable b) => a -> GHC.Internal.Maybe.Maybe b
  constrFields :: Constr -> [GHC.Internal.Base.String]
  constrFixity :: Constr -> Fixity
  constrIndex :: Constr -> ConIndex
  constrRep :: Constr -> ConstrRep
  constrType :: Constr -> DataType
  dataTypeConstrs :: DataType -> [Constr]
  dataTypeName :: DataType -> GHC.Internal.Base.String
  dataTypeRep :: DataType -> DataRep
  decT :: forall {k} (a :: k) (b :: k). (Typeable a, Typeable b) => GHC.Internal.Data.Either.Either ((a :~: b) -> GHC.Internal.Base.Void) (a :~: b)
  eqT :: forall {k} (a :: k) (b :: k). (Typeable a, Typeable b) => GHC.Internal.Maybe.Maybe (a :~: b)
  fromConstr :: forall a. Data a => Constr -> a
  fromConstrB :: forall a. Data a => (forall d. Data d => d) -> Constr -> a
  fromConstrM :: forall (m :: * -> *) a. (GHC.Internal.Base.Monad m, Data a) => (forall d. Data d => m d) -> Constr -> m a
  funResultTy :: TypeRep -> TypeRep -> GHC.Internal.Maybe.Maybe TypeRep
  gcast :: forall {k} (a :: k) (b :: k) (c :: k -> *). (Typeable a, Typeable b) => c a -> GHC.Internal.Maybe.Maybe (c b)
  gcast1 :: forall {k1} {k2} (c :: k1 -> *) (t :: k2 -> k1) (t' :: k2 -> k1) (a :: k2). (Typeable t, Typeable t') => c (t a) -> GHC.Internal.Maybe.Maybe (c (t' a))
  gcast2 :: forall {k1} {k2} {k3} (c :: k1 -> *) (t :: k2 -> k3 -> k1) (t' :: k2 -> k3 -> k1) (a :: k2) (b :: k3). (Typeable t, Typeable t') => c (t a b) -> GHC.Internal.Maybe.Maybe (c (t' a b))
  hdecT :: forall {k1} {k2} (a :: k1) (b :: k2). (Typeable a, Typeable b) => GHC.Internal.Data.Either.Either ((a :~~: b) -> GHC.Internal.Base.Void) (a :~~: b)
  heqT :: forall {k1} {k2} (a :: k1) (b :: k2). (Typeable a, Typeable b) => GHC.Internal.Maybe.Maybe (a :~~: b)
  indexConstr :: DataType -> ConIndex -> Constr
  isAlgType :: DataType -> GHC.Types.Bool
  isNorepType :: DataType -> GHC.Types.Bool
  maxConstrIndex :: DataType -> ConIndex
  mkCharConstr :: DataType -> GHC.Types.Char -> Constr
  mkCharType :: GHC.Internal.Base.String -> DataType
  mkConstr :: DataType -> GHC.Internal.Base.String -> [GHC.Internal.Base.String] -> Fixity -> Constr
  mkConstrTag :: DataType -> GHC.Internal.Base.String -> GHC.Types.Int -> [GHC.Internal.Base.String] -> Fixity -> Constr
  mkDataType :: GHC.Internal.Base.String -> [Constr] -> DataType
  mkFloatType :: GHC.Internal.Base.String -> DataType
  mkFunTy :: TypeRep -> TypeRep -> TypeRep
  mkIntType :: GHC.Internal.Base.String -> DataType
  mkIntegralConstr :: forall a. (GHC.Internal.Real.Integral a, GHC.Internal.Show.Show a) => DataType -> a -> Constr
  mkNoRepType :: GHC.Internal.Base.String -> DataType
  mkRealConstr :: forall a. (GHC.Internal.Real.Real a, GHC.Internal.Show.Show a) => DataType -> a -> Constr
  readConstr :: DataType -> GHC.Internal.Base.String -> GHC.Internal.Maybe.Maybe Constr
  repConstr :: DataType -> ConstrRep -> Constr
  rnfTyCon :: TyCon -> ()
  rnfTypeRep :: TypeRep -> ()
  showConstr :: Constr -> GHC.Internal.Base.String
  showsTypeRep :: TypeRep -> GHC.Internal.Show.ShowS
  splitTyConApp :: TypeRep -> (TyCon, [TypeRep])
  trLiftedRep :: ghc-internal-0.1.0.0:GHC.Internal.Data.Typeable.Internal.TypeRep GHC.Types.LiftedRep
  tyConFingerprint :: TyCon -> GHC.Internal.Fingerprint.Type.Fingerprint
  tyConModule :: TyCon -> GHC.Internal.Base.String
  tyConName :: TyCon -> GHC.Internal.Base.String
  tyConPackage :: TyCon -> GHC.Internal.Base.String
  tyconModule :: GHC.Internal.Base.String -> GHC.Internal.Base.String
  tyconUQname :: GHC.Internal.Base.String -> GHC.Internal.Base.String
  typeOf :: forall a. Typeable a => a -> TypeRep
  typeOf1 :: forall (t :: * -> *) a. Typeable t => t a -> TypeRep
  typeOf2 :: forall (t :: * -> * -> *) a b. Typeable t => t a b -> TypeRep
  typeOf3 :: forall (t :: * -> * -> * -> *) a b c. Typeable t => t a b c -> TypeRep
  typeOf4 :: forall (t :: * -> * -> * -> * -> *) a b c d. Typeable t => t a b c d -> TypeRep
  typeOf5 :: forall (t :: * -> * -> * -> * -> * -> *) a b c d e. Typeable t => t a b c d e -> TypeRep
  typeOf6 :: forall (t :: * -> * -> * -> * -> * -> * -> *) a b c d e f. Typeable t => t a b c d e f -> TypeRep
  typeOf7 :: forall (t :: * -> * -> * -> * -> * -> * -> * -> *) a b c d e f g. Typeable t => t a b c d e f g -> TypeRep
  typeRep :: forall {k} (proxy :: k -> *) (a :: k). Typeable a => proxy a -> TypeRep
  typeRepArgs :: TypeRep -> [TypeRep]
  typeRepFingerprint :: TypeRep -> GHC.Internal.Fingerprint.Type.Fingerprint
  typeRepTyCon :: TypeRep -> TyCon

module Data.Dynamic where
  -- Safety: Safe
  type Dynamic :: *
  data Dynamic where
    Dynamic :: forall a. ghc-internal-0.1.0.0:GHC.Internal.Data.Typeable.Internal.TypeRep a -> a -> Dynamic
  type Typeable :: forall k. k -> Constraint
  class Typeable a where
    ...
    {-# MINIMAL ghc-internal-0.1.0.0:GHC.Internal.Data.Typeable.Internal.typeRep# #-}
  dynApp :: Dynamic -> Dynamic -> Dynamic
  dynApply :: Dynamic -> Dynamic -> GHC.Internal.Maybe.Maybe Dynamic
  dynTypeRep :: Dynamic -> ghc-internal-0.1.0.0:GHC.Internal.Data.Typeable.Internal.SomeTypeRep
  fromDyn :: forall a. Typeable a => Dynamic -> a -> a
  fromDynamic :: forall a. Typeable a => Dynamic -> GHC.Internal.Maybe.Maybe a
  toDyn :: forall a. Typeable a => a -> Dynamic

module Data.Either where
  -- Safety: Safe
  type Either :: * -> * -> *
  data Either a b = Left a | Right b
  either :: forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
  fromLeft :: forall a b. a -> Either a b -> a
  fromRight :: forall b a. b -> Either a b -> b
  isLeft :: forall a b. Either a b -> GHC.Types.Bool
  isRight :: forall a b. Either a b -> GHC.Types.Bool
  lefts :: forall a b. [Either a b] -> [a]
  partitionEithers :: forall a b. [Either a b] -> ([a], [b])
  rights :: forall a b. [Either a b] -> [b]

module Data.Enum where
  -- Safety: Safe
  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 #-}

module Data.Eq where
  -- Safety: Safe
  type Eq :: * -> Constraint
  class Eq a where
    (==) :: a -> a -> GHC.Types.Bool
    (/=) :: a -> a -> GHC.Types.Bool
    {-# MINIMAL (==) | (/=) #-}

module Data.Fixed where
  -- Safety: Trustworthy
  type Centi :: *
  type Centi = Fixed E2
  type Deci :: *
  type Deci = Fixed E1
  type E0 :: *
  data E0
  type E1 :: *
  data E1
  type E12 :: *
  data E12
  type E2 :: *
  data E2
  type E3 :: *
  data E3
  type E6 :: *
  data E6
  type E9 :: *
  data E9
  type role Fixed phantom
  type Fixed :: forall k. k -> *
  newtype Fixed a = MkFixed GHC.Num.Integer.Integer
  type HasResolution :: forall k. k -> Constraint
  class HasResolution a where
    resolution :: forall (p :: k -> *). p a -> GHC.Num.Integer.Integer
    {-# MINIMAL resolution #-}
  type Micro :: *
  type Micro = Fixed E6
  type Milli :: *
  type Milli = Fixed E3
  type Nano :: *
  type Nano = Fixed E9
  type Pico :: *
  type Pico = Fixed E12
  type Uni :: *
  type Uni = Fixed E0
  div' :: forall a b. (GHC.Internal.Real.Real a, GHC.Internal.Real.Integral b) => a -> a -> b
  divMod' :: forall a b. (GHC.Internal.Real.Real a, GHC.Internal.Real.Integral b) => a -> a -> (b, a)
  mod' :: forall a. GHC.Internal.Real.Real a => a -> a -> a
  showFixed :: forall {k} (a :: k). HasResolution a => GHC.Types.Bool -> Fixed a -> GHC.Internal.Base.String

module Data.Foldable where
  -- Safety: Safe
  type Foldable :: (* -> *) -> Constraint
  class Foldable t where
    fold :: forall m. GHC.Internal.Base.Monoid m => t m -> m
    foldMap :: forall m a. GHC.Internal.Base.Monoid m => (a -> m) -> t a -> m
    foldMap' :: forall m a. GHC.Internal.Base.Monoid m => (a -> m) -> t a -> m
    foldr :: forall a b. (a -> b -> b) -> b -> t a -> b
    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
    toList :: forall a. t a -> [a]
    null :: forall a. t a -> GHC.Types.Bool
    length :: forall a. t a -> GHC.Types.Int
    elem :: forall a. GHC.Classes.Eq a => a -> t a -> GHC.Types.Bool
    maximum :: forall a. GHC.Classes.Ord a => t a -> a
    minimum :: forall a. GHC.Classes.Ord a => t a -> a
    sum :: forall a. GHC.Internal.Num.Num a => t a -> a
    product :: forall a. GHC.Internal.Num.Num a => t a -> a
    {-# MINIMAL foldMap | foldr #-}
  all :: forall (t :: * -> *) a. Foldable t => (a -> GHC.Types.Bool) -> t a -> GHC.Types.Bool
  and :: forall (t :: * -> *). Foldable t => t GHC.Types.Bool -> GHC.Types.Bool
  any :: forall (t :: * -> *) a. Foldable t => (a -> GHC.Types.Bool) -> t a -> GHC.Types.Bool
  asum :: forall (t :: * -> *) (f :: * -> *) a. (Foldable t, GHC.Internal.Base.Alternative f) => t (f a) -> f a
  concat :: forall (t :: * -> *) a. Foldable t => t [a] -> [a]
  concatMap :: forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
  find :: forall (t :: * -> *) a. Foldable t => (a -> GHC.Types.Bool) -> t a -> GHC.Internal.Maybe.Maybe a
  foldlM :: forall (t :: * -> *) (m :: * -> *) b a. (Foldable t, GHC.Internal.Base.Monad m) => (b -> a -> m b) -> b -> t a -> m b
  foldrM :: forall (t :: * -> *) (m :: * -> *) a b. (Foldable t, GHC.Internal.Base.Monad m) => (a -> b -> m b) -> b -> t a -> m b
  forM_ :: forall (t :: * -> *) (m :: * -> *) a b. (Foldable t, GHC.Internal.Base.Monad m) => t a -> (a -> m b) -> m ()
  for_ :: forall (t :: * -> *) (f :: * -> *) a b. (Foldable t, GHC.Internal.Base.Applicative f) => t a -> (a -> f b) -> f ()
  mapM_ :: forall (t :: * -> *) (m :: * -> *) a b. (Foldable t, GHC.Internal.Base.Monad m) => (a -> m b) -> t a -> m ()
  maximumBy :: forall (t :: * -> *) a. Foldable t => (a -> a -> GHC.Types.Ordering) -> t a -> a
  minimumBy :: forall (t :: * -> *) a. Foldable t => (a -> a -> GHC.Types.Ordering) -> t a -> a
  msum :: forall (t :: * -> *) (m :: * -> *) a. (Foldable t, GHC.Internal.Base.MonadPlus m) => t (m a) -> m a
  notElem :: forall (t :: * -> *) a. (Foldable t, GHC.Classes.Eq a) => a -> t a -> GHC.Types.Bool
  or :: forall (t :: * -> *). Foldable t => t GHC.Types.Bool -> GHC.Types.Bool
  sequenceA_ :: forall (t :: * -> *) (f :: * -> *) a. (Foldable t, GHC.Internal.Base.Applicative f) => t (f a) -> f ()
  sequence_ :: forall (t :: * -> *) (m :: * -> *) a. (Foldable t, GHC.Internal.Base.Monad m) => t (m a) -> m ()
  traverse_ :: forall (t :: * -> *) (f :: * -> *) a b. (Foldable t, GHC.Internal.Base.Applicative f) => (a -> f b) -> t a -> f ()

module Data.Foldable1 where
  -- Safety: Trustworthy
  type Foldable1 :: (* -> *) -> Constraint
  class GHC.Internal.Data.Foldable.Foldable t => Foldable1 t where
    fold1 :: forall m. GHC.Internal.Base.Semigroup m => t m -> m
    foldMap1 :: forall m a. GHC.Internal.Base.Semigroup m => (a -> m) -> t a -> m
    foldMap1' :: forall m a. GHC.Internal.Base.Semigroup m => (a -> m) -> t a -> m
    toNonEmpty :: forall a. t a -> GHC.Internal.Base.NonEmpty a
    maximum :: forall a. GHC.Classes.Ord a => t a -> a
    minimum :: forall a. GHC.Classes.Ord a => t a -> a
    head :: forall a. t a -> a
    last :: forall a. t a -> a
    foldrMap1 :: forall a b. (a -> b) -> (a -> b -> b) -> t a -> b
    foldlMap1' :: forall a b. (a -> b) -> (b -> a -> b) -> t a -> b
    foldlMap1 :: forall a b. (a -> b) -> (b -> a -> b) -> t a -> b
    foldrMap1' :: forall a b. (a -> b) -> (a -> b -> b) -> t a -> b
    {-# MINIMAL foldMap1 | foldrMap1 #-}
  foldl1 :: forall (t :: * -> *) a. Foldable1 t => (a -> a -> a) -> t a -> a
  foldl1' :: forall (t :: * -> *) a. Foldable1 t => (a -> a -> a) -> t a -> a
  foldlM1 :: forall (t :: * -> *) (m :: * -> *) a. (Foldable1 t, GHC.Internal.Base.Monad m) => (a -> a -> m a) -> t a -> m a
  foldlMapM1 :: forall (t :: * -> *) (m :: * -> *) a b. (Foldable1 t, GHC.Internal.Base.Monad m) => (a -> m b) -> (b -> a -> m b) -> t a -> m b
  foldr1 :: forall (t :: * -> *) a. Foldable1 t => (a -> a -> a) -> t a -> a
  foldr1' :: forall (t :: * -> *) a. Foldable1 t => (a -> a -> a) -> t a -> a
  foldrM1 :: forall (t :: * -> *) (m :: * -> *) a. (Foldable1 t, GHC.Internal.Base.Monad m) => (a -> a -> m a) -> t a -> m a
  foldrMapM1 :: forall (t :: * -> *) (m :: * -> *) a b. (Foldable1 t, GHC.Internal.Base.Monad m) => (a -> m b) -> (a -> b -> m b) -> t a -> m b
  intercalate1 :: forall (t :: * -> *) m. (Foldable1 t, GHC.Internal.Base.Semigroup m) => m -> t m -> m
  maximumBy :: forall (t :: * -> *) a. Foldable1 t => (a -> a -> GHC.Types.Ordering) -> t a -> a
  minimumBy :: forall (t :: * -> *) a. Foldable1 t => (a -> a -> GHC.Types.Ordering) -> t a -> a

module Data.Function where
  -- Safety: Safe
  ($) :: 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 -> (a -> b) -> b
  (.) :: forall b c a. (b -> c) -> (a -> b) -> a -> c
  applyWhen :: forall a. GHC.Types.Bool -> (a -> a) -> a -> a
  const :: forall a b. a -> b -> a
  fix :: forall a. (a -> a) -> a
  flip :: forall a b c. (a -> b -> c) -> b -> a -> c
  id :: forall a. a -> a
  on :: forall b c a. (b -> b -> c) -> (a -> b) -> a -> a -> c

module Data.Functor where
  -- Safety: Safe
  ($>) :: forall (f :: * -> *) a b. Functor f => f a -> b -> f b
  (<$>) :: forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
  (<&>) :: forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
  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 #-}
  unzip :: forall (f :: * -> *) a b. Functor f => f (a, b) -> (f a, f b)
  void :: forall (f :: * -> *) a. Functor f => f a -> f ()

module Data.Functor.Classes where
  -- Safety: Safe
  type Eq1 :: (* -> *) -> Constraint
  class (forall a. GHC.Classes.Eq a => GHC.Classes.Eq (f a)) => Eq1 f where
    liftEq :: forall a b. (a -> b -> GHC.Types.Bool) -> f a -> f b -> GHC.Types.Bool
    default liftEq :: forall (f' :: * -> * -> *) c a b. (f ~ f' c, Eq2 f', GHC.Classes.Eq c) => (a -> b -> GHC.Types.Bool) -> f a -> f b -> GHC.Types.Bool
    {-# MINIMAL #-}
  type Eq2 :: (* -> * -> *) -> Constraint
  class (forall a. GHC.Classes.Eq a => Eq1 (f a)) => Eq2 f where
    liftEq2 :: forall a b c d. (a -> b -> GHC.Types.Bool) -> (c -> d -> GHC.Types.Bool) -> f a c -> f b d -> GHC.Types.Bool
    {-# MINIMAL liftEq2 #-}
  type Ord1 :: (* -> *) -> Constraint
  class (Eq1 f, forall a. GHC.Classes.Ord a => GHC.Classes.Ord (f a)) => Ord1 f where
    liftCompare :: forall a b. (a -> b -> GHC.Types.Ordering) -> f a -> f b -> GHC.Types.Ordering
    default liftCompare :: forall (f' :: * -> * -> *) c a b. (f ~ f' c, Ord2 f', GHC.Classes.Ord c) => (a -> b -> GHC.Types.Ordering) -> f a -> f b -> GHC.Types.Ordering
    {-# MINIMAL #-}
  type Ord2 :: (* -> * -> *) -> Constraint
  class (Eq2 f, forall a. GHC.Classes.Ord a => Ord1 (f a)) => Ord2 f where
    liftCompare2 :: forall a b c d. (a -> b -> GHC.Types.Ordering) -> (c -> d -> GHC.Types.Ordering) -> f a c -> f b d -> GHC.Types.Ordering
    {-# MINIMAL liftCompare2 #-}
  type Read1 :: (* -> *) -> Constraint
  class (forall a. GHC.Internal.Read.Read a => GHC.Internal.Read.Read (f a)) => Read1 f where
    liftReadsPrec :: forall a. (GHC.Types.Int -> GHC.Internal.Text.ParserCombinators.ReadP.ReadS a) -> GHC.Internal.Text.ParserCombinators.ReadP.ReadS [a] -> GHC.Types.Int -> GHC.Internal.Text.ParserCombinators.ReadP.ReadS (f a)
    liftReadList :: forall a. (GHC.Types.Int -> GHC.Internal.Text.ParserCombinators.ReadP.ReadS a) -> GHC.Internal.Text.ParserCombinators.ReadP.ReadS [a] -> GHC.Internal.Text.ParserCombinators.ReadP.ReadS [f a]
    liftReadPrec :: forall a. GHC.Internal.Text.ParserCombinators.ReadPrec.ReadPrec a -> GHC.Internal.Text.ParserCombinators.ReadPrec.ReadPrec [a] -> GHC.Internal.Text.ParserCombinators.ReadPrec.ReadPrec (f a)
    liftReadListPrec :: forall a. GHC.Internal.Text.ParserCombinators.ReadPrec.ReadPrec a -> GHC.Internal.Text.ParserCombinators.ReadPrec.ReadPrec [a] -> GHC.Internal.Text.ParserCombinators.ReadPrec.ReadPrec [f a]
    {-# MINIMAL liftReadsPrec | liftReadPrec #-}
  type Read2 :: (* -> * -> *) -> Constraint
  class (forall a. GHC.Internal.Read.Read a => Read1 (f a)) => Read2 f where
    liftReadsPrec2 :: forall a b. (GHC.Types.Int -> GHC.Internal.Text.ParserCombinators.ReadP.ReadS a) -> GHC.Internal.Text.ParserCombinators.ReadP.ReadS [a] -> (GHC.Types.Int -> GHC.Internal.Text.ParserCombinators.ReadP.ReadS b) -> GHC.Internal.Text.ParserCombinators.ReadP.ReadS [b] -> GHC.Types.Int -> GHC.Internal.Text.ParserCombinators.ReadP.ReadS (f a b)
    liftReadList2 :: forall a b. (GHC.Types.Int -> GHC.Internal.Text.ParserCombinators.ReadP.ReadS a) -> GHC.Internal.Text.ParserCombinators.ReadP.ReadS [a] -> (GHC.Types.Int -> GHC.Internal.Text.ParserCombinators.ReadP.ReadS b) -> GHC.Internal.Text.ParserCombinators.ReadP.ReadS [b] -> GHC.Internal.Text.ParserCombinators.ReadP.ReadS [f a b]
    liftReadPrec2 :: forall a b. GHC.Internal.Text.ParserCombinators.ReadPrec.ReadPrec a -> GHC.Internal.Text.ParserCombinators.ReadPrec.ReadPrec [a] -> GHC.Internal.Text.ParserCombinators.ReadPrec.ReadPrec b -> GHC.Internal.Text.ParserCombinators.ReadPrec.ReadPrec [b] -> GHC.Internal.Text.ParserCombinators.ReadPrec.ReadPrec (f a b)
    liftReadListPrec2 :: forall a b. GHC.Internal.Text.ParserCombinators.ReadPrec.ReadPrec a -> GHC.Internal.Text.ParserCombinators.ReadPrec.ReadPrec [a] -> GHC.Internal.Text.ParserCombinators.ReadPrec.ReadPrec b -> GHC.Internal.Text.ParserCombinators.ReadPrec.ReadPrec [b] -> GHC.Internal.Text.ParserCombinators.ReadPrec.ReadPrec [f a b]
    {-# MINIMAL liftReadsPrec2 | liftReadPrec2 #-}
  type Show1 :: (* -> *) -> Constraint
  class (forall a. GHC.Internal.Show.Show a => GHC.Internal.Show.Show (f a)) => Show1 f where
    liftShowsPrec :: forall a. (GHC.Types.Int -> a -> GHC.Internal.Show.ShowS) -> ([a] -> GHC.Internal.Show.ShowS) -> GHC.Types.Int -> f a -> GHC.Internal.Show.ShowS
    default liftShowsPrec :: forall (f' :: * -> * -> *) b a. (f ~ f' b, Show2 f', GHC.Internal.Show.Show b) => (GHC.Types.Int -> a -> GHC.Internal.Show.ShowS) -> ([a] -> GHC.Internal.Show.ShowS) -> GHC.Types.Int -> f a -> GHC.Internal.Show.ShowS
    liftShowList :: forall a. (GHC.Types.Int -> a -> GHC.Internal.Show.ShowS) -> ([a] -> GHC.Internal.Show.ShowS) -> [f a] -> GHC.Internal.Show.ShowS
    {-# MINIMAL #-}
  type Show2 :: (* -> * -> *) -> Constraint
  class (forall a. GHC.Internal.Show.Show a => Show1 (f a)) => Show2 f where
    liftShowsPrec2 :: forall a b. (GHC.Types.Int -> a -> GHC.Internal.Show.ShowS) -> ([a] -> GHC.Internal.Show.ShowS) -> (GHC.Types.Int -> b -> GHC.Internal.Show.ShowS) -> ([b] -> GHC.Internal.Show.ShowS) -> GHC.Types.Int -> f a b -> GHC.Internal.Show.ShowS
    liftShowList2 :: forall a b. (GHC.Types.Int -> a -> GHC.Internal.Show.ShowS) -> ([a] -> GHC.Internal.Show.ShowS) -> (GHC.Types.Int -> b -> GHC.Internal.Show.ShowS) -> ([b] -> GHC.Internal.Show.ShowS) -> [f a b] -> GHC.Internal.Show.ShowS
    {-# MINIMAL liftShowsPrec2 #-}
  compare1 :: forall (f :: * -> *) a. (Ord1 f, GHC.Classes.Ord a) => f a -> f a -> GHC.Types.Ordering
  compare2 :: forall (f :: * -> * -> *) a b. (Ord2 f, GHC.Classes.Ord a, GHC.Classes.Ord b) => f a b -> f a b -> GHC.Types.Ordering
  eq1 :: forall (f :: * -> *) a. (Eq1 f, GHC.Classes.Eq a) => f a -> f a -> GHC.Types.Bool
  eq2 :: forall (f :: * -> * -> *) a b. (Eq2 f, GHC.Classes.Eq a, GHC.Classes.Eq b) => f a b -> f a b -> GHC.Types.Bool
  liftReadList2Default :: forall (f :: * -> * -> *) a b. Read2 f => (GHC.Types.Int -> GHC.Internal.Text.ParserCombinators.ReadP.ReadS a) -> GHC.Internal.Text.ParserCombinators.ReadP.ReadS [a] -> (GHC.Types.Int -> GHC.Internal.Text.ParserCombinators.ReadP.ReadS b) -> GHC.Internal.Text.ParserCombinators.ReadP.ReadS [b] -> GHC.Internal.Text.ParserCombinators.ReadP.ReadS [f a b]
  liftReadListDefault :: forall (f :: * -> *) a. Read1 f => (GHC.Types.Int -> GHC.Internal.Text.ParserCombinators.ReadP.ReadS a) -> GHC.Internal.Text.ParserCombinators.ReadP.ReadS [a] -> GHC.Internal.Text.ParserCombinators.ReadP.ReadS [f a]
  liftReadListPrec2Default :: forall (f :: * -> * -> *) a b. Read2 f => GHC.Internal.Text.ParserCombinators.ReadPrec.ReadPrec a -> GHC.Internal.Text.ParserCombinators.ReadPrec.ReadPrec [a] -> GHC.Internal.Text.ParserCombinators.ReadPrec.ReadPrec b -> GHC.Internal.Text.ParserCombinators.ReadPrec.ReadPrec [b] -> GHC.Internal.Text.ParserCombinators.ReadPrec.ReadPrec [f a b]
  liftReadListPrecDefault :: forall (f :: * -> *) a. Read1 f => GHC.Internal.Text.ParserCombinators.ReadPrec.ReadPrec a -> GHC.Internal.Text.ParserCombinators.ReadPrec.ReadPrec [a] -> GHC.Internal.Text.ParserCombinators.ReadPrec.ReadPrec [f a]
  readBinaryWith :: forall a b t. GHC.Internal.Text.ParserCombinators.ReadPrec.ReadPrec a -> GHC.Internal.Text.ParserCombinators.ReadPrec.ReadPrec b -> GHC.Internal.Base.String -> (a -> b -> t) -> GHC.Internal.Text.ParserCombinators.ReadPrec.ReadPrec t
  readData :: forall a. GHC.Internal.Text.ParserCombinators.ReadPrec.ReadPrec a -> GHC.Internal.Text.ParserCombinators.ReadPrec.ReadPrec a
  readPrec1 :: forall (f :: * -> *) a. (Read1 f, GHC.Internal.Read.Read a) => GHC.Internal.Text.ParserCombinators.ReadPrec.ReadPrec (f a)
  readPrec2 :: forall (f :: * -> * -> *) a b. (Read2 f, GHC.Internal.Read.Read a, GHC.Internal.Read.Read b) => GHC.Internal.Text.ParserCombinators.ReadPrec.ReadPrec (f a b)
  readUnaryWith :: forall a t. GHC.Internal.Text.ParserCombinators.ReadPrec.ReadPrec a -> GHC.Internal.Base.String -> (a -> t) -> GHC.Internal.Text.ParserCombinators.ReadPrec.ReadPrec t
  readsBinary1 :: forall (f :: * -> *) (g :: * -> *) a t. (Read1 f, Read1 g, GHC.Internal.Read.Read a) => GHC.Internal.Base.String -> (f a -> g a -> t) -> GHC.Internal.Base.String -> GHC.Internal.Text.ParserCombinators.ReadP.ReadS t
  readsBinaryWith :: forall a b t. (GHC.Types.Int -> GHC.Internal.Text.ParserCombinators.ReadP.ReadS a) -> (GHC.Types.Int -> GHC.Internal.Text.ParserCombinators.ReadP.ReadS b) -> GHC.Internal.Base.String -> (a -> b -> t) -> GHC.Internal.Base.String -> GHC.Internal.Text.ParserCombinators.ReadP.ReadS t
  readsData :: forall a. (GHC.Internal.Base.String -> GHC.Internal.Text.ParserCombinators.ReadP.ReadS a) -> GHC.Types.Int -> GHC.Internal.Text.ParserCombinators.ReadP.ReadS a
  readsPrec1 :: forall (f :: * -> *) a. (Read1 f, GHC.Internal.Read.Read a) => GHC.Types.Int -> GHC.Internal.Text.ParserCombinators.ReadP.ReadS (f a)
  readsPrec2 :: forall (f :: * -> * -> *) a b. (Read2 f, GHC.Internal.Read.Read a, GHC.Internal.Read.Read b) => GHC.Types.Int -> GHC.Internal.Text.ParserCombinators.ReadP.ReadS (f a b)
  readsUnary :: forall a t. GHC.Internal.Read.Read a => GHC.Internal.Base.String -> (a -> t) -> GHC.Internal.Base.String -> GHC.Internal.Text.ParserCombinators.ReadP.ReadS t
  readsUnary1 :: forall (f :: * -> *) a t. (Read1 f, GHC.Internal.Read.Read a) => GHC.Internal.Base.String -> (f a -> t) -> GHC.Internal.Base.String -> GHC.Internal.Text.ParserCombinators.ReadP.ReadS t
  readsUnaryWith :: forall a t. (GHC.Types.Int -> GHC.Internal.Text.ParserCombinators.ReadP.ReadS a) -> GHC.Internal.Base.String -> (a -> t) -> GHC.Internal.Base.String -> GHC.Internal.Text.ParserCombinators.ReadP.ReadS t
  showsBinary1 :: forall (f :: * -> *) (g :: * -> *) a. (Show1 f, Show1 g, GHC.Internal.Show.Show a) => GHC.Internal.Base.String -> GHC.Types.Int -> f a -> g a -> GHC.Internal.Show.ShowS
  showsBinaryWith :: forall a b. (GHC.Types.Int -> a -> GHC.Internal.Show.ShowS) -> (GHC.Types.Int -> b -> GHC.Internal.Show.ShowS) -> GHC.Internal.Base.String -> GHC.Types.Int -> a -> b -> GHC.Internal.Show.ShowS
  showsPrec1 :: forall (f :: * -> *) a. (Show1 f, GHC.Internal.Show.Show a) => GHC.Types.Int -> f a -> GHC.Internal.Show.ShowS
  showsPrec2 :: forall (f :: * -> * -> *) a b. (Show2 f, GHC.Internal.Show.Show a, GHC.Internal.Show.Show b) => GHC.Types.Int -> f a b -> GHC.Internal.Show.ShowS
  showsUnary :: forall a. GHC.Internal.Show.Show a => GHC.Internal.Base.String -> GHC.Types.Int -> a -> GHC.Internal.Show.ShowS
  showsUnary1 :: forall (f :: * -> *) a. (Show1 f, GHC.Internal.Show.Show a) => GHC.Internal.Base.String -> GHC.Types.Int -> f a -> GHC.Internal.Show.ShowS
  showsUnaryWith :: forall a. (GHC.Types.Int -> a -> GHC.Internal.Show.ShowS) -> GHC.Internal.Base.String -> GHC.Types.Int -> a -> GHC.Internal.Show.ShowS

module Data.Functor.Compose where
  -- Safety: Trustworthy
  type role Compose representational nominal nominal
  type Compose :: forall {k} {k1}. (k -> *) -> (k1 -> k) -> k1 -> *
  newtype Compose f g a = Compose {getCompose :: f (g a)}

module Data.Functor.Const where
  -- Safety: Safe
  type role Const representational phantom
  type Const :: forall {k}. * -> k -> *
  newtype Const a b = Const {getConst :: a}

module Data.Functor.Contravariant where
  -- Safety: Trustworthy
  ($<) :: forall (f :: * -> *) b a. Contravariant f => f b -> b -> f a
  (>$$<) :: forall (f :: * -> *) b a. Contravariant f => f b -> (a -> b) -> f a
  (>$<) :: forall (f :: * -> *) a b. Contravariant f => (a -> b) -> f b -> f a
  type Comparison :: * -> *
  newtype Comparison a = Comparison {getComparison :: a -> a -> GHC.Types.Ordering}
  type Contravariant :: (* -> *) -> Constraint
  class Contravariant f where
    contramap :: forall a' a. (a' -> a) -> f a -> f a'
    (>$) :: forall b a. b -> f b -> f a
    {-# MINIMAL contramap #-}
  type Equivalence :: * -> *
  newtype Equivalence a = Equivalence {getEquivalence :: a -> a -> GHC.Types.Bool}
  type Op :: * -> * -> *
  newtype Op a b = Op {getOp :: b -> a}
  type Predicate :: * -> *
  newtype Predicate a = Predicate {getPredicate :: a -> GHC.Types.Bool}
  comparisonEquivalence :: forall a. Comparison a -> Equivalence a
  defaultComparison :: forall a. GHC.Classes.Ord a => Comparison a
  defaultEquivalence :: forall a. GHC.Classes.Eq a => Equivalence a
  phantom :: forall (f :: * -> *) a b. (GHC.Internal.Base.Functor f, Contravariant f) => f a -> f b

module Data.Functor.Identity where
  -- Safety: Safe
  type Identity :: * -> *
  newtype Identity a = Identity {runIdentity :: a}

module Data.Functor.Product where
  -- Safety: Safe
  type role Product representational representational nominal
  type Product :: forall {k}. (k -> *) -> (k -> *) -> k -> *
  data Product f g a = Pair (f a) (g a)

module Data.Functor.Sum where
  -- Safety: Safe
  type role Sum representational representational nominal
  type Sum :: forall {k}. (k -> *) -> (k -> *) -> k -> *
  data Sum f g a = InL (f a) | InR (g a)

module Data.IORef where
  -- Safety: Safe
  type IORef :: * -> *
  newtype IORef a = ...
  atomicModifyIORef :: forall a b. IORef a -> (a -> (a, b)) -> GHC.Types.IO b
  atomicModifyIORef' :: forall a b. IORef a -> (a -> (a, b)) -> GHC.Types.IO b
  atomicWriteIORef :: forall a. IORef a -> a -> GHC.Types.IO ()
  mkWeakIORef :: forall a. IORef a -> GHC.Types.IO () -> GHC.Types.IO (GHC.Internal.Weak.Weak (IORef a))
  modifyIORef :: forall a. IORef a -> (a -> a) -> GHC.Types.IO ()
  modifyIORef' :: forall a. IORef a -> (a -> a) -> GHC.Types.IO ()
  newIORef :: forall a. a -> GHC.Types.IO (IORef a)
  readIORef :: forall a. IORef a -> GHC.Types.IO a
  writeIORef :: forall a. IORef a -> a -> GHC.Types.IO ()

module Data.Int where
  -- Safety: Safe
  type Int :: *
  data Int = ...
  type Int16 :: *
  data Int16 = ...
  type Int32 :: *
  data Int32 = ...
  type Int64 :: *
  data Int64 = ...
  type Int8 :: *
  data Int8 = ...

module Data.Ix where
  -- Safety: Safe
  type Ix :: * -> Constraint
  class GHC.Classes.Ord a => Ix a where
    range :: (a, a) -> [a]
    index :: (a, a) -> a -> GHC.Types.Int
    ...
    inRange :: (a, a) -> a -> GHC.Types.Bool
    rangeSize :: (a, a) -> GHC.Types.Int
    ...
    {-# MINIMAL range, (index | GHC.Internal.Ix.unsafeIndex), inRange #-}

module Data.Kind where
  -- Safety: Safe
  type Constraint :: *
  type Constraint = GHC.Prim.CONSTRAINT GHC.Types.LiftedRep
  type role FUN nominal representational representational
  type FUN :: forall (n :: GHC.Types.Multiplicity) -> forall {q :: GHC.Types.RuntimeRep} {r :: GHC.Types.RuntimeRep}. TYPE q -> TYPE r -> *
  data FUN n a b
  type Type :: *
  type Type = TYPE GHC.Types.LiftedRep

module Data.List where
  -- Safety: Safe
  (!!) :: forall a. GHC.Internal.Stack.Types.HasCallStack => [a] -> GHC.Types.Int -> a
  (!?) :: forall a. [a] -> GHC.Types.Int -> GHC.Internal.Maybe.Maybe a
  (++) :: forall a. [a] -> [a] -> [a]
  type List :: * -> *
  data List a = ...
  (\\) :: forall a. GHC.Classes.Eq a => [a] -> [a] -> [a]
  all :: forall (t :: * -> *) a. GHC.Internal.Data.Foldable.Foldable t => (a -> GHC.Types.Bool) -> t a -> GHC.Types.Bool
  and :: forall (t :: * -> *). GHC.Internal.Data.Foldable.Foldable t => t GHC.Types.Bool -> GHC.Types.Bool
  any :: forall (t :: * -> *) a. GHC.Internal.Data.Foldable.Foldable t => (a -> GHC.Types.Bool) -> t a -> GHC.Types.Bool
  break :: forall a. (a -> GHC.Types.Bool) -> [a] -> ([a], [a])
  concat :: forall (t :: * -> *) a. GHC.Internal.Data.Foldable.Foldable t => t [a] -> [a]
  concatMap :: forall (t :: * -> *) a b. GHC.Internal.Data.Foldable.Foldable t => (a -> [b]) -> t a -> [b]
  cycle :: forall a. GHC.Internal.Stack.Types.HasCallStack => [a] -> [a]
  delete :: forall a. GHC.Classes.Eq a => a -> [a] -> [a]
  deleteBy :: forall a. (a -> a -> GHC.Types.Bool) -> a -> [a] -> [a]
  deleteFirstsBy :: forall a. (a -> a -> GHC.Types.Bool) -> [a] -> [a] -> [a]
  drop :: forall a. GHC.Types.Int -> [a] -> [a]
  dropWhile :: forall a. (a -> GHC.Types.Bool) -> [a] -> [a]
  dropWhileEnd :: forall a. (a -> GHC.Types.Bool) -> [a] -> [a]
  elem :: forall (t :: * -> *) a. (GHC.Internal.Data.Foldable.Foldable t, GHC.Classes.Eq a) => a -> t a -> GHC.Types.Bool
  elemIndex :: forall a. GHC.Classes.Eq a => a -> [a] -> GHC.Internal.Maybe.Maybe GHC.Types.Int
  elemIndices :: forall a. GHC.Classes.Eq a => a -> [a] -> [GHC.Types.Int]
  filter :: forall a. (a -> GHC.Types.Bool) -> [a] -> [a]
  find :: forall (t :: * -> *) a. GHC.Internal.Data.Foldable.Foldable t => (a -> GHC.Types.Bool) -> t a -> GHC.Internal.Maybe.Maybe a
  findIndex :: forall a. (a -> GHC.Types.Bool) -> [a] -> GHC.Internal.Maybe.Maybe GHC.Types.Int
  findIndices :: forall a. (a -> GHC.Types.Bool) -> [a] -> [GHC.Types.Int]
  foldl :: forall (t :: * -> *) b a. GHC.Internal.Data.Foldable.Foldable t => (b -> a -> b) -> b -> t a -> b
  foldl' :: forall (t :: * -> *) b a. GHC.Internal.Data.Foldable.Foldable t => (b -> a -> b) -> b -> t a -> b
  foldl1 :: forall (t :: * -> *) a. GHC.Internal.Data.Foldable.Foldable t => (a -> a -> a) -> t a -> a
  foldl1' :: forall a. GHC.Internal.Stack.Types.HasCallStack => (a -> a -> a) -> [a] -> a
  foldr :: forall (t :: * -> *) a b. GHC.Internal.Data.Foldable.Foldable t => (a -> b -> b) -> b -> t a -> b
  foldr1 :: forall (t :: * -> *) a. GHC.Internal.Data.Foldable.Foldable t => (a -> a -> a) -> t a -> a
  genericDrop :: forall i a. GHC.Internal.Real.Integral i => i -> [a] -> [a]
  genericIndex :: forall i a. GHC.Internal.Real.Integral i => [a] -> i -> a
  genericLength :: forall i a. GHC.Internal.Num.Num i => [a] -> i
  genericReplicate :: forall i a. GHC.Internal.Real.Integral i => i -> a -> [a]
  genericSplitAt :: forall i a. GHC.Internal.Real.Integral i => i -> [a] -> ([a], [a])
  genericTake :: forall i a. GHC.Internal.Real.Integral i => i -> [a] -> [a]
  group :: forall a. GHC.Classes.Eq a => [a] -> [[a]]
  groupBy :: forall a. (a -> a -> GHC.Types.Bool) -> [a] -> [[a]]
  head :: forall a. GHC.Internal.Stack.Types.HasCallStack => [a] -> a
  init :: forall a. GHC.Internal.Stack.Types.HasCallStack => [a] -> [a]
  inits :: forall a. [a] -> [[a]]
  insert :: forall a. GHC.Classes.Ord a => a -> [a] -> [a]
  insertBy :: forall a. (a -> a -> GHC.Types.Ordering) -> a -> [a] -> [a]
  intercalate :: forall a. [a] -> [[a]] -> [a]
  intersect :: forall a. GHC.Classes.Eq a => [a] -> [a] -> [a]
  intersectBy :: forall a. (a -> a -> GHC.Types.Bool) -> [a] -> [a] -> [a]
  intersperse :: forall a. a -> [a] -> [a]
  isInfixOf :: forall a. GHC.Classes.Eq a => [a] -> [a] -> GHC.Types.Bool
  isPrefixOf :: forall a. GHC.Classes.Eq a => [a] -> [a] -> GHC.Types.Bool
  isSubsequenceOf :: forall a. GHC.Classes.Eq a => [a] -> [a] -> GHC.Types.Bool
  isSuffixOf :: forall a. GHC.Classes.Eq a => [a] -> [a] -> GHC.Types.Bool
  iterate :: forall a. (a -> a) -> a -> [a]
  iterate' :: forall a. (a -> a) -> a -> [a]
  last :: forall a. GHC.Internal.Stack.Types.HasCallStack => [a] -> a
  length :: forall (t :: * -> *) a. GHC.Internal.Data.Foldable.Foldable t => t a -> GHC.Types.Int
  lines :: GHC.Internal.Base.String -> [GHC.Internal.Base.String]
  lookup :: forall a b. GHC.Classes.Eq a => a -> [(a, b)] -> GHC.Internal.Maybe.Maybe b
  map :: forall a b. (a -> b) -> [a] -> [b]
  mapAccumL :: forall (t :: * -> *) s a b. GHC.Internal.Data.Traversable.Traversable t => (s -> a -> (s, b)) -> s -> t a -> (s, t b)
  mapAccumR :: forall (t :: * -> *) s a b. GHC.Internal.Data.Traversable.Traversable t => (s -> a -> (s, b)) -> s -> t a -> (s, t b)
  maximum :: forall (t :: * -> *) a. (GHC.Internal.Data.Foldable.Foldable t, GHC.Classes.Ord a) => t a -> a
  maximumBy :: forall (t :: * -> *) a. GHC.Internal.Data.Foldable.Foldable t => (a -> a -> GHC.Types.Ordering) -> t a -> a
  minimum :: forall (t :: * -> *) a. (GHC.Internal.Data.Foldable.Foldable t, GHC.Classes.Ord a) => t a -> a
  minimumBy :: forall (t :: * -> *) a. GHC.Internal.Data.Foldable.Foldable t => (a -> a -> GHC.Types.Ordering) -> t a -> a
  notElem :: forall (t :: * -> *) a. (GHC.Internal.Data.Foldable.Foldable t, GHC.Classes.Eq a) => a -> t a -> GHC.Types.Bool
  nub :: forall a. GHC.Classes.Eq a => [a] -> [a]
  nubBy :: forall a. (a -> a -> GHC.Types.Bool) -> [a] -> [a]
  null :: forall (t :: * -> *) a. GHC.Internal.Data.Foldable.Foldable t => t a -> GHC.Types.Bool
  or :: forall (t :: * -> *). GHC.Internal.Data.Foldable.Foldable t => t GHC.Types.Bool -> GHC.Types.Bool
  partition :: forall a. (a -> GHC.Types.Bool) -> [a] -> ([a], [a])
  permutations :: forall a. [a] -> [[a]]
  product :: forall (t :: * -> *) a. (GHC.Internal.Data.Foldable.Foldable t, GHC.Internal.Num.Num a) => t a -> a
  repeat :: forall a. a -> [a]
  replicate :: forall a. GHC.Types.Int -> a -> [a]
  reverse :: forall a. [a] -> [a]
  scanl :: forall b a. (b -> a -> b) -> b -> [a] -> [b]
  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]
  singleton :: forall a. a -> [a]
  sort :: forall a. GHC.Classes.Ord a => [a] -> [a]
  sortBy :: forall a. (a -> a -> GHC.Types.Ordering) -> [a] -> [a]
  sortOn :: forall b a. GHC.Classes.Ord b => (a -> b) -> [a] -> [a]
  span :: forall a. (a -> GHC.Types.Bool) -> [a] -> ([a], [a])
  splitAt :: forall a. GHC.Types.Int -> [a] -> ([a], [a])
  stripPrefix :: forall a. GHC.Classes.Eq a => [a] -> [a] -> GHC.Internal.Maybe.Maybe [a]
  subsequences :: forall a. [a] -> [[a]]
  sum :: forall (t :: * -> *) a. (GHC.Internal.Data.Foldable.Foldable t, GHC.Internal.Num.Num a) => t a -> a
  tail :: forall a. GHC.Internal.Stack.Types.HasCallStack => [a] -> [a]
  tails :: forall a. [a] -> [[a]]
  take :: forall a. GHC.Types.Int -> [a] -> [a]
  takeWhile :: forall a. (a -> GHC.Types.Bool) -> [a] -> [a]
  transpose :: forall a. [[a]] -> [[a]]
  uncons :: forall a. [a] -> GHC.Internal.Maybe.Maybe (a, [a])
  unfoldr :: forall b a. (b -> GHC.Internal.Maybe.Maybe (a, b)) -> b -> [a]
  union :: forall a. GHC.Classes.Eq a => [a] -> [a] -> [a]
  unionBy :: forall a. (a -> a -> GHC.Types.Bool) -> [a] -> [a] -> [a]
  unlines :: [GHC.Internal.Base.String] -> GHC.Internal.Base.String
  unsnoc :: forall a. [a] -> GHC.Internal.Maybe.Maybe ([a], a)
  unwords :: [GHC.Internal.Base.String] -> GHC.Internal.Base.String
  unzip :: forall a b. [(a, b)] -> ([a], [b])
  unzip3 :: forall a b c. [(a, b, c)] -> ([a], [b], [c])
  unzip4 :: forall a b c d. [(a, b, c, d)] -> ([a], [b], [c], [d])
  unzip5 :: forall a b c d e. [(a, b, c, d, e)] -> ([a], [b], [c], [d], [e])
  unzip6 :: forall a b c d e f. [(a, b, c, d, e, f)] -> ([a], [b], [c], [d], [e], [f])
  unzip7 :: forall a b c d e f g. [(a, b, c, d, e, f, g)] -> ([a], [b], [c], [d], [e], [f], [g])
  words :: GHC.Internal.Base.String -> [GHC.Internal.Base.String]
  zip :: forall a b. [a] -> [b] -> [(a, b)]
  zip3 :: forall a b c. [a] -> [b] -> [c] -> [(a, b, c)]
  zip4 :: forall a b c d. [a] -> [b] -> [c] -> [d] -> [(a, b, c, d)]
  zip5 :: forall a b c d e. [a] -> [b] -> [c] -> [d] -> [e] -> [(a, b, c, d, e)]
  zip6 :: forall a b c d e f. [a] -> [b] -> [c] -> [d] -> [e] -> [f] -> [(a, b, c, d, e, f)]
  zip7 :: forall a b c d e f g. [a] -> [b] -> [c] -> [d] -> [e] -> [f] -> [g] -> [(a, b, c, d, e, f, g)]
  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]
  zipWith4 :: forall a b c d e. (a -> b -> c -> d -> e) -> [a] -> [b] -> [c] -> [d] -> [e]
  zipWith5 :: forall a b c d e f. (a -> b -> c -> d -> e -> f) -> [a] -> [b] -> [c] -> [d] -> [e] -> [f]
  zipWith6 :: forall a b c d e f g. (a -> b -> c -> d -> e -> f -> g) -> [a] -> [b] -> [c] -> [d] -> [e] -> [f] -> [g]
  zipWith7 :: forall a b c d e f g h. (a -> b -> c -> d -> e -> f -> g -> h) -> [a] -> [b] -> [c] -> [d] -> [e] -> [f] -> [g] -> [h]

module Data.List.NonEmpty where
  -- Safety: Trustworthy
  (!!) :: forall a. GHC.Internal.Stack.Types.HasCallStack => NonEmpty a -> GHC.Types.Int -> a
  (<|) :: forall a. a -> NonEmpty a -> NonEmpty a
  type NonEmpty :: * -> *
  data NonEmpty a = a :| [a]
  append :: forall a. NonEmpty a -> NonEmpty a -> NonEmpty a
  appendList :: forall a. NonEmpty a -> [a] -> NonEmpty a
  break :: forall a. (a -> GHC.Types.Bool) -> NonEmpty a -> ([a], [a])
  cons :: forall a. a -> NonEmpty a -> NonEmpty a
  cycle :: forall a. NonEmpty a -> NonEmpty a
  drop :: forall a. GHC.Types.Int -> NonEmpty a -> [a]
  dropWhile :: forall a. (a -> GHC.Types.Bool) -> NonEmpty a -> [a]
  filter :: forall a. (a -> GHC.Types.Bool) -> NonEmpty a -> [a]
  fromList :: forall a. GHC.Internal.Stack.Types.HasCallStack => [a] -> NonEmpty a
  group :: forall (f :: * -> *) a. (GHC.Internal.Data.Foldable.Foldable f, GHC.Classes.Eq a) => f a -> [NonEmpty a]
  group1 :: forall a. GHC.Classes.Eq a => NonEmpty a -> NonEmpty (NonEmpty a)
  groupAllWith :: forall b a. GHC.Classes.Ord b => (a -> b) -> [a] -> [NonEmpty a]
  groupAllWith1 :: forall b a. GHC.Classes.Ord b => (a -> b) -> NonEmpty a -> NonEmpty (NonEmpty a)
  groupBy :: forall (f :: * -> *) a. GHC.Internal.Data.Foldable.Foldable f => (a -> a -> GHC.Types.Bool) -> f a -> [NonEmpty a]
  groupBy1 :: forall a. (a -> a -> GHC.Types.Bool) -> NonEmpty a -> NonEmpty (NonEmpty a)
  groupWith :: forall (f :: * -> *) b a. (GHC.Internal.Data.Foldable.Foldable f, GHC.Classes.Eq b) => (a -> b) -> f a -> [NonEmpty a]
  groupWith1 :: forall b a. GHC.Classes.Eq b => (a -> b) -> NonEmpty a -> NonEmpty (NonEmpty a)
  head :: forall a. NonEmpty a -> a
  init :: forall a. NonEmpty a -> [a]
  inits :: forall (f :: * -> *) a. GHC.Internal.Data.Foldable.Foldable f => f a -> NonEmpty [a]
  inits1 :: forall a. NonEmpty a -> NonEmpty (NonEmpty a)
  insert :: forall (f :: * -> *) a. (GHC.Internal.Data.Foldable.Foldable f, GHC.Classes.Ord a) => a -> f a -> NonEmpty a
  intersperse :: forall a. a -> NonEmpty a -> NonEmpty a
  isPrefixOf :: forall a. GHC.Classes.Eq a => [a] -> NonEmpty a -> GHC.Types.Bool
  iterate :: forall a. (a -> a) -> a -> NonEmpty a
  last :: forall a. NonEmpty a -> a
  length :: forall a. NonEmpty a -> GHC.Types.Int
  map :: forall a b. (a -> b) -> NonEmpty a -> NonEmpty b
  nonEmpty :: forall a. [a] -> GHC.Internal.Maybe.Maybe (NonEmpty a)
  nub :: forall a. GHC.Classes.Eq a => NonEmpty a -> NonEmpty a
  nubBy :: forall a. (a -> a -> GHC.Types.Bool) -> NonEmpty a -> NonEmpty a
  partition :: forall a. (a -> GHC.Types.Bool) -> NonEmpty a -> ([a], [a])
  permutations :: forall a. [a] -> NonEmpty [a]
  permutations1 :: forall a. NonEmpty a -> NonEmpty (NonEmpty a)
  prependList :: forall a. [a] -> NonEmpty a -> NonEmpty a
  repeat :: forall a. a -> NonEmpty a
  reverse :: forall a. NonEmpty a -> NonEmpty a
  scanl :: forall (f :: * -> *) b a. GHC.Internal.Data.Foldable.Foldable f => (b -> a -> b) -> b -> f a -> NonEmpty b
  scanl1 :: forall a. (a -> a -> a) -> NonEmpty a -> NonEmpty a
  scanr :: forall (f :: * -> *) a b. GHC.Internal.Data.Foldable.Foldable f => (a -> b -> b) -> b -> f a -> NonEmpty b
  scanr1 :: forall a. (a -> a -> a) -> NonEmpty a -> NonEmpty a
  singleton :: forall a. a -> NonEmpty a
  some1 :: forall (f :: * -> *) a. GHC.Internal.Base.Alternative f => f a -> f (NonEmpty a)
  sort :: forall a. GHC.Classes.Ord a => NonEmpty a -> NonEmpty a
  sortBy :: forall a. (a -> a -> GHC.Types.Ordering) -> NonEmpty a -> NonEmpty a
  sortOn :: forall b a. GHC.Classes.Ord b => (a -> b) -> NonEmpty a -> NonEmpty a
  sortWith :: forall o a. GHC.Classes.Ord o => (a -> o) -> NonEmpty a -> NonEmpty a
  span :: forall a. (a -> GHC.Types.Bool) -> NonEmpty a -> ([a], [a])
  splitAt :: forall a. GHC.Types.Int -> NonEmpty a -> ([a], [a])
  tail :: forall a. NonEmpty a -> [a]
  tails :: forall (f :: * -> *) a. GHC.Internal.Data.Foldable.Foldable f => f a -> NonEmpty [a]
  tails1 :: forall a. NonEmpty a -> NonEmpty (NonEmpty a)
  take :: forall a. GHC.Types.Int -> NonEmpty a -> [a]
  takeWhile :: forall a. (a -> GHC.Types.Bool) -> NonEmpty a -> [a]
  toList :: forall a. NonEmpty a -> [a]
  transpose :: forall a. NonEmpty (NonEmpty a) -> NonEmpty (NonEmpty a)
  uncons :: forall a. NonEmpty a -> (a, GHC.Internal.Maybe.Maybe (NonEmpty a))
  unfold :: forall a b. (a -> (b, GHC.Internal.Maybe.Maybe a)) -> a -> NonEmpty b
  unfoldr :: forall a b. (a -> (b, GHC.Internal.Maybe.Maybe a)) -> a -> NonEmpty b
  unzip :: forall (f :: * -> *) a b. GHC.Internal.Base.Functor f => f (a, b) -> (f a, f b)
  xor :: NonEmpty GHC.Types.Bool -> GHC.Types.Bool
  zip :: forall a b. NonEmpty a -> NonEmpty b -> NonEmpty (a, b)
  zipWith :: forall a b c. (a -> b -> c) -> NonEmpty a -> NonEmpty b -> NonEmpty c

module Data.Maybe where
  -- Safety: Safe
  type Maybe :: * -> *
  data Maybe a = Nothing | Just a
  catMaybes :: forall a. [Maybe a] -> [a]
  fromJust :: forall a. GHC.Internal.Stack.Types.HasCallStack => Maybe a -> a
  fromMaybe :: forall a. a -> Maybe a -> a
  isJust :: forall a. Maybe a -> GHC.Types.Bool
  isNothing :: forall a. Maybe a -> GHC.Types.Bool
  listToMaybe :: forall a. [a] -> Maybe a
  mapMaybe :: forall a b. (a -> Maybe b) -> [a] -> [b]
  maybe :: forall b a. b -> (a -> b) -> Maybe a -> b
  maybeToList :: forall a. Maybe a -> [a]

module Data.Monoid where
  -- Safety: Safe
  (<>) :: forall a. GHC.Internal.Base.Semigroup a => a -> a -> a
  type All :: *
  newtype All = All {getAll :: GHC.Types.Bool}
  type role Alt representational nominal
  type Alt :: forall {k}. (k -> *) -> k -> *
  newtype Alt f a = Alt {getAlt :: f a}
  type Any :: *
  newtype Any = Any {getAny :: GHC.Types.Bool}
  type role Ap representational nominal
  type Ap :: forall {k}. (k -> *) -> k -> *
  newtype Ap f a = Ap {getAp :: f a}
  type Dual :: * -> *
  newtype Dual a = Dual {getDual :: a}
  type Endo :: * -> *
  newtype Endo a = Endo {appEndo :: a -> a}
  type First :: * -> *
  newtype First a = First {getFirst :: GHC.Internal.Maybe.Maybe a}
  type Last :: * -> *
  newtype Last a = Last {getLast :: GHC.Internal.Maybe.Maybe a}
  type Monoid :: * -> Constraint
  class GHC.Internal.Base.Semigroup a => Monoid a where
    mempty :: a
    mappend :: a -> a -> a
    mconcat :: [a] -> a
    {-# MINIMAL mempty | mconcat #-}
  type Product :: * -> *
  newtype Product a = Product {getProduct :: a}
  type Sum :: * -> *
  newtype Sum a = Sum {getSum :: a}

module Data.Ord where
  -- Safety: Safe
  type Down :: * -> *
  newtype Down a = Down {getDown :: a}
  type Ord :: * -> Constraint
  class GHC.Classes.Eq a => Ord a where
    compare :: a -> a -> Ordering
    (<) :: a -> a -> GHC.Types.Bool
    (<=) :: a -> a -> GHC.Types.Bool
    (>) :: a -> a -> GHC.Types.Bool
    (>=) :: a -> a -> GHC.Types.Bool
    max :: a -> a -> a
    min :: a -> a -> a
    {-# MINIMAL compare | (<=) #-}
  type Ordering :: *
  data Ordering = LT | EQ | GT
  clamp :: forall a. Ord a => (a, a) -> a -> a
  comparing :: forall a b. Ord a => (b -> a) -> b -> b -> Ordering

module Data.Proxy where
  -- Safety: Safe
  type role KProxy phantom
  type KProxy :: * -> *
  data KProxy t = KProxy
  type role Proxy phantom
  type Proxy :: forall {k}. k -> *
  data Proxy t = Proxy
  asProxyTypeOf :: forall a (proxy :: * -> *). a -> proxy a -> a

module Data.Ratio where
  -- Safety: Safe
  (%) :: forall a. GHC.Internal.Real.Integral a => a -> a -> Ratio a
  type Ratio :: * -> *
  data Ratio a = ...
  type Rational :: *
  type Rational = Ratio GHC.Num.Integer.Integer
  approxRational :: forall a. GHC.Internal.Real.RealFrac a => a -> a -> Rational
  denominator :: forall a. Ratio a -> a
  numerator :: forall a. Ratio a -> a

module Data.STRef where
  -- Safety: Safe
  type role STRef nominal representational
  type STRef :: * -> * -> *
  data STRef s a = ...
  modifySTRef :: forall s a. STRef s a -> (a -> a) -> GHC.Internal.ST.ST s ()
  modifySTRef' :: forall s a. STRef s a -> (a -> a) -> GHC.Internal.ST.ST s ()
  newSTRef :: forall a s. a -> GHC.Internal.ST.ST s (STRef s a)
  readSTRef :: forall s a. STRef s a -> GHC.Internal.ST.ST s a
  writeSTRef :: forall s a. STRef s a -> a -> GHC.Internal.ST.ST s ()

module Data.STRef.Lazy where
  -- Safety: Safe
  type role STRef nominal representational
  type STRef :: * -> * -> *
  data STRef s a = ...
  modifySTRef :: forall s a. STRef s a -> (a -> a) -> GHC.Internal.Control.Monad.ST.Lazy.Imp.ST s ()
  newSTRef :: forall a s. a -> GHC.Internal.Control.Monad.ST.Lazy.Imp.ST s (STRef s a)
  readSTRef :: forall s a. STRef s a -> GHC.Internal.Control.Monad.ST.Lazy.Imp.ST s a
  writeSTRef :: forall s a. STRef s a -> a -> GHC.Internal.Control.Monad.ST.Lazy.Imp.ST s ()

module Data.STRef.Strict where
  -- Safety: Safe
  type role STRef nominal representational
  type STRef :: * -> * -> *
  data STRef s a = ...
  modifySTRef :: forall s a. STRef s a -> (a -> a) -> GHC.Internal.ST.ST s ()
  modifySTRef' :: forall s a. STRef s a -> (a -> a) -> GHC.Internal.ST.ST s ()
  newSTRef :: forall a s. a -> GHC.Internal.ST.ST s (STRef s a)
  readSTRef :: forall s a. STRef s a -> GHC.Internal.ST.ST s a
  writeSTRef :: forall s a. STRef s a -> a -> GHC.Internal.ST.ST s ()

module Data.Semigroup where
  -- Safety: Trustworthy
  type All :: *
  newtype All = All {getAll :: GHC.Types.Bool}
  type Any :: *
  newtype Any = Any {getAny :: GHC.Types.Bool}
  type Arg :: * -> * -> *
  data Arg a b = Arg a b
  type ArgMax :: * -> * -> *
  type ArgMax a b = Max (Arg a b)
  type ArgMin :: * -> * -> *
  type ArgMin a b = Min (Arg a b)
  type Dual :: * -> *
  newtype Dual a = Dual {getDual :: a}
  type Endo :: * -> *
  newtype Endo a = Endo {appEndo :: a -> a}
  type First :: * -> *
  newtype First a = First {getFirst :: a}
  type Last :: * -> *
  newtype Last a = Last {getLast :: a}
  type Max :: * -> *
  newtype Max a = Max {getMax :: a}
  type Min :: * -> *
  newtype Min a = Min {getMin :: a}
  type Product :: * -> *
  newtype Product a = Product {getProduct :: a}
  type Semigroup :: * -> Constraint
  class Semigroup a where
    (<>) :: a -> a -> a
    sconcat :: GHC.Internal.Base.NonEmpty a -> a
    stimes :: forall b. GHC.Internal.Real.Integral b => b -> a -> a
    {-# MINIMAL (<>) | sconcat #-}
  type Sum :: * -> *
  newtype Sum a = Sum {getSum :: a}
  type WrappedMonoid :: * -> *
  newtype WrappedMonoid m = WrapMonoid {unwrapMonoid :: m}
  cycle1 :: forall m. Semigroup m => m -> m
  diff :: forall m. Semigroup m => m -> Endo m
  mtimesDefault :: forall b a. (GHC.Internal.Real.Integral b, GHC.Internal.Base.Monoid a) => b -> a -> a
  stimesIdempotent :: forall b a. GHC.Internal.Real.Integral b => b -> a -> a
  stimesIdempotentMonoid :: forall b a. (GHC.Internal.Real.Integral b, GHC.Internal.Base.Monoid a) => b -> a -> a
  stimesMonoid :: forall b a. (GHC.Internal.Real.Integral b, GHC.Internal.Base.Monoid a) => b -> a -> a

module Data.String where
  -- Safety: Safe
  type IsString :: * -> Constraint
  class IsString a where
    fromString :: String -> a
    {-# MINIMAL fromString #-}
  type String :: *
  type String = [GHC.Types.Char]
  lines :: String -> [String]
  unlines :: [String] -> String
  unwords :: [String] -> String
  words :: String -> [String]

module Data.Traversable where
  -- Safety: Safe
  type Traversable :: (* -> *) -> Constraint
  class (GHC.Internal.Base.Functor t, GHC.Internal.Data.Foldable.Foldable t) => Traversable t where
    traverse :: forall (f :: * -> *) a b. GHC.Internal.Base.Applicative f => (a -> f b) -> t a -> f (t b)
    sequenceA :: forall (f :: * -> *) a. GHC.Internal.Base.Applicative f => t (f a) -> f (t a)
    mapM :: forall (m :: * -> *) a b. GHC.Internal.Base.Monad m => (a -> m b) -> t a -> m (t b)
    sequence :: forall (m :: * -> *) a. GHC.Internal.Base.Monad m => t (m a) -> m (t a)
    {-# MINIMAL traverse | sequenceA #-}
  fmapDefault :: forall (t :: * -> *) a b. Traversable t => (a -> b) -> t a -> t b
  foldMapDefault :: forall (t :: * -> *) m a. (Traversable t, GHC.Internal.Base.Monoid m) => (a -> m) -> t a -> m
  for :: forall (t :: * -> *) (f :: * -> *) a b. (Traversable t, GHC.Internal.Base.Applicative f) => t a -> (a -> f b) -> f (t b)
  forAccumM :: forall (m :: * -> *) (t :: * -> *) s a b. (GHC.Internal.Base.Monad m, Traversable t) => s -> t a -> (s -> a -> m (s, b)) -> m (s, t b)
  forM :: forall (t :: * -> *) (m :: * -> *) a b. (Traversable t, GHC.Internal.Base.Monad m) => t a -> (a -> m b) -> m (t b)
  mapAccumL :: forall (t :: * -> *) s a b. Traversable t => (s -> a -> (s, b)) -> s -> t a -> (s, t b)
  mapAccumM :: forall (m :: * -> *) (t :: * -> *) s a b. (GHC.Internal.Base.Monad m, Traversable t) => (s -> a -> m (s, b)) -> s -> t a -> m (s, t b)
  mapAccumR :: forall (t :: * -> *) s a b. Traversable t => (s -> a -> (s, b)) -> s -> t a -> (s, t b)

module Data.Tuple where
  -- Safety: Safe
  pattern Solo :: forall a. a -> Solo a
  type Solo :: * -> *
  data Solo a = MkSolo a
  curry :: forall a b c. ((a, b) -> c) -> a -> b -> c
  fst :: forall a b. (a, b) -> a
  getSolo :: forall a. Solo a -> a
  snd :: forall a b. (a, b) -> b
  swap :: forall a b. (a, b) -> (b, a)
  uncurry :: forall a b c. (a -> b -> c) -> (a, b) -> c

module Data.Type.Bool where
  -- Safety: Safe
  type (&&) :: GHC.Types.Bool -> GHC.Types.Bool -> GHC.Types.Bool
  type family (&&) a b where
    forall (a :: GHC.Types.Bool). (&&) GHC.Types.False a = GHC.Types.False
    forall (a :: GHC.Types.Bool). (&&) GHC.Types.True a = a
    forall (a :: GHC.Types.Bool). (&&) a GHC.Types.False = GHC.Types.False
    forall (a :: GHC.Types.Bool). (&&) a GHC.Types.True = a
    forall (a :: GHC.Types.Bool). (&&) a a = a
  type If :: forall {k}. GHC.Types.Bool -> k -> k -> k
  type family If cond tru fls where
    forall k (tru :: k) (fls :: k). If GHC.Types.True tru fls = tru
    forall k (tru :: k) (fls :: k). If GHC.Types.False tru fls = fls
  type Not :: GHC.Types.Bool -> GHC.Types.Bool
  type family Not a = res | res -> a where
      Not GHC.Types.False = GHC.Types.True
      Not GHC.Types.True = GHC.Types.False
  type (||) :: GHC.Types.Bool -> GHC.Types.Bool -> GHC.Types.Bool
  type family (||) a b where
    forall (a :: GHC.Types.Bool). (||) GHC.Types.False a = a
    forall (a :: GHC.Types.Bool). (||) GHC.Types.True a = GHC.Types.True
    forall (a :: GHC.Types.Bool). (||) a GHC.Types.False = a
    forall (a :: GHC.Types.Bool). (||) a GHC.Types.True = GHC.Types.True
    forall (a :: GHC.Types.Bool). (||) a a = a

module Data.Type.Coercion where
  -- Safety: None
  type Coercion :: forall {k}. k -> k -> *
  data Coercion a b where
    Coercion :: forall {k} (a :: k) (b :: k). Coercible a b => Coercion a b
  type TestCoercion :: forall {k}. (k -> *) -> Constraint
  class TestCoercion f where
    testCoercion :: forall (a :: k) (b :: k). f a -> f b -> GHC.Internal.Maybe.Maybe (Coercion a b)
    {-# MINIMAL testCoercion #-}
  coerceWith :: forall a b. Coercion a b -> a -> b
  gcoerceWith :: forall {k} (a :: k) (b :: k) r. Coercion a b -> (Coercible a b => r) -> r
  repr :: forall {k} (a :: k) (b :: k). (a GHC.Internal.Data.Type.Equality.:~: b) -> Coercion a b
  sym :: forall {k} (a :: k) (b :: k). Coercion a b -> Coercion b a
  trans :: forall {k} (a :: k) (b :: k) (c :: k). Coercion a b -> Coercion b c -> Coercion a c

module Data.Type.Equality where
  -- Safety: Safe
  type role (:~:) nominal nominal
  type (:~:) :: forall {k}. k -> k -> *
  data (:~:) a b where
    Refl :: forall {k} (a :: k). (:~:) a a
  type role (:~~:) nominal nominal
  type (:~~:) :: forall k1 k2. k1 -> k2 -> *
  data (:~~:) a b where
    HRefl :: forall {k1} (a :: k1). (:~~:) a a
  type (==) :: forall k. k -> k -> GHC.Types.Bool
  type family (==) a b where
    forall k1 k2 (f :: k1 -> k2) (a :: k1) (g :: k1 -> k2) (b :: k1). (==) (f a) (g b) = (f == g) GHC.Internal.Data.Type.Bool.&& (a == b)
    forall k (a :: k). (==) a a = GHC.Types.True
    forall k (_1 :: k) (_2 :: k). (==) _1 _2 = GHC.Types.False
  type TestEquality :: forall {k}. (k -> *) -> Constraint
  class TestEquality f where
    testEquality :: forall (a :: k) (b :: k). f a -> f b -> GHC.Internal.Maybe.Maybe (a :~: b)
    {-# MINIMAL testEquality #-}
  apply :: forall {k1} {k2} (f :: k1 -> k2) (g :: k1 -> k2) (a :: k1) (b :: k1). (f :~: g) -> (a :~: b) -> f a :~: g b
  castWith :: forall a b. (a :~: b) -> a -> b
  gcastWith :: forall {k} (a :: k) (b :: k) r. (a :~: b) -> ((a ~ b) => r) -> r
  inner :: forall {k1} {k2} (f :: k1 -> k2) (a :: k1) (g :: k1 -> k2) (b :: k1). (f a :~: g b) -> a :~: b
  outer :: forall {k1} {k2} (f :: k1 -> k2) (a :: k1) (g :: k1 -> k2) (b :: k1). (f a :~: g b) -> f :~: g
  sym :: forall {k} (a :: k) (b :: k). (a :~: b) -> b :~: a
  trans :: forall {k} (a :: k) (b :: k) (c :: k). (a :~: b) -> (b :~: c) -> a :~: c
  type (~) :: forall k. k -> k -> Constraint
  class (a ~ b) => (~) a b
    {-# MINIMAL #-}
  type (~~) :: forall k0 k1. k0 -> k1 -> Constraint
  class (a ~~ b) => (~~) a b
    {-# MINIMAL #-}

module Data.Type.Ord where
  -- Safety: Safe
  type (<) :: forall {t}. t -> t -> Constraint
  type (<) x y = GHC.Internal.TypeError.Assert (x <? y) (GHC.Internal.Data.Type.Ord.LtErrMsg x y) :: Constraint
  type (<=) :: forall {t}. t -> t -> Constraint
  type (<=) x y = GHC.Internal.TypeError.Assert (x <=? y) (GHC.Internal.Data.Type.Ord.LeErrMsg x y) :: Constraint
  type (<=?) :: forall k. k -> k -> GHC.Types.Bool
  type (<=?) m n = OrdCond (Compare m n) GHC.Types.True GHC.Types.True GHC.Types.False :: GHC.Types.Bool
  type (<?) :: forall k. k -> k -> GHC.Types.Bool
  type (<?) m n = OrdCond (Compare m n) GHC.Types.True GHC.Types.False GHC.Types.False :: GHC.Types.Bool
  type (>) :: forall {t}. t -> t -> Constraint
  type (>) x y = GHC.Internal.TypeError.Assert (x >? y) (GHC.Internal.Data.Type.Ord.GtErrMsg x y) :: Constraint
  type (>=) :: forall {t}. t -> t -> Constraint
  type (>=) x y = GHC.Internal.TypeError.Assert (x >=? y) (GHC.Internal.Data.Type.Ord.GeErrMsg x y) :: Constraint
  type (>=?) :: forall k. k -> k -> GHC.Types.Bool
  type (>=?) m n = OrdCond (Compare m n) GHC.Types.False GHC.Types.True GHC.Types.True :: GHC.Types.Bool
  type (>?) :: forall k. k -> k -> GHC.Types.Bool
  type (>?) m n = OrdCond (Compare m n) GHC.Types.False GHC.Types.False GHC.Types.True :: GHC.Types.Bool
  type Compare :: forall k. k -> k -> GHC.Types.Ordering
  type family Compare a b
  type Max :: forall k. k -> k -> k
  type Max m n = OrdCond (Compare m n) n n m :: k
  type Min :: forall k. k -> k -> k
  type Min m n = OrdCond (Compare m n) m m n :: k
  type OrdCond :: forall k. GHC.Types.Ordering -> k -> k -> k -> k
  type family OrdCond o lt eq gt where
    forall k (lt :: k) (eq :: k) (gt :: k). OrdCond GHC.Types.LT lt eq gt = lt
    forall k (lt :: k) (eq :: k) (gt :: k). OrdCond GHC.Types.EQ lt eq gt = eq
    forall k (lt :: k) (eq :: k) (gt :: k). OrdCond GHC.Types.GT lt eq gt = gt
  type role OrderingI nominal nominal
  type OrderingI :: forall {k}. k -> k -> *
  data OrderingI a b where
    LTI :: forall {k} (a :: k) (b :: k). (Compare a b ~ GHC.Types.LT) => OrderingI a b
    EQI :: forall {k} (a :: k). (Compare a a ~ GHC.Types.EQ) => OrderingI a a
    GTI :: forall {k} (a :: k) (b :: k). (Compare a b ~ GHC.Types.GT) => OrderingI a b

module Data.Typeable where
  -- Safety: Safe
  type role (:~:) nominal nominal
  type (:~:) :: forall {k}. k -> k -> *
  data (:~:) a b where
    Refl :: forall {k} (a :: k). (:~:) a a
  type role (:~~:) nominal nominal
  type (:~~:) :: forall k1 k2. k1 -> k2 -> *
  data (:~~:) a b where
    HRefl :: forall {k1} (a :: k1). (:~~:) a a
  type role Proxy phantom
  type Proxy :: forall {k}. k -> *
  data Proxy t = Proxy
  type TyCon :: *
  data TyCon = ...
  type TypeRep :: *
  type TypeRep = ghc-internal-0.1.0.0:GHC.Internal.Data.Typeable.Internal.SomeTypeRep
  type Typeable :: forall k. k -> Constraint
  class Typeable a where
    ...
    {-# MINIMAL ghc-internal-0.1.0.0:GHC.Internal.Data.Typeable.Internal.typeRep# #-}
  cast :: forall a b. (Typeable a, Typeable b) => a -> GHC.Internal.Maybe.Maybe b
  decT :: forall {k} (a :: k) (b :: k). (Typeable a, Typeable b) => GHC.Internal.Data.Either.Either ((a :~: b) -> GHC.Internal.Base.Void) (a :~: b)
  eqT :: forall {k} (a :: k) (b :: k). (Typeable a, Typeable b) => GHC.Internal.Maybe.Maybe (a :~: b)
  funResultTy :: TypeRep -> TypeRep -> GHC.Internal.Maybe.Maybe TypeRep
  gcast :: forall {k} (a :: k) (b :: k) (c :: k -> *). (Typeable a, Typeable b) => c a -> GHC.Internal.Maybe.Maybe (c b)
  gcast1 :: forall {k1} {k2} (c :: k1 -> *) (t :: k2 -> k1) (t' :: k2 -> k1) (a :: k2). (Typeable t, Typeable t') => c (t a) -> GHC.Internal.Maybe.Maybe (c (t' a))
  gcast2 :: forall {k1} {k2} {k3} (c :: k1 -> *) (t :: k2 -> k3 -> k1) (t' :: k2 -> k3 -> k1) (a :: k2) (b :: k3). (Typeable t, Typeable t') => c (t a b) -> GHC.Internal.Maybe.Maybe (c (t' a b))
  hdecT :: forall {k1} {k2} (a :: k1) (b :: k2). (Typeable a, Typeable b) => GHC.Internal.Data.Either.Either ((a :~~: b) -> GHC.Internal.Base.Void) (a :~~: b)
  heqT :: forall {k1} {k2} (a :: k1) (b :: k2). (Typeable a, Typeable b) => GHC.Internal.Maybe.Maybe (a :~~: b)
  mkFunTy :: TypeRep -> TypeRep -> TypeRep
  rnfTyCon :: TyCon -> ()
  rnfTypeRep :: TypeRep -> ()
  showsTypeRep :: TypeRep -> GHC.Internal.Show.ShowS
  splitTyConApp :: TypeRep -> (TyCon, [TypeRep])
  trLiftedRep :: ghc-internal-0.1.0.0:GHC.Internal.Data.Typeable.Internal.TypeRep GHC.Types.LiftedRep
  tyConFingerprint :: TyCon -> GHC.Internal.Fingerprint.Type.Fingerprint
  tyConModule :: TyCon -> GHC.Internal.Base.String
  tyConName :: TyCon -> GHC.Internal.Base.String
  tyConPackage :: TyCon -> GHC.Internal.Base.String
  typeOf :: forall a. Typeable a => a -> TypeRep
  typeOf1 :: forall (t :: * -> *) a. Typeable t => t a -> TypeRep
  typeOf2 :: forall (t :: * -> * -> *) a b. Typeable t => t a b -> TypeRep
  typeOf3 :: forall (t :: * -> * -> * -> *) a b c. Typeable t => t a b c -> TypeRep
  typeOf4 :: forall (t :: * -> * -> * -> * -> *) a b c d. Typeable t => t a b c d -> TypeRep
  typeOf5 :: forall (t :: * -> * -> * -> * -> * -> *) a b c d e. Typeable t => t a b c d e -> TypeRep
  typeOf6 :: forall (t :: * -> * -> * -> * -> * -> * -> *) a b c d e f. Typeable t => t a b c d e f -> TypeRep
  typeOf7 :: forall (t :: * -> * -> * -> * -> * -> * -> * -> *) a b c d e f g. Typeable t => t a b c d e f g -> TypeRep
  typeRep :: forall {k} (proxy :: k -> *) (a :: k). Typeable a => proxy a -> TypeRep
  typeRepArgs :: TypeRep -> [TypeRep]
  typeRepFingerprint :: TypeRep -> GHC.Internal.Fingerprint.Type.Fingerprint
  typeRepTyCon :: TypeRep -> TyCon

module Data.Unique where
  -- Safety: Safe
  type Unique :: *
  newtype Unique = ...
  hashUnique :: Unique -> GHC.Types.Int
  newUnique :: GHC.Types.IO Unique

module Data.Version where
  -- Safety: Safe
  type Version :: *
  data Version = Version {versionBranch :: [GHC.Types.Int], versionTags :: [GHC.Internal.Base.String]}
  makeVersion :: [GHC.Types.Int] -> Version
  parseVersion :: GHC.Internal.Text.ParserCombinators.ReadP.ReadP Version
  showVersion :: Version -> GHC.Internal.Base.String

module Data.Void where
  -- Safety: Safe
  type Void :: *
  data Void
  absurd :: forall a. Void -> a
  vacuous :: forall (f :: * -> *) a. GHC.Internal.Base.Functor f => f Void -> f a

module Data.Word where
  -- Safety: Safe
  type Word :: *
  data Word = ...
  type Word16 :: *
  data Word16 = ...
  type Word32 :: *
  data Word32 = ...
  type Word64 :: *
  data Word64 = ...
  type Word8 :: *
  data Word8 = ...
  bitReverse16 :: Word16 -> Word16
  bitReverse32 :: Word32 -> Word32
  bitReverse64 :: Word64 -> Word64
  bitReverse8 :: Word8 -> Word8
  byteSwap16 :: Word16 -> Word16
  byteSwap32 :: Word32 -> Word32
  byteSwap64 :: Word64 -> Word64

module Debug.Trace where
  -- Safety: None
  flushEventLog :: GHC.Types.IO ()
  putTraceMsg :: GHC.Internal.Base.String -> GHC.Types.IO ()
  trace :: forall a. GHC.Internal.Base.String -> a -> a
  traceEvent :: forall a. GHC.Internal.Base.String -> a -> a
  traceEventIO :: GHC.Internal.Base.String -> GHC.Types.IO ()
  traceEventWith :: forall a. (a -> GHC.Internal.Base.String) -> a -> a
  traceIO :: GHC.Internal.Base.String -> GHC.Types.IO ()
  traceId :: GHC.Internal.Base.String -> GHC.Internal.Base.String
  traceM :: forall (f :: * -> *). GHC.Internal.Base.Applicative f => GHC.Internal.Base.String -> f ()
  traceMarker :: forall a. GHC.Internal.Base.String -> a -> a
  traceMarkerIO :: GHC.Internal.Base.String -> GHC.Types.IO ()
  traceShow :: forall a b. GHC.Internal.Show.Show a => a -> b -> b
  traceShowId :: forall a. GHC.Internal.Show.Show a => a -> a
  traceShowM :: forall a (f :: * -> *). (GHC.Internal.Show.Show a, GHC.Internal.Base.Applicative f) => a -> f ()
  traceShowWith :: forall b a. GHC.Internal.Show.Show b => (a -> b) -> a -> a
  traceStack :: forall a. GHC.Internal.Base.String -> a -> a
  traceWith :: forall a. (a -> GHC.Internal.Base.String) -> a -> a

module Foreign where
  -- Safety: Safe
  (!<<.) :: forall a. Bits a => a -> Int -> a
  (!>>.) :: forall a. Bits a => a -> Int -> a
  (.<<.) :: forall a. Bits a => a -> Int -> a
  (.>>.) :: forall a. Bits a => a -> Int -> a
  (.^.) :: forall a. Bits a => a -> a -> a
  type And :: * -> *
  newtype And a = And {getAnd :: a}
  type Bits :: * -> Constraint
  class GHC.Classes.Eq a => Bits a where
    (.&.) :: a -> a -> a
    (.|.) :: a -> a -> a
    xor :: a -> a -> a
    complement :: a -> a
    shift :: a -> Int -> a
    rotate :: a -> Int -> a
    zeroBits :: a
    bit :: Int -> a
    setBit :: a -> Int -> a
    clearBit :: a -> Int -> a
    complementBit :: a -> Int -> a
    testBit :: a -> Int -> GHC.Types.Bool
    bitSizeMaybe :: a -> GHC.Internal.Maybe.Maybe Int
    bitSize :: a -> Int
    isSigned :: a -> GHC.Types.Bool
    shiftL :: a -> Int -> a
    unsafeShiftL :: a -> Int -> a
    shiftR :: a -> Int -> a
    unsafeShiftR :: a -> Int -> a
    rotateL :: a -> Int -> a
    rotateR :: a -> Int -> a
    popCount :: a -> Int
    {-# MINIMAL (.&.), (.|.), xor, complement, (shift | (shiftL, shiftR)), (rotate | (rotateL, rotateR)), bitSize, bitSizeMaybe, isSigned, testBit, bit, popCount #-}
  type FinalizerEnvPtr :: * -> * -> *
  type FinalizerEnvPtr env a = FunPtr (Ptr env -> Ptr a -> GHC.Types.IO ())
  type FinalizerPtr :: * -> *
  type FinalizerPtr a = FunPtr (Ptr a -> GHC.Types.IO ())
  type FiniteBits :: * -> Constraint
  class Bits b => FiniteBits b where
    finiteBitSize :: b -> Int
    countLeadingZeros :: b -> Int
    countTrailingZeros :: b -> Int
    {-# MINIMAL finiteBitSize #-}
  type role ForeignPtr phantom
  type ForeignPtr :: * -> *
  data ForeignPtr a = ...
  type role FunPtr phantom
  type FunPtr :: * -> *
  data FunPtr a = ...
  type Iff :: * -> *
  newtype Iff a = Iff {getIff :: a}
  type Int :: *
  data Int = ...
  type Int16 :: *
  data Int16 = ...
  type Int32 :: *
  data Int32 = ...
  type Int64 :: *
  data Int64 = ...
  type Int8 :: *
  data Int8 = ...
  type IntPtr :: *
  newtype IntPtr = IntPtr Int
  type Ior :: * -> *
  newtype Ior a = Ior {getIor :: a}
  type Pool :: *
  newtype Pool = ...
  type role Ptr phantom
  type Ptr :: * -> *
  data Ptr a = ...
  type StablePtr :: * -> *
  data StablePtr a = ...
  type Storable :: * -> Constraint
  class Storable a where
    sizeOf :: a -> Int
    alignment :: a -> Int
    peekElemOff :: Ptr a -> Int -> GHC.Types.IO a
    pokeElemOff :: Ptr a -> Int -> a -> GHC.Types.IO ()
    peekByteOff :: forall b. Ptr b -> Int -> GHC.Types.IO a
    pokeByteOff :: forall b. Ptr b -> Int -> a -> GHC.Types.IO ()
    peek :: Ptr a -> GHC.Types.IO a
    poke :: Ptr a -> a -> GHC.Types.IO ()
    {-# MINIMAL sizeOf, alignment, (peek | peekElemOff | peekByteOff), (poke | pokeElemOff | pokeByteOff) #-}
  type Word :: *
  data Word = ...
  type Word16 :: *
  data Word16 = ...
  type Word32 :: *
  data Word32 = ...
  type Word64 :: *
  data Word64 = ...
  type Word8 :: *
  data Word8 = ...
  type WordPtr :: *
  newtype WordPtr = WordPtr Word
  type Xor :: * -> *
  newtype Xor a = Xor {getXor :: a}
  addForeignPtrFinalizer :: forall a. FinalizerPtr a -> ForeignPtr a -> GHC.Types.IO ()
  addForeignPtrFinalizerEnv :: forall env a. FinalizerEnvPtr env a -> Ptr env -> ForeignPtr a -> GHC.Types.IO ()
  advancePtr :: forall a. Storable a => Ptr a -> Int -> Ptr a
  alignPtr :: forall a. Ptr a -> Int -> Ptr a
  alloca :: forall a b. Storable a => (Ptr a -> GHC.Types.IO b) -> GHC.Types.IO b
  allocaArray :: forall a b. Storable a => Int -> (Ptr a -> GHC.Types.IO b) -> GHC.Types.IO b
  allocaArray0 :: forall a b. Storable a => Int -> (Ptr a -> GHC.Types.IO b) -> GHC.Types.IO b
  allocaBytes :: forall a b. Int -> (Ptr a -> GHC.Types.IO b) -> GHC.Types.IO b
  allocaBytesAligned :: forall a b. Int -> Int -> (Ptr a -> GHC.Types.IO b) -> GHC.Types.IO b
  bitDefault :: forall a. (Bits a, GHC.Internal.Num.Num a) => Int -> a
  bitReverse16 :: Word16 -> Word16
  bitReverse32 :: Word32 -> Word32
  bitReverse64 :: Word64 -> Word64
  bitReverse8 :: Word8 -> Word8
  byteSwap16 :: Word16 -> Word16
  byteSwap32 :: Word32 -> Word32
  byteSwap64 :: Word64 -> Word64
  calloc :: forall a. Storable a => GHC.Types.IO (Ptr a)
  callocArray :: forall a. Storable a => Int -> GHC.Types.IO (Ptr a)
  callocArray0 :: forall a. Storable a => Int -> GHC.Types.IO (Ptr a)
  callocBytes :: forall a. Int -> GHC.Types.IO (Ptr a)
  castForeignPtr :: forall a b. ForeignPtr a -> ForeignPtr b
  castFunPtr :: forall a b. FunPtr a -> FunPtr b
  castFunPtrToPtr :: forall a b. FunPtr a -> Ptr b
  castPtr :: forall a b. Ptr a -> Ptr b
  castPtrToFunPtr :: forall a b. Ptr a -> FunPtr b
  castPtrToStablePtr :: forall a. Ptr () -> StablePtr a
  castStablePtrToPtr :: forall a. StablePtr a -> Ptr ()
  copyArray :: forall a. Storable a => Ptr a -> Ptr a -> Int -> GHC.Types.IO ()
  copyBytes :: forall a. Ptr a -> Ptr a -> Int -> GHC.Types.IO ()
  deRefStablePtr :: forall a. StablePtr a -> GHC.Types.IO a
  fillBytes :: forall a. Ptr a -> Word8 -> Int -> GHC.Types.IO ()
  finalizeForeignPtr :: forall a. ForeignPtr a -> GHC.Types.IO ()
  finalizerFree :: forall a. FinalizerPtr a
  free :: forall a. Ptr a -> GHC.Types.IO ()
  freeHaskellFunPtr :: forall a. FunPtr a -> GHC.Types.IO ()
  freePool :: Pool -> GHC.Types.IO ()
  freeStablePtr :: forall a. StablePtr a -> GHC.Types.IO ()
  fromBool :: forall a. GHC.Internal.Num.Num a => GHC.Types.Bool -> a
  intPtrToPtr :: forall a. IntPtr -> Ptr a
  lengthArray0 :: forall a. (Storable a, GHC.Classes.Eq a) => a -> Ptr a -> GHC.Types.IO Int
  malloc :: forall a. Storable a => GHC.Types.IO (Ptr a)
  mallocArray :: forall a. Storable a => Int -> GHC.Types.IO (Ptr a)
  mallocArray0 :: forall a. Storable a => Int -> GHC.Types.IO (Ptr a)
  mallocBytes :: forall a. Int -> GHC.Types.IO (Ptr a)
  mallocForeignPtr :: forall a. Storable a => GHC.Types.IO (ForeignPtr a)
  mallocForeignPtrArray :: forall a. Storable a => Int -> GHC.Types.IO (ForeignPtr a)
  mallocForeignPtrArray0 :: forall a. Storable a => Int -> GHC.Types.IO (ForeignPtr a)
  mallocForeignPtrBytes :: forall a. Int -> GHC.Types.IO (ForeignPtr a)
  maybeNew :: forall a b. (a -> GHC.Types.IO (Ptr b)) -> GHC.Internal.Maybe.Maybe a -> GHC.Types.IO (Ptr b)
  maybePeek :: forall a b. (Ptr a -> GHC.Types.IO b) -> Ptr a -> GHC.Types.IO (GHC.Internal.Maybe.Maybe b)
  maybeWith :: forall a b c. (a -> (Ptr b -> GHC.Types.IO c) -> GHC.Types.IO c) -> GHC.Internal.Maybe.Maybe a -> (Ptr b -> GHC.Types.IO c) -> GHC.Types.IO c
  minusPtr :: forall a b. Ptr a -> Ptr b -> Int
  moveArray :: forall a. Storable a => Ptr a -> Ptr a -> Int -> GHC.Types.IO ()
  moveBytes :: forall a. Ptr a -> Ptr a -> Int -> GHC.Types.IO ()
  new :: forall a. Storable a => a -> GHC.Types.IO (Ptr a)
  newArray :: forall a. Storable a => [a] -> GHC.Types.IO (Ptr a)
  newArray0 :: forall a. Storable a => a -> [a] -> GHC.Types.IO (Ptr a)
  newForeignPtr :: forall a. FinalizerPtr a -> Ptr a -> GHC.Types.IO (ForeignPtr a)
  newForeignPtrEnv :: forall env a. FinalizerEnvPtr env a -> Ptr env -> Ptr a -> GHC.Types.IO (ForeignPtr a)
  newForeignPtr_ :: forall a. Ptr a -> GHC.Types.IO (ForeignPtr a)
  newPool :: GHC.Types.IO Pool
  newStablePtr :: forall a. a -> GHC.Types.IO (StablePtr a)
  nullFunPtr :: forall a. FunPtr a
  nullPtr :: forall a. Ptr a
  oneBits :: forall a. FiniteBits a => a
  peekArray :: forall a. Storable a => Int -> Ptr a -> GHC.Types.IO [a]
  peekArray0 :: forall a. (Storable a, GHC.Classes.Eq a) => a -> Ptr a -> GHC.Types.IO [a]
  plusForeignPtr :: forall a b. ForeignPtr a -> Int -> ForeignPtr b
  plusPtr :: forall a b. Ptr a -> Int -> Ptr b
  pokeArray :: forall a. Storable a => Ptr a -> [a] -> GHC.Types.IO ()
  pokeArray0 :: forall a. Storable a => a -> Ptr a -> [a] -> GHC.Types.IO ()
  pooledMalloc :: forall a. Storable a => Pool -> GHC.Types.IO (Ptr a)
  pooledMallocArray :: forall a. Storable a => Pool -> Int -> GHC.Types.IO (Ptr a)
  pooledMallocArray0 :: forall a. Storable a => Pool -> Int -> GHC.Types.IO (Ptr a)
  pooledMallocBytes :: forall a. Pool -> Int -> GHC.Types.IO (Ptr a)
  pooledNew :: forall a. Storable a => Pool -> a -> GHC.Types.IO (Ptr a)
  pooledNewArray :: forall a. Storable a => Pool -> [a] -> GHC.Types.IO (Ptr a)
  pooledNewArray0 :: forall a. Storable a => Pool -> a -> [a] -> GHC.Types.IO (Ptr a)
  pooledRealloc :: forall a. Storable a => Pool -> Ptr a -> GHC.Types.IO (Ptr a)
  pooledReallocArray :: forall a. Storable a => Pool -> Ptr a -> Int -> GHC.Types.IO (Ptr a)
  pooledReallocArray0 :: forall a. Storable a => Pool -> Ptr a -> Int -> GHC.Types.IO (Ptr a)
  pooledReallocBytes :: forall a. Pool -> Ptr a -> Int -> GHC.Types.IO (Ptr a)
  popCountDefault :: forall a. (Bits a, GHC.Internal.Num.Num a) => a -> Int
  ptrToIntPtr :: forall a. Ptr a -> IntPtr
  ptrToWordPtr :: forall a. Ptr a -> WordPtr
  realloc :: forall a b. Storable b => Ptr a -> GHC.Types.IO (Ptr b)
  reallocArray :: forall a. Storable a => Ptr a -> Int -> GHC.Types.IO (Ptr a)
  reallocArray0 :: forall a. Storable a => Ptr a -> Int -> GHC.Types.IO (Ptr a)
  reallocBytes :: forall a. Ptr a -> Int -> GHC.Types.IO (Ptr a)
  testBitDefault :: forall a. (Bits a, GHC.Internal.Num.Num a) => a -> Int -> GHC.Types.Bool
  throwIf :: forall a. (a -> GHC.Types.Bool) -> (a -> GHC.Internal.Base.String) -> GHC.Types.IO a -> GHC.Types.IO a
  throwIfNeg :: forall a. (GHC.Classes.Ord a, GHC.Internal.Num.Num a) => (a -> GHC.Internal.Base.String) -> GHC.Types.IO a -> GHC.Types.IO a
  throwIfNeg_ :: forall a. (GHC.Classes.Ord a, GHC.Internal.Num.Num a) => (a -> GHC.Internal.Base.String) -> GHC.Types.IO a -> GHC.Types.IO ()
  throwIfNull :: forall a. GHC.Internal.Base.String -> GHC.Types.IO (Ptr a) -> GHC.Types.IO (Ptr a)
  throwIf_ :: forall a. (a -> GHC.Types.Bool) -> (a -> GHC.Internal.Base.String) -> GHC.Types.IO a -> GHC.Types.IO ()
  toBool :: forall a. (GHC.Classes.Eq a, GHC.Internal.Num.Num a) => a -> GHC.Types.Bool
  toIntegralSized :: forall a b. (GHC.Internal.Real.Integral a, GHC.Internal.Real.Integral b, Bits a, Bits b) => a -> GHC.Internal.Maybe.Maybe b
  touchForeignPtr :: forall a. ForeignPtr a -> GHC.Types.IO ()
  void :: forall a. GHC.Types.IO a -> GHC.Types.IO ()
  with :: forall a b. Storable a => a -> (Ptr a -> GHC.Types.IO b) -> GHC.Types.IO b
  withArray :: forall a b. Storable a => [a] -> (Ptr a -> GHC.Types.IO b) -> GHC.Types.IO b
  withArray0 :: forall a b. Storable a => a -> [a] -> (Ptr a -> GHC.Types.IO b) -> GHC.Types.IO b
  withArrayLen :: forall a b. Storable a => [a] -> (Int -> Ptr a -> GHC.Types.IO b) -> GHC.Types.IO b
  withArrayLen0 :: forall a b. Storable a => a -> [a] -> (Int -> Ptr a -> GHC.Types.IO b) -> GHC.Types.IO b
  withForeignPtr :: forall a b. ForeignPtr a -> (Ptr a -> GHC.Types.IO b) -> GHC.Types.IO b
  withMany :: forall a b res. (a -> (b -> res) -> res) -> [a] -> ([b] -> res) -> res
  withPool :: forall b. (Pool -> GHC.Types.IO b) -> GHC.Types.IO b
  wordPtrToPtr :: forall a. WordPtr -> Ptr a

module Foreign.C where
  -- Safety: Safe
  type CBool :: *
  newtype CBool = ...
  type CChar :: *
  newtype CChar = ...
  type CClock :: *
  newtype CClock = ...
  type CDouble :: *
  newtype CDouble = ...
  type CFile :: *
  data CFile = ...
  type CFloat :: *
  newtype CFloat = ...
  type CFpos :: *
  data CFpos = ...
  type CInt :: *
  newtype CInt = ...
  type CIntMax :: *
  newtype CIntMax = ...
  type CIntPtr :: *
  newtype CIntPtr = ...
  type CJmpBuf :: *
  data CJmpBuf = ...
  type CLLong :: *
  newtype CLLong = ...
  type CLong :: *
  newtype CLong = ...
  type CPtrdiff :: *
  newtype CPtrdiff = ...
  type CSChar :: *
  newtype CSChar = ...
  type CSUSeconds :: *
  newtype CSUSeconds = ...
  type CShort :: *
  newtype CShort = ...
  type CSigAtomic :: *
  newtype CSigAtomic = ...
  type CSize :: *
  newtype CSize = ...
  type CString :: *
  type CString = GHC.Internal.Ptr.Ptr CChar
  type CStringLen :: *
  type CStringLen = (GHC.Internal.Ptr.Ptr CChar, GHC.Types.Int)
  type CTime :: *
  newtype CTime = ...
  type CUChar :: *
  newtype CUChar = ...
  type CUInt :: *
  newtype CUInt = ...
  type CUIntMax :: *
  newtype CUIntMax = ...
  type CUIntPtr :: *
  newtype CUIntPtr = ...
  type CULLong :: *
  newtype CULLong = ...
  type CULong :: *
  newtype CULong = ...
  type CUSeconds :: *
  newtype CUSeconds = ...
  type CUShort :: *
  newtype CUShort = ...
  type CWString :: *
  type CWString = GHC.Internal.Ptr.Ptr CWchar
  type CWStringLen :: *
  type CWStringLen = (GHC.Internal.Ptr.Ptr CWchar, GHC.Types.Int)
  type CWchar :: *
  newtype CWchar = ...
  type Errno :: *
  newtype Errno = Errno CInt
  castCCharToChar :: CChar -> GHC.Types.Char
  castCSCharToChar :: CSChar -> GHC.Types.Char
  castCUCharToChar :: CUChar -> GHC.Types.Char
  castCharToCChar :: GHC.Types.Char -> CChar
  castCharToCSChar :: GHC.Types.Char -> CSChar
  castCharToCUChar :: GHC.Types.Char -> CUChar
  charIsRepresentable :: GHC.Types.Char -> GHC.Types.IO GHC.Types.Bool
  e2BIG :: Errno
  eACCES :: Errno
  eADDRINUSE :: Errno
  eADDRNOTAVAIL :: Errno
  eADV :: Errno
  eAFNOSUPPORT :: Errno
  eAGAIN :: Errno
  eALREADY :: Errno
  eBADF :: Errno
  eBADMSG :: Errno
  eBADRPC :: Errno
  eBUSY :: Errno
  eCHILD :: Errno
  eCOMM :: Errno
  eCONNABORTED :: Errno
  eCONNREFUSED :: Errno
  eCONNRESET :: Errno
  eDEADLK :: Errno
  eDESTADDRREQ :: Errno
  eDIRTY :: Errno
  eDOM :: Errno
  eDQUOT :: Errno
  eEXIST :: Errno
  eFAULT :: Errno
  eFBIG :: Errno
  eFTYPE :: Errno
  eHOSTDOWN :: Errno
  eHOSTUNREACH :: Errno
  eIDRM :: Errno
  eILSEQ :: Errno
  eINPROGRESS :: Errno
  eINTR :: Errno
  eINVAL :: Errno
  eIO :: Errno
  eISCONN :: Errno
  eISDIR :: Errno
  eLOOP :: Errno
  eMFILE :: Errno
  eMLINK :: Errno
  eMSGSIZE :: Errno
  eMULTIHOP :: Errno
  eNAMETOOLONG :: Errno
  eNETDOWN :: Errno
  eNETRESET :: Errno
  eNETUNREACH :: Errno
  eNFILE :: Errno
  eNOBUFS :: Errno
  eNODATA :: Errno
  eNODEV :: Errno
  eNOENT :: Errno
  eNOEXEC :: Errno
  eNOLCK :: Errno
  eNOLINK :: Errno
  eNOMEM :: Errno
  eNOMSG :: Errno
  eNONET :: Errno
  eNOPROTOOPT :: Errno
  eNOSPC :: Errno
  eNOSR :: Errno
  eNOSTR :: Errno
  eNOSYS :: Errno
  eNOTBLK :: Errno
  eNOTCONN :: Errno
  eNOTDIR :: Errno
  eNOTEMPTY :: Errno
  eNOTSOCK :: Errno
  eNOTSUP :: Errno
  eNOTTY :: Errno
  eNXIO :: Errno
  eOK :: Errno
  eOPNOTSUPP :: Errno
  ePERM :: Errno
  ePFNOSUPPORT :: Errno
  ePIPE :: Errno
  ePROCLIM :: Errno
  ePROCUNAVAIL :: Errno
  ePROGMISMATCH :: Errno
  ePROGUNAVAIL :: Errno
  ePROTO :: Errno
  ePROTONOSUPPORT :: Errno
  ePROTOTYPE :: Errno
  eRANGE :: Errno
  eREMCHG :: Errno
  eREMOTE :: Errno
  eROFS :: Errno
  eRPCMISMATCH :: Errno
  eRREMOTE :: Errno
  eSHUTDOWN :: Errno
  eSOCKTNOSUPPORT :: Errno
  eSPIPE :: Errno
  eSRCH :: Errno
  eSRMNT :: Errno
  eSTALE :: Errno
  eTIME :: Errno
  eTIMEDOUT :: Errno
  eTOOMANYREFS :: Errno
  eTXTBSY :: Errno
  eUSERS :: Errno
  eWOULDBLOCK :: Errno
  eXDEV :: Errno
  errnoToIOError :: GHC.Internal.Base.String -> Errno -> GHC.Internal.Maybe.Maybe GHC.Internal.IO.Handle.Types.Handle -> GHC.Internal.Maybe.Maybe GHC.Internal.Base.String -> GHC.Internal.IO.Exception.IOError
  getErrno :: GHC.Types.IO Errno
  isValidErrno :: Errno -> GHC.Types.Bool
  newCAString :: GHC.Internal.Base.String -> GHC.Types.IO CString
  newCAStringLen :: GHC.Internal.Base.String -> GHC.Types.IO CStringLen
  newCString :: GHC.Internal.Base.String -> GHC.Types.IO CString
  newCStringLen :: GHC.Internal.Base.String -> GHC.Types.IO CStringLen
  newCWString :: GHC.Internal.Base.String -> GHC.Types.IO CWString
  newCWStringLen :: GHC.Internal.Base.String -> GHC.Types.IO CWStringLen
  peekCAString :: CString -> GHC.Types.IO GHC.Internal.Base.String
  peekCAStringLen :: CStringLen -> GHC.Types.IO GHC.Internal.Base.String
  peekCString :: CString -> GHC.Types.IO GHC.Internal.Base.String
  peekCStringLen :: CStringLen -> GHC.Types.IO GHC.Internal.Base.String
  peekCWString :: CWString -> GHC.Types.IO GHC.Internal.Base.String
  peekCWStringLen :: CWStringLen -> GHC.Types.IO GHC.Internal.Base.String
  resetErrno :: GHC.Types.IO ()
  throwErrno :: forall a. GHC.Internal.Base.String -> GHC.Types.IO a
  throwErrnoIf :: forall a. (a -> GHC.Types.Bool) -> GHC.Internal.Base.String -> GHC.Types.IO a -> GHC.Types.IO a
  throwErrnoIfMinus1 :: forall a. (GHC.Classes.Eq a, GHC.Internal.Num.Num a) => GHC.Internal.Base.String -> GHC.Types.IO a -> GHC.Types.IO a
  throwErrnoIfMinus1Retry :: forall a. (GHC.Classes.Eq a, GHC.Internal.Num.Num a) => GHC.Internal.Base.String -> GHC.Types.IO a -> GHC.Types.IO a
  throwErrnoIfMinus1RetryMayBlock :: forall a b. (GHC.Classes.Eq a, GHC.Internal.Num.Num a) => GHC.Internal.Base.String -> GHC.Types.IO a -> GHC.Types.IO b -> GHC.Types.IO a
  throwErrnoIfMinus1RetryMayBlock_ :: forall a b. (GHC.Classes.Eq a, GHC.Internal.Num.Num a) => GHC.Internal.Base.String -> GHC.Types.IO a -> GHC.Types.IO b -> GHC.Types.IO ()
  throwErrnoIfMinus1Retry_ :: forall a. (GHC.Classes.Eq a, GHC.Internal.Num.Num a) => GHC.Internal.Base.String -> GHC.Types.IO a -> GHC.Types.IO ()
  throwErrnoIfMinus1_ :: forall a. (GHC.Classes.Eq a, GHC.Internal.Num.Num a) => GHC.Internal.Base.String -> GHC.Types.IO a -> GHC.Types.IO ()
  throwErrnoIfNull :: forall a. GHC.Internal.Base.String -> GHC.Types.IO (GHC.Internal.Ptr.Ptr a) -> GHC.Types.IO (GHC.Internal.Ptr.Ptr a)
  throwErrnoIfNullRetry :: forall a. GHC.Internal.Base.String -> GHC.Types.IO (GHC.Internal.Ptr.Ptr a) -> GHC.Types.IO (GHC.Internal.Ptr.Ptr a)
  throwErrnoIfNullRetryMayBlock :: forall a b. GHC.Internal.Base.String -> GHC.Types.IO (GHC.Internal.Ptr.Ptr a) -> GHC.Types.IO b -> GHC.Types.IO (GHC.Internal.Ptr.Ptr a)
  throwErrnoIfRetry :: forall a. (a -> GHC.Types.Bool) -> GHC.Internal.Base.String -> GHC.Types.IO a -> GHC.Types.IO a
  throwErrnoIfRetryMayBlock :: forall a b. (a -> GHC.Types.Bool) -> GHC.Internal.Base.String -> GHC.Types.IO a -> GHC.Types.IO b -> GHC.Types.IO a
  throwErrnoIfRetryMayBlock_ :: forall a b. (a -> GHC.Types.Bool) -> GHC.Internal.Base.String -> GHC.Types.IO a -> GHC.Types.IO b -> GHC.Types.IO ()
  throwErrnoIfRetry_ :: forall a. (a -> GHC.Types.Bool) -> GHC.Internal.Base.String -> GHC.Types.IO a -> GHC.Types.IO ()
  throwErrnoIf_ :: forall a. (a -> GHC.Types.Bool) -> GHC.Internal.Base.String -> GHC.Types.IO a -> GHC.Types.IO ()
  throwErrnoPath :: forall a. GHC.Internal.Base.String -> GHC.Internal.IO.FilePath -> GHC.Types.IO a
  throwErrnoPathIf :: forall a. (a -> GHC.Types.Bool) -> GHC.Internal.Base.String -> GHC.Internal.IO.FilePath -> GHC.Types.IO a -> GHC.Types.IO a
  throwErrnoPathIfMinus1 :: forall a. (GHC.Classes.Eq a, GHC.Internal.Num.Num a) => GHC.Internal.Base.String -> GHC.Internal.IO.FilePath -> GHC.Types.IO a -> GHC.Types.IO a
  throwErrnoPathIfMinus1_ :: forall a. (GHC.Classes.Eq a, GHC.Internal.Num.Num a) => GHC.Internal.Base.String -> GHC.Internal.IO.FilePath -> GHC.Types.IO a -> GHC.Types.IO ()
  throwErrnoPathIfNull :: forall a. GHC.Internal.Base.String -> GHC.Internal.IO.FilePath -> GHC.Types.IO (GHC.Internal.Ptr.Ptr a) -> GHC.Types.IO (GHC.Internal.Ptr.Ptr a)
  throwErrnoPathIf_ :: forall a. (a -> GHC.Types.Bool) -> GHC.Internal.Base.String -> GHC.Internal.IO.FilePath -> GHC.Types.IO a -> GHC.Types.IO ()
  withCAString :: forall a. GHC.Internal.Base.String -> (CString -> GHC.Types.IO a) -> GHC.Types.IO a
  withCAStringLen :: forall a. GHC.Internal.Base.String -> (CStringLen -> GHC.Types.IO a) -> GHC.Types.IO a
  withCString :: forall a. GHC.Internal.Base.String -> (CString -> GHC.Types.IO a) -> GHC.Types.IO a
  withCStringLen :: forall a. GHC.Internal.Base.String -> (CStringLen -> GHC.Types.IO a) -> GHC.Types.IO a
  withCWString :: forall a. GHC.Internal.Base.String -> (CWString -> GHC.Types.IO a) -> GHC.Types.IO a
  withCWStringLen :: forall a. GHC.Internal.Base.String -> (CWStringLen -> GHC.Types.IO a) -> GHC.Types.IO a

module Foreign.C.ConstPtr where
  -- Safety: Safe
  type role ConstPtr phantom
  type ConstPtr :: * -> *
  newtype ConstPtr a = ConstPtr {unConstPtr :: GHC.Internal.Ptr.Ptr a}

module Foreign.C.Error where
  -- Safety: Safe
  type Errno :: *
  newtype Errno = Errno GHC.Internal.Foreign.C.Types.CInt
  e2BIG :: Errno
  eACCES :: Errno
  eADDRINUSE :: Errno
  eADDRNOTAVAIL :: Errno
  eADV :: Errno
  eAFNOSUPPORT :: Errno
  eAGAIN :: Errno
  eALREADY :: Errno
  eBADF :: Errno
  eBADMSG :: Errno
  eBADRPC :: Errno
  eBUSY :: Errno
  eCHILD :: Errno
  eCOMM :: Errno
  eCONNABORTED :: Errno
  eCONNREFUSED :: Errno
  eCONNRESET :: Errno
  eDEADLK :: Errno
  eDESTADDRREQ :: Errno
  eDIRTY :: Errno
  eDOM :: Errno
  eDQUOT :: Errno
  eEXIST :: Errno
  eFAULT :: Errno
  eFBIG :: Errno
  eFTYPE :: Errno
  eHOSTDOWN :: Errno
  eHOSTUNREACH :: Errno
  eIDRM :: Errno
  eILSEQ :: Errno
  eINPROGRESS :: Errno
  eINTR :: Errno
  eINVAL :: Errno
  eIO :: Errno
  eISCONN :: Errno
  eISDIR :: Errno
  eLOOP :: Errno
  eMFILE :: Errno
  eMLINK :: Errno
  eMSGSIZE :: Errno
  eMULTIHOP :: Errno
  eNAMETOOLONG :: Errno
  eNETDOWN :: Errno
  eNETRESET :: Errno
  eNETUNREACH :: Errno
  eNFILE :: Errno
  eNOBUFS :: Errno
  eNODATA :: Errno
  eNODEV :: Errno
  eNOENT :: Errno
  eNOEXEC :: Errno
  eNOLCK :: Errno
  eNOLINK :: Errno
  eNOMEM :: Errno
  eNOMSG :: Errno
  eNONET :: Errno
  eNOPROTOOPT :: Errno
  eNOSPC :: Errno
  eNOSR :: Errno
  eNOSTR :: Errno
  eNOSYS :: Errno
  eNOTBLK :: Errno
  eNOTCONN :: Errno
  eNOTDIR :: Errno
  eNOTEMPTY :: Errno
  eNOTSOCK :: Errno
  eNOTSUP :: Errno
  eNOTTY :: Errno
  eNXIO :: Errno
  eOK :: Errno
  eOPNOTSUPP :: Errno
  ePERM :: Errno
  ePFNOSUPPORT :: Errno
  ePIPE :: Errno
  ePROCLIM :: Errno
  ePROCUNAVAIL :: Errno
  ePROGMISMATCH :: Errno
  ePROGUNAVAIL :: Errno
  ePROTO :: Errno
  ePROTONOSUPPORT :: Errno
  ePROTOTYPE :: Errno
  eRANGE :: Errno
  eREMCHG :: Errno
  eREMOTE :: Errno
  eROFS :: Errno
  eRPCMISMATCH :: Errno
  eRREMOTE :: Errno
  eSHUTDOWN :: Errno
  eSOCKTNOSUPPORT :: Errno
  eSPIPE :: Errno
  eSRCH :: Errno
  eSRMNT :: Errno
  eSTALE :: Errno
  eTIME :: Errno
  eTIMEDOUT :: Errno
  eTOOMANYREFS :: Errno
  eTXTBSY :: Errno
  eUSERS :: Errno
  eWOULDBLOCK :: Errno
  eXDEV :: Errno
  errnoToIOError :: GHC.Internal.Base.String -> Errno -> GHC.Internal.Maybe.Maybe GHC.Internal.IO.Handle.Types.Handle -> GHC.Internal.Maybe.Maybe GHC.Internal.Base.String -> GHC.Internal.IO.Exception.IOError
  getErrno :: GHC.Types.IO Errno
  isValidErrno :: Errno -> GHC.Types.Bool
  resetErrno :: GHC.Types.IO ()
  throwErrno :: forall a. GHC.Internal.Base.String -> GHC.Types.IO a
  throwErrnoIf :: forall a. (a -> GHC.Types.Bool) -> GHC.Internal.Base.String -> GHC.Types.IO a -> GHC.Types.IO a
  throwErrnoIfMinus1 :: forall a. (GHC.Classes.Eq a, GHC.Internal.Num.Num a) => GHC.Internal.Base.String -> GHC.Types.IO a -> GHC.Types.IO a
  throwErrnoIfMinus1Retry :: forall a. (GHC.Classes.Eq a, GHC.Internal.Num.Num a) => GHC.Internal.Base.String -> GHC.Types.IO a -> GHC.Types.IO a
  throwErrnoIfMinus1RetryMayBlock :: forall a b. (GHC.Classes.Eq a, GHC.Internal.Num.Num a) => GHC.Internal.Base.String -> GHC.Types.IO a -> GHC.Types.IO b -> GHC.Types.IO a
  throwErrnoIfMinus1RetryMayBlock_ :: forall a b. (GHC.Classes.Eq a, GHC.Internal.Num.Num a) => GHC.Internal.Base.String -> GHC.Types.IO a -> GHC.Types.IO b -> GHC.Types.IO ()
  throwErrnoIfMinus1Retry_ :: forall a. (GHC.Classes.Eq a, GHC.Internal.Num.Num a) => GHC.Internal.Base.String -> GHC.Types.IO a -> GHC.Types.IO ()
  throwErrnoIfMinus1_ :: forall a. (GHC.Classes.Eq a, GHC.Internal.Num.Num a) => GHC.Internal.Base.String -> GHC.Types.IO a -> GHC.Types.IO ()
  throwErrnoIfNull :: forall a. GHC.Internal.Base.String -> GHC.Types.IO (GHC.Internal.Ptr.Ptr a) -> GHC.Types.IO (GHC.Internal.Ptr.Ptr a)
  throwErrnoIfNullRetry :: forall a. GHC.Internal.Base.String -> GHC.Types.IO (GHC.Internal.Ptr.Ptr a) -> GHC.Types.IO (GHC.Internal.Ptr.Ptr a)
  throwErrnoIfNullRetryMayBlock :: forall a b. GHC.Internal.Base.String -> GHC.Types.IO (GHC.Internal.Ptr.Ptr a) -> GHC.Types.IO b -> GHC.Types.IO (GHC.Internal.Ptr.Ptr a)
  throwErrnoIfRetry :: forall a. (a -> GHC.Types.Bool) -> GHC.Internal.Base.String -> GHC.Types.IO a -> GHC.Types.IO a
  throwErrnoIfRetryMayBlock :: forall a b. (a -> GHC.Types.Bool) -> GHC.Internal.Base.String -> GHC.Types.IO a -> GHC.Types.IO b -> GHC.Types.IO a
  throwErrnoIfRetryMayBlock_ :: forall a b. (a -> GHC.Types.Bool) -> GHC.Internal.Base.String -> GHC.Types.IO a -> GHC.Types.IO b -> GHC.Types.IO ()
  throwErrnoIfRetry_ :: forall a. (a -> GHC.Types.Bool) -> GHC.Internal.Base.String -> GHC.Types.IO a -> GHC.Types.IO ()
  throwErrnoIf_ :: forall a. (a -> GHC.Types.Bool) -> GHC.Internal.Base.String -> GHC.Types.IO a -> GHC.Types.IO ()
  throwErrnoPath :: forall a. GHC.Internal.Base.String -> GHC.Internal.IO.FilePath -> GHC.Types.IO a
  throwErrnoPathIf :: forall a. (a -> GHC.Types.Bool) -> GHC.Internal.Base.String -> GHC.Internal.IO.FilePath -> GHC.Types.IO a -> GHC.Types.IO a
  throwErrnoPathIfMinus1 :: forall a. (GHC.Classes.Eq a, GHC.Internal.Num.Num a) => GHC.Internal.Base.String -> GHC.Internal.IO.FilePath -> GHC.Types.IO a -> GHC.Types.IO a
  throwErrnoPathIfMinus1_ :: forall a. (GHC.Classes.Eq a, GHC.Internal.Num.Num a) => GHC.Internal.Base.String -> GHC.Internal.IO.FilePath -> GHC.Types.IO a -> GHC.Types.IO ()
  throwErrnoPathIfNull :: forall a. GHC.Internal.Base.String -> GHC.Internal.IO.FilePath -> GHC.Types.IO (GHC.Internal.Ptr.Ptr a) -> GHC.Types.IO (GHC.Internal.Ptr.Ptr a)
  throwErrnoPathIf_ :: forall a. (a -> GHC.Types.Bool) -> GHC.Internal.Base.String -> GHC.Internal.IO.FilePath -> GHC.Types.IO a -> GHC.Types.IO ()

module Foreign.C.String where
  -- Safety: Safe
  type CString :: *
  type CString = GHC.Internal.Ptr.Ptr GHC.Internal.Foreign.C.Types.CChar
  type CStringLen :: *
  type CStringLen = (GHC.Internal.Ptr.Ptr GHC.Internal.Foreign.C.Types.CChar, GHC.Types.Int)
  type CWString :: *
  type CWString = GHC.Internal.Ptr.Ptr GHC.Internal.Foreign.C.Types.CWchar
  type CWStringLen :: *
  type CWStringLen = (GHC.Internal.Ptr.Ptr GHC.Internal.Foreign.C.Types.CWchar, GHC.Types.Int)
  castCCharToChar :: GHC.Internal.Foreign.C.Types.CChar -> GHC.Types.Char
  castCSCharToChar :: GHC.Internal.Foreign.C.Types.CSChar -> GHC.Types.Char
  castCUCharToChar :: GHC.Internal.Foreign.C.Types.CUChar -> GHC.Types.Char
  castCharToCChar :: GHC.Types.Char -> GHC.Internal.Foreign.C.Types.CChar
  castCharToCSChar :: GHC.Types.Char -> GHC.Internal.Foreign.C.Types.CSChar
  castCharToCUChar :: GHC.Types.Char -> GHC.Internal.Foreign.C.Types.CUChar
  charIsRepresentable :: GHC.Types.Char -> GHC.Types.IO GHC.Types.Bool
  newCAString :: GHC.Internal.Base.String -> GHC.Types.IO CString
  newCAStringLen :: GHC.Internal.Base.String -> GHC.Types.IO CStringLen
  newCString :: GHC.Internal.Base.String -> GHC.Types.IO CString
  newCStringLen :: GHC.Internal.Base.String -> GHC.Types.IO CStringLen
  newCWString :: GHC.Internal.Base.String -> GHC.Types.IO CWString
  newCWStringLen :: GHC.Internal.Base.String -> GHC.Types.IO CWStringLen
  peekCAString :: CString -> GHC.Types.IO GHC.Internal.Base.String
  peekCAStringLen :: CStringLen -> GHC.Types.IO GHC.Internal.Base.String
  peekCString :: CString -> GHC.Types.IO GHC.Internal.Base.String
  peekCStringLen :: CStringLen -> GHC.Types.IO GHC.Internal.Base.String
  peekCWString :: CWString -> GHC.Types.IO GHC.Internal.Base.String
  peekCWStringLen :: CWStringLen -> GHC.Types.IO GHC.Internal.Base.String
  withCAString :: forall a. GHC.Internal.Base.String -> (CString -> GHC.Types.IO a) -> GHC.Types.IO a
  withCAStringLen :: forall a. GHC.Internal.Base.String -> (CStringLen -> GHC.Types.IO a) -> GHC.Types.IO a
  withCString :: forall a. GHC.Internal.Base.String -> (CString -> GHC.Types.IO a) -> GHC.Types.IO a
  withCStringLen :: forall a. GHC.Internal.Base.String -> (CStringLen -> GHC.Types.IO a) -> GHC.Types.IO a
  withCWString :: forall a. GHC.Internal.Base.String -> (CWString -> GHC.Types.IO a) -> GHC.Types.IO a
  withCWStringLen :: forall a. GHC.Internal.Base.String -> (CWStringLen -> GHC.Types.IO a) -> GHC.Types.IO a

module Foreign.C.Types where

-- ignored


module Foreign.Concurrent where
  -- Safety: Safe
  addForeignPtrFinalizer :: forall a. GHC.Internal.ForeignPtr.ForeignPtr a -> GHC.Types.IO () -> GHC.Types.IO ()
  newForeignPtr :: forall a. GHC.Internal.Ptr.Ptr a -> GHC.Types.IO () -> GHC.Types.IO (GHC.Internal.ForeignPtr.ForeignPtr a)

module Foreign.ForeignPtr where
  -- Safety: Safe
  type FinalizerEnvPtr :: * -> * -> *
  type FinalizerEnvPtr env a = GHC.Internal.Ptr.FunPtr (GHC.Internal.Ptr.Ptr env -> GHC.Internal.Ptr.Ptr a -> GHC.Types.IO ())
  type FinalizerPtr :: * -> *
  type FinalizerPtr a = GHC.Internal.Ptr.FunPtr (GHC.Internal.Ptr.Ptr a -> GHC.Types.IO ())
  type role ForeignPtr phantom
  type ForeignPtr :: * -> *
  data ForeignPtr a = ...
  addForeignPtrFinalizer :: forall a. FinalizerPtr a -> ForeignPtr a -> GHC.Types.IO ()
  addForeignPtrFinalizerEnv :: forall env a. FinalizerEnvPtr env a -> GHC.Internal.Ptr.Ptr env -> ForeignPtr a -> GHC.Types.IO ()
  castForeignPtr :: forall a b. ForeignPtr a -> ForeignPtr b
  finalizeForeignPtr :: forall a. ForeignPtr a -> GHC.Types.IO ()
  mallocForeignPtr :: forall a. GHC.Internal.Foreign.Storable.Storable a => GHC.Types.IO (ForeignPtr a)
  mallocForeignPtrArray :: forall a. GHC.Internal.Foreign.Storable.Storable a => GHC.Types.Int -> GHC.Types.IO (ForeignPtr a)
  mallocForeignPtrArray0 :: forall a. GHC.Internal.Foreign.Storable.Storable a => GHC.Types.Int -> GHC.Types.IO (ForeignPtr a)
  mallocForeignPtrBytes :: forall a. GHC.Types.Int -> GHC.Types.IO (ForeignPtr a)
  newForeignPtr :: forall a. FinalizerPtr a -> GHC.Internal.Ptr.Ptr a -> GHC.Types.IO (ForeignPtr a)
  newForeignPtrEnv :: forall env a. FinalizerEnvPtr env a -> GHC.Internal.Ptr.Ptr env -> GHC.Internal.Ptr.Ptr a -> GHC.Types.IO (ForeignPtr a)
  newForeignPtr_ :: forall a. GHC.Internal.Ptr.Ptr a -> GHC.Types.IO (ForeignPtr a)
  plusForeignPtr :: forall a b. ForeignPtr a -> GHC.Types.Int -> ForeignPtr b
  touchForeignPtr :: forall a. ForeignPtr a -> GHC.Types.IO ()
  withForeignPtr :: forall a b. ForeignPtr a -> (GHC.Internal.Ptr.Ptr a -> GHC.Types.IO b) -> GHC.Types.IO b

module Foreign.ForeignPtr.Safe where
  -- Safety: Trustworthy
  type FinalizerEnvPtr :: * -> * -> *
  type FinalizerEnvPtr env a = GHC.Internal.Ptr.FunPtr (GHC.Internal.Ptr.Ptr env -> GHC.Internal.Ptr.Ptr a -> GHC.Types.IO ())
  type FinalizerPtr :: * -> *
  type FinalizerPtr a = GHC.Internal.Ptr.FunPtr (GHC.Internal.Ptr.Ptr a -> GHC.Types.IO ())
  type role ForeignPtr phantom
  type ForeignPtr :: * -> *
  data ForeignPtr a = ...
  addForeignPtrFinalizer :: forall a. FinalizerPtr a -> ForeignPtr a -> GHC.Types.IO ()
  addForeignPtrFinalizerEnv :: forall env a. FinalizerEnvPtr env a -> GHC.Internal.Ptr.Ptr env -> ForeignPtr a -> GHC.Types.IO ()
  castForeignPtr :: forall a b. ForeignPtr a -> ForeignPtr b
  finalizeForeignPtr :: forall a. ForeignPtr a -> GHC.Types.IO ()
  mallocForeignPtr :: forall a. GHC.Internal.Foreign.Storable.Storable a => GHC.Types.IO (ForeignPtr a)
  mallocForeignPtrArray :: forall a. GHC.Internal.Foreign.Storable.Storable a => GHC.Types.Int -> GHC.Types.IO (ForeignPtr a)
  mallocForeignPtrArray0 :: forall a. GHC.Internal.Foreign.Storable.Storable a => GHC.Types.Int -> GHC.Types.IO (ForeignPtr a)
  mallocForeignPtrBytes :: forall a. GHC.Types.Int -> GHC.Types.IO (ForeignPtr a)
  newForeignPtr :: forall a. FinalizerPtr a -> GHC.Internal.Ptr.Ptr a -> GHC.Types.IO (ForeignPtr a)
  newForeignPtrEnv :: forall env a. FinalizerEnvPtr env a -> GHC.Internal.Ptr.Ptr env -> GHC.Internal.Ptr.Ptr a -> GHC.Types.IO (ForeignPtr a)
  newForeignPtr_ :: forall a. GHC.Internal.Ptr.Ptr a -> GHC.Types.IO (ForeignPtr a)
  touchForeignPtr :: forall a. ForeignPtr a -> GHC.Types.IO ()
  withForeignPtr :: forall a b. ForeignPtr a -> (GHC.Internal.Ptr.Ptr a -> GHC.Types.IO b) -> GHC.Types.IO b

module Foreign.ForeignPtr.Unsafe where
  -- Safety: None
  unsafeForeignPtrToPtr :: forall a. GHC.Internal.ForeignPtr.ForeignPtr a -> GHC.Internal.Ptr.Ptr a

module Foreign.Marshal where
  -- Safety: Safe
  type Pool :: *
  newtype Pool = ...
  advancePtr :: forall a. GHC.Internal.Foreign.Storable.Storable a => GHC.Internal.Ptr.Ptr a -> GHC.Types.Int -> GHC.Internal.Ptr.Ptr a
  alloca :: forall a b. GHC.Internal.Foreign.Storable.Storable a => (GHC.Internal.Ptr.Ptr a -> GHC.Types.IO b) -> GHC.Types.IO b
  allocaArray :: forall a b. GHC.Internal.Foreign.Storable.Storable a => GHC.Types.Int -> (GHC.Internal.Ptr.Ptr a -> GHC.Types.IO b) -> GHC.Types.IO b
  allocaArray0 :: forall a b. GHC.Internal.Foreign.Storable.Storable a => GHC.Types.Int -> (GHC.Internal.Ptr.Ptr a -> GHC.Types.IO b) -> GHC.Types.IO b
  allocaBytes :: forall a b. GHC.Types.Int -> (GHC.Internal.Ptr.Ptr a -> GHC.Types.IO b) -> GHC.Types.IO b
  allocaBytesAligned :: forall a b. GHC.Types.Int -> GHC.Types.Int -> (GHC.Internal.Ptr.Ptr a -> GHC.Types.IO b) -> GHC.Types.IO b
  calloc :: forall a. GHC.Internal.Foreign.Storable.Storable a => GHC.Types.IO (GHC.Internal.Ptr.Ptr a)
  callocArray :: forall a. GHC.Internal.Foreign.Storable.Storable a => GHC.Types.Int -> GHC.Types.IO (GHC.Internal.Ptr.Ptr a)
  callocArray0 :: forall a. GHC.Internal.Foreign.Storable.Storable a => GHC.Types.Int -> GHC.Types.IO (GHC.Internal.Ptr.Ptr a)
  callocBytes :: forall a. GHC.Types.Int -> GHC.Types.IO (GHC.Internal.Ptr.Ptr a)
  copyArray :: forall a. GHC.Internal.Foreign.Storable.Storable a => GHC.Internal.Ptr.Ptr a -> GHC.Internal.Ptr.Ptr a -> GHC.Types.Int -> GHC.Types.IO ()
  copyBytes :: forall a. GHC.Internal.Ptr.Ptr a -> GHC.Internal.Ptr.Ptr a -> GHC.Types.Int -> GHC.Types.IO ()
  fillBytes :: forall a. GHC.Internal.Ptr.Ptr a -> GHC.Internal.Word.Word8 -> GHC.Types.Int -> GHC.Types.IO ()
  finalizerFree :: forall a. GHC.Internal.ForeignPtr.FinalizerPtr a
  free :: forall a. GHC.Internal.Ptr.Ptr a -> GHC.Types.IO ()
  freePool :: Pool -> GHC.Types.IO ()
  fromBool :: forall a. GHC.Internal.Num.Num a => GHC.Types.Bool -> a
  lengthArray0 :: forall a. (GHC.Internal.Foreign.Storable.Storable a, GHC.Classes.Eq a) => a -> GHC.Internal.Ptr.Ptr a -> GHC.Types.IO GHC.Types.Int
  malloc :: forall a. GHC.Internal.Foreign.Storable.Storable a => GHC.Types.IO (GHC.Internal.Ptr.Ptr a)
  mallocArray :: forall a. GHC.Internal.Foreign.Storable.Storable a => GHC.Types.Int -> GHC.Types.IO (GHC.Internal.Ptr.Ptr a)
  mallocArray0 :: forall a. GHC.Internal.Foreign.Storable.Storable a => GHC.Types.Int -> GHC.Types.IO (GHC.Internal.Ptr.Ptr a)
  mallocBytes :: forall a. GHC.Types.Int -> GHC.Types.IO (GHC.Internal.Ptr.Ptr a)
  maybeNew :: forall a b. (a -> GHC.Types.IO (GHC.Internal.Ptr.Ptr b)) -> GHC.Internal.Maybe.Maybe a -> GHC.Types.IO (GHC.Internal.Ptr.Ptr b)
  maybePeek :: forall a b. (GHC.Internal.Ptr.Ptr a -> GHC.Types.IO b) -> GHC.Internal.Ptr.Ptr a -> GHC.Types.IO (GHC.Internal.Maybe.Maybe b)
  maybeWith :: forall a b c. (a -> (GHC.Internal.Ptr.Ptr b -> GHC.Types.IO c) -> GHC.Types.IO c) -> GHC.Internal.Maybe.Maybe a -> (GHC.Internal.Ptr.Ptr b -> GHC.Types.IO c) -> GHC.Types.IO c
  moveArray :: forall a. GHC.Internal.Foreign.Storable.Storable a => GHC.Internal.Ptr.Ptr a -> GHC.Internal.Ptr.Ptr a -> GHC.Types.Int -> GHC.Types.IO ()
  moveBytes :: forall a. GHC.Internal.Ptr.Ptr a -> GHC.Internal.Ptr.Ptr a -> GHC.Types.Int -> GHC.Types.IO ()
  new :: forall a. GHC.Internal.Foreign.Storable.Storable a => a -> GHC.Types.IO (GHC.Internal.Ptr.Ptr a)
  newArray :: forall a. GHC.Internal.Foreign.Storable.Storable a => [a] -> GHC.Types.IO (GHC.Internal.Ptr.Ptr a)
  newArray0 :: forall a. GHC.Internal.Foreign.Storable.Storable a => a -> [a] -> GHC.Types.IO (GHC.Internal.Ptr.Ptr a)
  newPool :: GHC.Types.IO Pool
  peekArray :: forall a. GHC.Internal.Foreign.Storable.Storable a => GHC.Types.Int -> GHC.Internal.Ptr.Ptr a -> GHC.Types.IO [a]
  peekArray0 :: forall a. (GHC.Internal.Foreign.Storable.Storable a, GHC.Classes.Eq a) => a -> GHC.Internal.Ptr.Ptr a -> GHC.Types.IO [a]
  pokeArray :: forall a. GHC.Internal.Foreign.Storable.Storable a => GHC.Internal.Ptr.Ptr a -> [a] -> GHC.Types.IO ()
  pokeArray0 :: forall a. GHC.Internal.Foreign.Storable.Storable a => a -> GHC.Internal.Ptr.Ptr a -> [a] -> GHC.Types.IO ()
  pooledMalloc :: forall a. GHC.Internal.Foreign.Storable.Storable a => Pool -> GHC.Types.IO (GHC.Internal.Ptr.Ptr a)
  pooledMallocArray :: forall a. GHC.Internal.Foreign.Storable.Storable a => Pool -> GHC.Types.Int -> GHC.Types.IO (GHC.Internal.Ptr.Ptr a)
  pooledMallocArray0 :: forall a. GHC.Internal.Foreign.Storable.Storable a => Pool -> GHC.Types.Int -> GHC.Types.IO (GHC.Internal.Ptr.Ptr a)
  pooledMallocBytes :: forall a. Pool -> GHC.Types.Int -> GHC.Types.IO (GHC.Internal.Ptr.Ptr a)
  pooledNew :: forall a. GHC.Internal.Foreign.Storable.Storable a => Pool -> a -> GHC.Types.IO (GHC.Internal.Ptr.Ptr a)
  pooledNewArray :: forall a. GHC.Internal.Foreign.Storable.Storable a => Pool -> [a] -> GHC.Types.IO (GHC.Internal.Ptr.Ptr a)
  pooledNewArray0 :: forall a. GHC.Internal.Foreign.Storable.Storable a => Pool -> a -> [a] -> GHC.Types.IO (GHC.Internal.Ptr.Ptr a)
  pooledRealloc :: forall a. GHC.Internal.Foreign.Storable.Storable a => Pool -> GHC.Internal.Ptr.Ptr a -> GHC.Types.IO (GHC.Internal.Ptr.Ptr a)
  pooledReallocArray :: forall a. GHC.Internal.Foreign.Storable.Storable a => Pool -> GHC.Internal.Ptr.Ptr a -> GHC.Types.Int -> GHC.Types.IO (GHC.Internal.Ptr.Ptr a)
  pooledReallocArray0 :: forall a. GHC.Internal.Foreign.Storable.Storable a => Pool -> GHC.Internal.Ptr.Ptr a -> GHC.Types.Int -> GHC.Types.IO (GHC.Internal.Ptr.Ptr a)
  pooledReallocBytes :: forall a. Pool -> GHC.Internal.Ptr.Ptr a -> GHC.Types.Int -> GHC.Types.IO (GHC.Internal.Ptr.Ptr a)
  realloc :: forall a b. GHC.Internal.Foreign.Storable.Storable b => GHC.Internal.Ptr.Ptr a -> GHC.Types.IO (GHC.Internal.Ptr.Ptr b)
  reallocArray :: forall a. GHC.Internal.Foreign.Storable.Storable a => GHC.Internal.Ptr.Ptr a -> GHC.Types.Int -> GHC.Types.IO (GHC.Internal.Ptr.Ptr a)
  reallocArray0 :: forall a. GHC.Internal.Foreign.Storable.Storable a => GHC.Internal.Ptr.Ptr a -> GHC.Types.Int -> GHC.Types.IO (GHC.Internal.Ptr.Ptr a)
  reallocBytes :: forall a. GHC.Internal.Ptr.Ptr a -> GHC.Types.Int -> GHC.Types.IO (GHC.Internal.Ptr.Ptr a)
  throwIf :: forall a. (a -> GHC.Types.Bool) -> (a -> GHC.Internal.Base.String) -> GHC.Types.IO a -> GHC.Types.IO a
  throwIfNeg :: forall a. (GHC.Classes.Ord a, GHC.Internal.Num.Num a) => (a -> GHC.Internal.Base.String) -> GHC.Types.IO a -> GHC.Types.IO a
  throwIfNeg_ :: forall a. (GHC.Classes.Ord a, GHC.Internal.Num.Num a) => (a -> GHC.Internal.Base.String) -> GHC.Types.IO a -> GHC.Types.IO ()
  throwIfNull :: forall a. GHC.Internal.Base.String -> GHC.Types.IO (GHC.Internal.Ptr.Ptr a) -> GHC.Types.IO (GHC.Internal.Ptr.Ptr a)
  throwIf_ :: forall a. (a -> GHC.Types.Bool) -> (a -> GHC.Internal.Base.String) -> GHC.Types.IO a -> GHC.Types.IO ()
  toBool :: forall a. (GHC.Classes.Eq a, GHC.Internal.Num.Num a) => a -> GHC.Types.Bool
  void :: forall a. GHC.Types.IO a -> GHC.Types.IO ()
  with :: forall a b. GHC.Internal.Foreign.Storable.Storable a => a -> (GHC.Internal.Ptr.Ptr a -> GHC.Types.IO b) -> GHC.Types.IO b
  withArray :: forall a b. GHC.Internal.Foreign.Storable.Storable a => [a] -> (GHC.Internal.Ptr.Ptr a -> GHC.Types.IO b) -> GHC.Types.IO b
  withArray0 :: forall a b. GHC.Internal.Foreign.Storable.Storable a => a -> [a] -> (GHC.Internal.Ptr.Ptr a -> GHC.Types.IO b) -> GHC.Types.IO b
  withArrayLen :: forall a b. GHC.Internal.Foreign.Storable.Storable a => [a] -> (GHC.Types.Int -> GHC.Internal.Ptr.Ptr a -> GHC.Types.IO b) -> GHC.Types.IO b
  withArrayLen0 :: forall a b. GHC.Internal.Foreign.Storable.Storable a => a -> [a] -> (GHC.Types.Int -> GHC.Internal.Ptr.Ptr a -> GHC.Types.IO b) -> GHC.Types.IO b
  withMany :: forall a b res. (a -> (b -> res) -> res) -> [a] -> ([b] -> res) -> res
  withPool :: forall b. (Pool -> GHC.Types.IO b) -> GHC.Types.IO b

module Foreign.Marshal.Alloc where
  -- Safety: Safe
  alloca :: forall a b. GHC.Internal.Foreign.Storable.Storable a => (GHC.Internal.Ptr.Ptr a -> GHC.Types.IO b) -> GHC.Types.IO b
  allocaBytes :: forall a b. GHC.Types.Int -> (GHC.Internal.Ptr.Ptr a -> GHC.Types.IO b) -> GHC.Types.IO b
  allocaBytesAligned :: forall a b. GHC.Types.Int -> GHC.Types.Int -> (GHC.Internal.Ptr.Ptr a -> GHC.Types.IO b) -> GHC.Types.IO b
  calloc :: forall a. GHC.Internal.Foreign.Storable.Storable a => GHC.Types.IO (GHC.Internal.Ptr.Ptr a)
  callocBytes :: forall a. GHC.Types.Int -> GHC.Types.IO (GHC.Internal.Ptr.Ptr a)
  finalizerFree :: forall a. GHC.Internal.ForeignPtr.FinalizerPtr a
  free :: forall a. GHC.Internal.Ptr.Ptr a -> GHC.Types.IO ()
  malloc :: forall a. GHC.Internal.Foreign.Storable.Storable a => GHC.Types.IO (GHC.Internal.Ptr.Ptr a)
  mallocBytes :: forall a. GHC.Types.Int -> GHC.Types.IO (GHC.Internal.Ptr.Ptr a)
  realloc :: forall a b. GHC.Internal.Foreign.Storable.Storable b => GHC.Internal.Ptr.Ptr a -> GHC.Types.IO (GHC.Internal.Ptr.Ptr b)
  reallocBytes :: forall a. GHC.Internal.Ptr.Ptr a -> GHC.Types.Int -> GHC.Types.IO (GHC.Internal.Ptr.Ptr a)

module Foreign.Marshal.Array where
  -- Safety: Safe
  advancePtr :: forall a. GHC.Internal.Foreign.Storable.Storable a => GHC.Internal.Ptr.Ptr a -> GHC.Types.Int -> GHC.Internal.Ptr.Ptr a
  allocaArray :: forall a b. GHC.Internal.Foreign.Storable.Storable a => GHC.Types.Int -> (GHC.Internal.Ptr.Ptr a -> GHC.Types.IO b) -> GHC.Types.IO b
  allocaArray0 :: forall a b. GHC.Internal.Foreign.Storable.Storable a => GHC.Types.Int -> (GHC.Internal.Ptr.Ptr a -> GHC.Types.IO b) -> GHC.Types.IO b
  callocArray :: forall a. GHC.Internal.Foreign.Storable.Storable a => GHC.Types.Int -> GHC.Types.IO (GHC.Internal.Ptr.Ptr a)
  callocArray0 :: forall a. GHC.Internal.Foreign.Storable.Storable a => GHC.Types.Int -> GHC.Types.IO (GHC.Internal.Ptr.Ptr a)
  copyArray :: forall a. GHC.Internal.Foreign.Storable.Storable a => GHC.Internal.Ptr.Ptr a -> GHC.Internal.Ptr.Ptr a -> GHC.Types.Int -> GHC.Types.IO ()
  lengthArray0 :: forall a. (GHC.Internal.Foreign.Storable.Storable a, GHC.Classes.Eq a) => a -> GHC.Internal.Ptr.Ptr a -> GHC.Types.IO GHC.Types.Int
  mallocArray :: forall a. GHC.Internal.Foreign.Storable.Storable a => GHC.Types.Int -> GHC.Types.IO (GHC.Internal.Ptr.Ptr a)
  mallocArray0 :: forall a. GHC.Internal.Foreign.Storable.Storable a => GHC.Types.Int -> GHC.Types.IO (GHC.Internal.Ptr.Ptr a)
  moveArray :: forall a. GHC.Internal.Foreign.Storable.Storable a => GHC.Internal.Ptr.Ptr a -> GHC.Internal.Ptr.Ptr a -> GHC.Types.Int -> GHC.Types.IO ()
  newArray :: forall a. GHC.Internal.Foreign.Storable.Storable a => [a] -> GHC.Types.IO (GHC.Internal.Ptr.Ptr a)
  newArray0 :: forall a. GHC.Internal.Foreign.Storable.Storable a => a -> [a] -> GHC.Types.IO (GHC.Internal.Ptr.Ptr a)
  peekArray :: forall a. GHC.Internal.Foreign.Storable.Storable a => GHC.Types.Int -> GHC.Internal.Ptr.Ptr a -> GHC.Types.IO [a]
  peekArray0 :: forall a. (GHC.Internal.Foreign.Storable.Storable a, GHC.Classes.Eq a) => a -> GHC.Internal.Ptr.Ptr a -> GHC.Types.IO [a]
  pokeArray :: forall a. GHC.Internal.Foreign.Storable.Storable a => GHC.Internal.Ptr.Ptr a -> [a] -> GHC.Types.IO ()
  pokeArray0 :: forall a. GHC.Internal.Foreign.Storable.Storable a => a -> GHC.Internal.Ptr.Ptr a -> [a] -> GHC.Types.IO ()
  reallocArray :: forall a. GHC.Internal.Foreign.Storable.Storable a => GHC.Internal.Ptr.Ptr a -> GHC.Types.Int -> GHC.Types.IO (GHC.Internal.Ptr.Ptr a)
  reallocArray0 :: forall a. GHC.Internal.Foreign.Storable.Storable a => GHC.Internal.Ptr.Ptr a -> GHC.Types.Int -> GHC.Types.IO (GHC.Internal.Ptr.Ptr a)
  withArray :: forall a b. GHC.Internal.Foreign.Storable.Storable a => [a] -> (GHC.Internal.Ptr.Ptr a -> GHC.Types.IO b) -> GHC.Types.IO b
  withArray0 :: forall a b. GHC.Internal.Foreign.Storable.Storable a => a -> [a] -> (GHC.Internal.Ptr.Ptr a -> GHC.Types.IO b) -> GHC.Types.IO b
  withArrayLen :: forall a b. GHC.Internal.Foreign.Storable.Storable a => [a] -> (GHC.Types.Int -> GHC.Internal.Ptr.Ptr a -> GHC.Types.IO b) -> GHC.Types.IO b
  withArrayLen0 :: forall a b. GHC.Internal.Foreign.Storable.Storable a => a -> [a] -> (GHC.Types.Int -> GHC.Internal.Ptr.Ptr a -> GHC.Types.IO b) -> GHC.Types.IO b

module Foreign.Marshal.Error where
  -- Safety: Safe
  throwIf :: forall a. (a -> GHC.Types.Bool) -> (a -> GHC.Internal.Base.String) -> GHC.Types.IO a -> GHC.Types.IO a
  throwIfNeg :: forall a. (GHC.Classes.Ord a, GHC.Internal.Num.Num a) => (a -> GHC.Internal.Base.String) -> GHC.Types.IO a -> GHC.Types.IO a
  throwIfNeg_ :: forall a. (GHC.Classes.Ord a, GHC.Internal.Num.Num a) => (a -> GHC.Internal.Base.String) -> GHC.Types.IO a -> GHC.Types.IO ()
  throwIfNull :: forall a. GHC.Internal.Base.String -> GHC.Types.IO (GHC.Internal.Ptr.Ptr a) -> GHC.Types.IO (GHC.Internal.Ptr.Ptr a)
  throwIf_ :: forall a. (a -> GHC.Types.Bool) -> (a -> GHC.Internal.Base.String) -> GHC.Types.IO a -> GHC.Types.IO ()
  void :: forall a. GHC.Types.IO a -> GHC.Types.IO ()

module Foreign.Marshal.Pool where
  -- Safety: Safe
  type Pool :: *
  newtype Pool = ...
  freePool :: Pool -> GHC.Types.IO ()
  newPool :: GHC.Types.IO Pool
  pooledMalloc :: forall a. GHC.Internal.Foreign.Storable.Storable a => Pool -> GHC.Types.IO (GHC.Internal.Ptr.Ptr a)
  pooledMallocArray :: forall a. GHC.Internal.Foreign.Storable.Storable a => Pool -> GHC.Types.Int -> GHC.Types.IO (GHC.Internal.Ptr.Ptr a)
  pooledMallocArray0 :: forall a. GHC.Internal.Foreign.Storable.Storable a => Pool -> GHC.Types.Int -> GHC.Types.IO (GHC.Internal.Ptr.Ptr a)
  pooledMallocBytes :: forall a. Pool -> GHC.Types.Int -> GHC.Types.IO (GHC.Internal.Ptr.Ptr a)
  pooledNew :: forall a. GHC.Internal.Foreign.Storable.Storable a => Pool -> a -> GHC.Types.IO (GHC.Internal.Ptr.Ptr a)
  pooledNewArray :: forall a. GHC.Internal.Foreign.Storable.Storable a => Pool -> [a] -> GHC.Types.IO (GHC.Internal.Ptr.Ptr a)
  pooledNewArray0 :: forall a. GHC.Internal.Foreign.Storable.Storable a => Pool -> a -> [a] -> GHC.Types.IO (GHC.Internal.Ptr.Ptr a)
  pooledRealloc :: forall a. GHC.Internal.Foreign.Storable.Storable a => Pool -> GHC.Internal.Ptr.Ptr a -> GHC.Types.IO (GHC.Internal.Ptr.Ptr a)
  pooledReallocArray :: forall a. GHC.Internal.Foreign.Storable.Storable a => Pool -> GHC.Internal.Ptr.Ptr a -> GHC.Types.Int -> GHC.Types.IO (GHC.Internal.Ptr.Ptr a)
  pooledReallocArray0 :: forall a. GHC.Internal.Foreign.Storable.Storable a => Pool -> GHC.Internal.Ptr.Ptr a -> GHC.Types.Int -> GHC.Types.IO (GHC.Internal.Ptr.Ptr a)
  pooledReallocBytes :: forall a. Pool -> GHC.Internal.Ptr.Ptr a -> GHC.Types.Int -> GHC.Types.IO (GHC.Internal.Ptr.Ptr a)
  withPool :: forall b. (Pool -> GHC.Types.IO b) -> GHC.Types.IO b

module Foreign.Marshal.Safe where
  -- Safety: Safe
  type Pool :: *
  newtype Pool = ...
  advancePtr :: forall a. GHC.Internal.Foreign.Storable.Storable a => GHC.Internal.Ptr.Ptr a -> GHC.Types.Int -> GHC.Internal.Ptr.Ptr a
  alloca :: forall a b. GHC.Internal.Foreign.Storable.Storable a => (GHC.Internal.Ptr.Ptr a -> GHC.Types.IO b) -> GHC.Types.IO b
  allocaArray :: forall a b. GHC.Internal.Foreign.Storable.Storable a => GHC.Types.Int -> (GHC.Internal.Ptr.Ptr a -> GHC.Types.IO b) -> GHC.Types.IO b
  allocaArray0 :: forall a b. GHC.Internal.Foreign.Storable.Storable a => GHC.Types.Int -> (GHC.Internal.Ptr.Ptr a -> GHC.Types.IO b) -> GHC.Types.IO b
  allocaBytes :: forall a b. GHC.Types.Int -> (GHC.Internal.Ptr.Ptr a -> GHC.Types.IO b) -> GHC.Types.IO b
  allocaBytesAligned :: forall a b. GHC.Types.Int -> GHC.Types.Int -> (GHC.Internal.Ptr.Ptr a -> GHC.Types.IO b) -> GHC.Types.IO b
  calloc :: forall a. GHC.Internal.Foreign.Storable.Storable a => GHC.Types.IO (GHC.Internal.Ptr.Ptr a)
  callocArray :: forall a. GHC.Internal.Foreign.Storable.Storable a => GHC.Types.Int -> GHC.Types.IO (GHC.Internal.Ptr.Ptr a)
  callocArray0 :: forall a. GHC.Internal.Foreign.Storable.Storable a => GHC.Types.Int -> GHC.Types.IO (GHC.Internal.Ptr.Ptr a)
  callocBytes :: forall a. GHC.Types.Int -> GHC.Types.IO (GHC.Internal.Ptr.Ptr a)
  copyArray :: forall a. GHC.Internal.Foreign.Storable.Storable a => GHC.Internal.Ptr.Ptr a -> GHC.Internal.Ptr.Ptr a -> GHC.Types.Int -> GHC.Types.IO ()
  copyBytes :: forall a. GHC.Internal.Ptr.Ptr a -> GHC.Internal.Ptr.Ptr a -> GHC.Types.Int -> GHC.Types.IO ()
  fillBytes :: forall a. GHC.Internal.Ptr.Ptr a -> GHC.Internal.Word.Word8 -> GHC.Types.Int -> GHC.Types.IO ()
  finalizerFree :: forall a. GHC.Internal.ForeignPtr.FinalizerPtr a
  free :: forall a. GHC.Internal.Ptr.Ptr a -> GHC.Types.IO ()
  freePool :: Pool -> GHC.Types.IO ()
  fromBool :: forall a. GHC.Internal.Num.Num a => GHC.Types.Bool -> a
  lengthArray0 :: forall a. (GHC.Internal.Foreign.Storable.Storable a, GHC.Classes.Eq a) => a -> GHC.Internal.Ptr.Ptr a -> GHC.Types.IO GHC.Types.Int
  malloc :: forall a. GHC.Internal.Foreign.Storable.Storable a => GHC.Types.IO (GHC.Internal.Ptr.Ptr a)
  mallocArray :: forall a. GHC.Internal.Foreign.Storable.Storable a => GHC.Types.Int -> GHC.Types.IO (GHC.Internal.Ptr.Ptr a)
  mallocArray0 :: forall a. GHC.Internal.Foreign.Storable.Storable a => GHC.Types.Int -> GHC.Types.IO (GHC.Internal.Ptr.Ptr a)
  mallocBytes :: forall a. GHC.Types.Int -> GHC.Types.IO (GHC.Internal.Ptr.Ptr a)
  maybeNew :: forall a b. (a -> GHC.Types.IO (GHC.Internal.Ptr.Ptr b)) -> GHC.Internal.Maybe.Maybe a -> GHC.Types.IO (GHC.Internal.Ptr.Ptr b)
  maybePeek :: forall a b. (GHC.Internal.Ptr.Ptr a -> GHC.Types.IO b) -> GHC.Internal.Ptr.Ptr a -> GHC.Types.IO (GHC.Internal.Maybe.Maybe b)
  maybeWith :: forall a b c. (a -> (GHC.Internal.Ptr.Ptr b -> GHC.Types.IO c) -> GHC.Types.IO c) -> GHC.Internal.Maybe.Maybe a -> (GHC.Internal.Ptr.Ptr b -> GHC.Types.IO c) -> GHC.Types.IO c
  moveArray :: forall a. GHC.Internal.Foreign.Storable.Storable a => GHC.Internal.Ptr.Ptr a -> GHC.Internal.Ptr.Ptr a -> GHC.Types.Int -> GHC.Types.IO ()
  moveBytes :: forall a. GHC.Internal.Ptr.Ptr a -> GHC.Internal.Ptr.Ptr a -> GHC.Types.Int -> GHC.Types.IO ()
  new :: forall a. GHC.Internal.Foreign.Storable.Storable a => a -> GHC.Types.IO (GHC.Internal.Ptr.Ptr a)
  newArray :: forall a. GHC.Internal.Foreign.Storable.Storable a => [a] -> GHC.Types.IO (GHC.Internal.Ptr.Ptr a)
  newArray0 :: forall a. GHC.Internal.Foreign.Storable.Storable a => a -> [a] -> GHC.Types.IO (GHC.Internal.Ptr.Ptr a)
  newPool :: GHC.Types.IO Pool
  peekArray :: forall a. GHC.Internal.Foreign.Storable.Storable a => GHC.Types.Int -> GHC.Internal.Ptr.Ptr a -> GHC.Types.IO [a]
  peekArray0 :: forall a. (GHC.Internal.Foreign.Storable.Storable a, GHC.Classes.Eq a) => a -> GHC.Internal.Ptr.Ptr a -> GHC.Types.IO [a]
  pokeArray :: forall a. GHC.Internal.Foreign.Storable.Storable a => GHC.Internal.Ptr.Ptr a -> [a] -> GHC.Types.IO ()
  pokeArray0 :: forall a. GHC.Internal.Foreign.Storable.Storable a => a -> GHC.Internal.Ptr.Ptr a -> [a] -> GHC.Types.IO ()
  pooledMalloc :: forall a. GHC.Internal.Foreign.Storable.Storable a => Pool -> GHC.Types.IO (GHC.Internal.Ptr.Ptr a)
  pooledMallocArray :: forall a. GHC.Internal.Foreign.Storable.Storable a => Pool -> GHC.Types.Int -> GHC.Types.IO (GHC.Internal.Ptr.Ptr a)
  pooledMallocArray0 :: forall a. GHC.Internal.Foreign.Storable.Storable a => Pool -> GHC.Types.Int -> GHC.Types.IO (GHC.Internal.Ptr.Ptr a)
  pooledMallocBytes :: forall a. Pool -> GHC.Types.Int -> GHC.Types.IO (GHC.Internal.Ptr.Ptr a)
  pooledNew :: forall a. GHC.Internal.Foreign.Storable.Storable a => Pool -> a -> GHC.Types.IO (GHC.Internal.Ptr.Ptr a)
  pooledNewArray :: forall a. GHC.Internal.Foreign.Storable.Storable a => Pool -> [a] -> GHC.Types.IO (GHC.Internal.Ptr.Ptr a)
  pooledNewArray0 :: forall a. GHC.Internal.Foreign.Storable.Storable a => Pool -> a -> [a] -> GHC.Types.IO (GHC.Internal.Ptr.Ptr a)
  pooledRealloc :: forall a. GHC.Internal.Foreign.Storable.Storable a => Pool -> GHC.Internal.Ptr.Ptr a -> GHC.Types.IO (GHC.Internal.Ptr.Ptr a)
  pooledReallocArray :: forall a. GHC.Internal.Foreign.Storable.Storable a => Pool -> GHC.Internal.Ptr.Ptr a -> GHC.Types.Int -> GHC.Types.IO (GHC.Internal.Ptr.Ptr a)
  pooledReallocArray0 :: forall a. GHC.Internal.Foreign.Storable.Storable a => Pool -> GHC.Internal.Ptr.Ptr a -> GHC.Types.Int -> GHC.Types.IO (GHC.Internal.Ptr.Ptr a)
  pooledReallocBytes :: forall a. Pool -> GHC.Internal.Ptr.Ptr a -> GHC.Types.Int -> GHC.Types.IO (GHC.Internal.Ptr.Ptr a)
  realloc :: forall a b. GHC.Internal.Foreign.Storable.Storable b => GHC.Internal.Ptr.Ptr a -> GHC.Types.IO (GHC.Internal.Ptr.Ptr b)
  reallocArray :: forall a. GHC.Internal.Foreign.Storable.Storable a => GHC.Internal.Ptr.Ptr a -> GHC.Types.Int -> GHC.Types.IO (GHC.Internal.Ptr.Ptr a)
  reallocArray0 :: forall a. GHC.Internal.Foreign.Storable.Storable a => GHC.Internal.Ptr.Ptr a -> GHC.Types.Int -> GHC.Types.IO (GHC.Internal.Ptr.Ptr a)
  reallocBytes :: forall a. GHC.Internal.Ptr.Ptr a -> GHC.Types.Int -> GHC.Types.IO (GHC.Internal.Ptr.Ptr a)
  throwIf :: forall a. (a -> GHC.Types.Bool) -> (a -> GHC.Internal.Base.String) -> GHC.Types.IO a -> GHC.Types.IO a
  throwIfNeg :: forall a. (GHC.Classes.Ord a, GHC.Internal.Num.Num a) => (a -> GHC.Internal.Base.String) -> GHC.Types.IO a -> GHC.Types.IO a
  throwIfNeg_ :: forall a. (GHC.Classes.Ord a, GHC.Internal.Num.Num a) => (a -> GHC.Internal.Base.String) -> GHC.Types.IO a -> GHC.Types.IO ()
  throwIfNull :: forall a. GHC.Internal.Base.String -> GHC.Types.IO (GHC.Internal.Ptr.Ptr a) -> GHC.Types.IO (GHC.Internal.Ptr.Ptr a)
  throwIf_ :: forall a. (a -> GHC.Types.Bool) -> (a -> GHC.Internal.Base.String) -> GHC.Types.IO a -> GHC.Types.IO ()
  toBool :: forall a. (GHC.Classes.Eq a, GHC.Internal.Num.Num a) => a -> GHC.Types.Bool
  void :: forall a. GHC.Types.IO a -> GHC.Types.IO ()
  with :: forall a b. GHC.Internal.Foreign.Storable.Storable a => a -> (GHC.Internal.Ptr.Ptr a -> GHC.Types.IO b) -> GHC.Types.IO b
  withArray :: forall a b. GHC.Internal.Foreign.Storable.Storable a => [a] -> (GHC.Internal.Ptr.Ptr a -> GHC.Types.IO b) -> GHC.Types.IO b
  withArray0 :: forall a b. GHC.Internal.Foreign.Storable.Storable a => a -> [a] -> (GHC.Internal.Ptr.Ptr a -> GHC.Types.IO b) -> GHC.Types.IO b
  withArrayLen :: forall a b. GHC.Internal.Foreign.Storable.Storable a => [a] -> (GHC.Types.Int -> GHC.Internal.Ptr.Ptr a -> GHC.Types.IO b) -> GHC.Types.IO b
  withArrayLen0 :: forall a b. GHC.Internal.Foreign.Storable.Storable a => a -> [a] -> (GHC.Types.Int -> GHC.Internal.Ptr.Ptr a -> GHC.Types.IO b) -> GHC.Types.IO b
  withMany :: forall a b res. (a -> (b -> res) -> res) -> [a] -> ([b] -> res) -> res
  withPool :: forall b. (Pool -> GHC.Types.IO b) -> GHC.Types.IO b

module Foreign.Marshal.Unsafe where
  -- Safety: None
  unsafeLocalState :: forall a. GHC.Types.IO a -> a

module Foreign.Marshal.Utils where
  -- Safety: Safe
  copyBytes :: forall a. GHC.Internal.Ptr.Ptr a -> GHC.Internal.Ptr.Ptr a -> GHC.Types.Int -> GHC.Types.IO ()
  fillBytes :: forall a. GHC.Internal.Ptr.Ptr a -> GHC.Internal.Word.Word8 -> GHC.Types.Int -> GHC.Types.IO ()
  fromBool :: forall a. GHC.Internal.Num.Num a => GHC.Types.Bool -> a
  maybeNew :: forall a b. (a -> GHC.Types.IO (GHC.Internal.Ptr.Ptr b)) -> GHC.Internal.Maybe.Maybe a -> GHC.Types.IO (GHC.Internal.Ptr.Ptr b)
  maybePeek :: forall a b. (GHC.Internal.Ptr.Ptr a -> GHC.Types.IO b) -> GHC.Internal.Ptr.Ptr a -> GHC.Types.IO (GHC.Internal.Maybe.Maybe b)
  maybeWith :: forall a b c. (a -> (GHC.Internal.Ptr.Ptr b -> GHC.Types.IO c) -> GHC.Types.IO c) -> GHC.Internal.Maybe.Maybe a -> (GHC.Internal.Ptr.Ptr b -> GHC.Types.IO c) -> GHC.Types.IO c
  moveBytes :: forall a. GHC.Internal.Ptr.Ptr a -> GHC.Internal.Ptr.Ptr a -> GHC.Types.Int -> GHC.Types.IO ()
  new :: forall a. GHC.Internal.Foreign.Storable.Storable a => a -> GHC.Types.IO (GHC.Internal.Ptr.Ptr a)
  toBool :: forall a. (GHC.Classes.Eq a, GHC.Internal.Num.Num a) => a -> GHC.Types.Bool
  with :: forall a b. GHC.Internal.Foreign.Storable.Storable a => a -> (GHC.Internal.Ptr.Ptr a -> GHC.Types.IO b) -> GHC.Types.IO b
  withMany :: forall a b res. (a -> (b -> res) -> res) -> [a] -> ([b] -> res) -> res

module Foreign.Ptr where
  -- Safety: Safe
  type role FunPtr phantom
  type FunPtr :: * -> *
  data FunPtr a = ...
  type IntPtr :: *
  newtype IntPtr = IntPtr GHC.Types.Int
  type role Ptr phantom
  type Ptr :: * -> *
  data Ptr a = ...
  type WordPtr :: *
  newtype WordPtr = WordPtr GHC.Types.Word
  alignPtr :: forall a. Ptr a -> GHC.Types.Int -> Ptr a
  castFunPtr :: forall a b. FunPtr a -> FunPtr b
  castFunPtrToPtr :: forall a b. FunPtr a -> Ptr b
  castPtr :: forall a b. Ptr a -> Ptr b
  castPtrToFunPtr :: forall a b. Ptr a -> FunPtr b
  freeHaskellFunPtr :: forall a. FunPtr a -> GHC.Types.IO ()
  intPtrToPtr :: forall a. IntPtr -> Ptr a
  minusPtr :: forall a b. Ptr a -> Ptr b -> GHC.Types.Int
  nullFunPtr :: forall a. FunPtr a
  nullPtr :: forall a. Ptr a
  plusPtr :: forall a b. Ptr a -> GHC.Types.Int -> Ptr b
  ptrToIntPtr :: forall a. Ptr a -> IntPtr
  ptrToWordPtr :: forall a. Ptr a -> WordPtr
  wordPtrToPtr :: forall a. WordPtr -> Ptr a

module Foreign.Safe where
  -- Safety: Safe
  (!<<.) :: forall a. Bits a => a -> Int -> a
  (!>>.) :: forall a. Bits a => a -> Int -> a
  (.<<.) :: forall a. Bits a => a -> Int -> a
  (.>>.) :: forall a. Bits a => a -> Int -> a
  (.^.) :: forall a. Bits a => a -> a -> a
  type And :: * -> *
  newtype And a = And {getAnd :: a}
  type Bits :: * -> Constraint
  class GHC.Classes.Eq a => Bits a where
    (.&.) :: a -> a -> a
    (.|.) :: a -> a -> a
    xor :: a -> a -> a
    complement :: a -> a
    shift :: a -> Int -> a
    rotate :: a -> Int -> a
    zeroBits :: a
    bit :: Int -> a
    setBit :: a -> Int -> a
    clearBit :: a -> Int -> a
    complementBit :: a -> Int -> a
    testBit :: a -> Int -> GHC.Types.Bool
    bitSizeMaybe :: a -> GHC.Internal.Maybe.Maybe Int
    bitSize :: a -> Int
    isSigned :: a -> GHC.Types.Bool
    shiftL :: a -> Int -> a
    unsafeShiftL :: a -> Int -> a
    shiftR :: a -> Int -> a
    unsafeShiftR :: a -> Int -> a
    rotateL :: a -> Int -> a
    rotateR :: a -> Int -> a
    popCount :: a -> Int
    {-# MINIMAL (.&.), (.|.), xor, complement, (shift | (shiftL, shiftR)), (rotate | (rotateL, rotateR)), bitSize, bitSizeMaybe, isSigned, testBit, bit, popCount #-}
  type FinalizerEnvPtr :: * -> * -> *
  type FinalizerEnvPtr env a = FunPtr (Ptr env -> Ptr a -> GHC.Types.IO ())
  type FinalizerPtr :: * -> *
  type FinalizerPtr a = FunPtr (Ptr a -> GHC.Types.IO ())
  type FiniteBits :: * -> Constraint
  class Bits b => FiniteBits b where
    finiteBitSize :: b -> Int
    countLeadingZeros :: b -> Int
    countTrailingZeros :: b -> Int
    {-# MINIMAL finiteBitSize #-}
  type role ForeignPtr phantom
  type ForeignPtr :: * -> *
  data ForeignPtr a = ...
  type role FunPtr phantom
  type FunPtr :: * -> *
  data FunPtr a = ...
  type Iff :: * -> *
  newtype Iff a = Iff {getIff :: a}
  type Int :: *
  data Int = ...
  type Int16 :: *
  data Int16 = ...
  type Int32 :: *
  data Int32 = ...
  type Int64 :: *
  data Int64 = ...
  type Int8 :: *
  data Int8 = ...
  type IntPtr :: *
  newtype IntPtr = IntPtr Int
  type Ior :: * -> *
  newtype Ior a = Ior {getIor :: a}
  type Pool :: *
  newtype Pool = ...
  type role Ptr phantom
  type Ptr :: * -> *
  data Ptr a = ...
  type StablePtr :: * -> *
  data StablePtr a = ...
  type Storable :: * -> Constraint
  class Storable a where
    sizeOf :: a -> Int
    alignment :: a -> Int
    peekElemOff :: Ptr a -> Int -> GHC.Types.IO a
    pokeElemOff :: Ptr a -> Int -> a -> GHC.Types.IO ()
    peekByteOff :: forall b. Ptr b -> Int -> GHC.Types.IO a
    pokeByteOff :: forall b. Ptr b -> Int -> a -> GHC.Types.IO ()
    peek :: Ptr a -> GHC.Types.IO a
    poke :: Ptr a -> a -> GHC.Types.IO ()
    {-# MINIMAL sizeOf, alignment, (peek | peekElemOff | peekByteOff), (poke | pokeElemOff | pokeByteOff) #-}
  type Word :: *
  data Word = ...
  type Word16 :: *
  data Word16 = ...
  type Word32 :: *
  data Word32 = ...
  type Word64 :: *
  data Word64 = ...
  type Word8 :: *
  data Word8 = ...
  type WordPtr :: *
  newtype WordPtr = WordPtr Word
  type Xor :: * -> *
  newtype Xor a = Xor {getXor :: a}
  addForeignPtrFinalizer :: forall a. FinalizerPtr a -> ForeignPtr a -> GHC.Types.IO ()
  addForeignPtrFinalizerEnv :: forall env a. FinalizerEnvPtr env a -> Ptr env -> ForeignPtr a -> GHC.Types.IO ()
  advancePtr :: forall a. Storable a => Ptr a -> Int -> Ptr a
  alignPtr :: forall a. Ptr a -> Int -> Ptr a
  alloca :: forall a b. Storable a => (Ptr a -> GHC.Types.IO b) -> GHC.Types.IO b
  allocaArray :: forall a b. Storable a => Int -> (Ptr a -> GHC.Types.IO b) -> GHC.Types.IO b
  allocaArray0 :: forall a b. Storable a => Int -> (Ptr a -> GHC.Types.IO b) -> GHC.Types.IO b
  allocaBytes :: forall a b. Int -> (Ptr a -> GHC.Types.IO b) -> GHC.Types.IO b
  allocaBytesAligned :: forall a b. Int -> Int -> (Ptr a -> GHC.Types.IO b) -> GHC.Types.IO b
  bitDefault :: forall a. (Bits a, GHC.Internal.Num.Num a) => Int -> a
  bitReverse16 :: Word16 -> Word16
  bitReverse32 :: Word32 -> Word32
  bitReverse64 :: Word64 -> Word64
  bitReverse8 :: Word8 -> Word8
  byteSwap16 :: Word16 -> Word16
  byteSwap32 :: Word32 -> Word32
  byteSwap64 :: Word64 -> Word64
  calloc :: forall a. Storable a => GHC.Types.IO (Ptr a)
  callocArray :: forall a. Storable a => Int -> GHC.Types.IO (Ptr a)
  callocArray0 :: forall a. Storable a => Int -> GHC.Types.IO (Ptr a)
  callocBytes :: forall a. Int -> GHC.Types.IO (Ptr a)
  castForeignPtr :: forall a b. ForeignPtr a -> ForeignPtr b
  castFunPtr :: forall a b. FunPtr a -> FunPtr b
  castFunPtrToPtr :: forall a b. FunPtr a -> Ptr b
  castPtr :: forall a b. Ptr a -> Ptr b
  castPtrToFunPtr :: forall a b. Ptr a -> FunPtr b
  castPtrToStablePtr :: forall a. Ptr () -> StablePtr a
  castStablePtrToPtr :: forall a. StablePtr a -> Ptr ()
  copyArray :: forall a. Storable a => Ptr a -> Ptr a -> Int -> GHC.Types.IO ()
  copyBytes :: forall a. Ptr a -> Ptr a -> Int -> GHC.Types.IO ()
  deRefStablePtr :: forall a. StablePtr a -> GHC.Types.IO a
  fillBytes :: forall a. Ptr a -> Word8 -> Int -> GHC.Types.IO ()
  finalizeForeignPtr :: forall a. ForeignPtr a -> GHC.Types.IO ()
  finalizerFree :: forall a. FinalizerPtr a
  free :: forall a. Ptr a -> GHC.Types.IO ()
  freeHaskellFunPtr :: forall a. FunPtr a -> GHC.Types.IO ()
  freePool :: Pool -> GHC.Types.IO ()
  freeStablePtr :: forall a. StablePtr a -> GHC.Types.IO ()
  fromBool :: forall a. GHC.Internal.Num.Num a => GHC.Types.Bool -> a
  intPtrToPtr :: forall a. IntPtr -> Ptr a
  lengthArray0 :: forall a. (Storable a, GHC.Classes.Eq a) => a -> Ptr a -> GHC.Types.IO Int
  malloc :: forall a. Storable a => GHC.Types.IO (Ptr a)
  mallocArray :: forall a. Storable a => Int -> GHC.Types.IO (Ptr a)
  mallocArray0 :: forall a. Storable a => Int -> GHC.Types.IO (Ptr a)
  mallocBytes :: forall a. Int -> GHC.Types.IO (Ptr a)
  mallocForeignPtr :: forall a. Storable a => GHC.Types.IO (ForeignPtr a)
  mallocForeignPtrArray :: forall a. Storable a => Int -> GHC.Types.IO (ForeignPtr a)
  mallocForeignPtrArray0 :: forall a. Storable a => Int -> GHC.Types.IO (ForeignPtr a)
  mallocForeignPtrBytes :: forall a. Int -> GHC.Types.IO (ForeignPtr a)
  maybeNew :: forall a b. (a -> GHC.Types.IO (Ptr b)) -> GHC.Internal.Maybe.Maybe a -> GHC.Types.IO (Ptr b)
  maybePeek :: forall a b. (Ptr a -> GHC.Types.IO b) -> Ptr a -> GHC.Types.IO (GHC.Internal.Maybe.Maybe b)
  maybeWith :: forall a b c. (a -> (Ptr b -> GHC.Types.IO c) -> GHC.Types.IO c) -> GHC.Internal.Maybe.Maybe a -> (Ptr b -> GHC.Types.IO c) -> GHC.Types.IO c
  minusPtr :: forall a b. Ptr a -> Ptr b -> Int
  moveArray :: forall a. Storable a => Ptr a -> Ptr a -> Int -> GHC.Types.IO ()
  moveBytes :: forall a. Ptr a -> Ptr a -> Int -> GHC.Types.IO ()
  new :: forall a. Storable a => a -> GHC.Types.IO (Ptr a)
  newArray :: forall a. Storable a => [a] -> GHC.Types.IO (Ptr a)
  newArray0 :: forall a. Storable a => a -> [a] -> GHC.Types.IO (Ptr a)
  newForeignPtr :: forall a. FinalizerPtr a -> Ptr a -> GHC.Types.IO (ForeignPtr a)
  newForeignPtrEnv :: forall env a. FinalizerEnvPtr env a -> Ptr env -> Ptr a -> GHC.Types.IO (ForeignPtr a)
  newForeignPtr_ :: forall a. Ptr a -> GHC.Types.IO (ForeignPtr a)
  newPool :: GHC.Types.IO Pool
  newStablePtr :: forall a. a -> GHC.Types.IO (StablePtr a)
  nullFunPtr :: forall a. FunPtr a
  nullPtr :: forall a. Ptr a
  oneBits :: forall a. FiniteBits a => a
  peekArray :: forall a. Storable a => Int -> Ptr a -> GHC.Types.IO [a]
  peekArray0 :: forall a. (Storable a, GHC.Classes.Eq a) => a -> Ptr a -> GHC.Types.IO [a]
  plusForeignPtr :: forall a b. ForeignPtr a -> Int -> ForeignPtr b
  plusPtr :: forall a b. Ptr a -> Int -> Ptr b
  pokeArray :: forall a. Storable a => Ptr a -> [a] -> GHC.Types.IO ()
  pokeArray0 :: forall a. Storable a => a -> Ptr a -> [a] -> GHC.Types.IO ()
  pooledMalloc :: forall a. Storable a => Pool -> GHC.Types.IO (Ptr a)
  pooledMallocArray :: forall a. Storable a => Pool -> Int -> GHC.Types.IO (Ptr a)
  pooledMallocArray0 :: forall a. Storable a => Pool -> Int -> GHC.Types.IO (Ptr a)
  pooledMallocBytes :: forall a. Pool -> Int -> GHC.Types.IO (Ptr a)
  pooledNew :: forall a. Storable a => Pool -> a -> GHC.Types.IO (Ptr a)
  pooledNewArray :: forall a. Storable a => Pool -> [a] -> GHC.Types.IO (Ptr a)
  pooledNewArray0 :: forall a. Storable a => Pool -> a -> [a] -> GHC.Types.IO (Ptr a)
  pooledRealloc :: forall a. Storable a => Pool -> Ptr a -> GHC.Types.IO (Ptr a)
  pooledReallocArray :: forall a. Storable a => Pool -> Ptr a -> Int -> GHC.Types.IO (Ptr a)
  pooledReallocArray0 :: forall a. Storable a => Pool -> Ptr a -> Int -> GHC.Types.IO (Ptr a)
  pooledReallocBytes :: forall a. Pool -> Ptr a -> Int -> GHC.Types.IO (Ptr a)
  popCountDefault :: forall a. (Bits a, GHC.Internal.Num.Num a) => a -> Int
  ptrToIntPtr :: forall a. Ptr a -> IntPtr
  ptrToWordPtr :: forall a. Ptr a -> WordPtr
  realloc :: forall a b. Storable b => Ptr a -> GHC.Types.IO (Ptr b)
  reallocArray :: forall a. Storable a => Ptr a -> Int -> GHC.Types.IO (Ptr a)
  reallocArray0 :: forall a. Storable a => Ptr a -> Int -> GHC.Types.IO (Ptr a)
  reallocBytes :: forall a. Ptr a -> Int -> GHC.Types.IO (Ptr a)
  testBitDefault :: forall a. (Bits a, GHC.Internal.Num.Num a) => a -> Int -> GHC.Types.Bool
  throwIf :: forall a. (a -> GHC.Types.Bool) -> (a -> GHC.Internal.Base.String) -> GHC.Types.IO a -> GHC.Types.IO a
  throwIfNeg :: forall a. (GHC.Classes.Ord a, GHC.Internal.Num.Num a) => (a -> GHC.Internal.Base.String) -> GHC.Types.IO a -> GHC.Types.IO a
  throwIfNeg_ :: forall a. (GHC.Classes.Ord a, GHC.Internal.Num.Num a) => (a -> GHC.Internal.Base.String) -> GHC.Types.IO a -> GHC.Types.IO ()
  throwIfNull :: forall a. GHC.Internal.Base.String -> GHC.Types.IO (Ptr a) -> GHC.Types.IO (Ptr a)
  throwIf_ :: forall a. (a -> GHC.Types.Bool) -> (a -> GHC.Internal.Base.String) -> GHC.Types.IO a -> GHC.Types.IO ()
  toBool :: forall a. (GHC.Classes.Eq a, GHC.Internal.Num.Num a) => a -> GHC.Types.Bool
  toIntegralSized :: forall a b. (GHC.Internal.Real.Integral a, GHC.Internal.Real.Integral b, Bits a, Bits b) => a -> GHC.Internal.Maybe.Maybe b
  touchForeignPtr :: forall a. ForeignPtr a -> GHC.Types.IO ()
  void :: forall a. GHC.Types.IO a -> GHC.Types.IO ()
  with :: forall a b. Storable a => a -> (Ptr a -> GHC.Types.IO b) -> GHC.Types.IO b
  withArray :: forall a b. Storable a => [a] -> (Ptr a -> GHC.Types.IO b) -> GHC.Types.IO b
  withArray0 :: forall a b. Storable a => a -> [a] -> (Ptr a -> GHC.Types.IO b) -> GHC.Types.IO b
  withArrayLen :: forall a b. Storable a => [a] -> (Int -> Ptr a -> GHC.Types.IO b) -> GHC.Types.IO b
  withArrayLen0 :: forall a b. Storable a => a -> [a] -> (Int -> Ptr a -> GHC.Types.IO b) -> GHC.Types.IO b
  withForeignPtr :: forall a b. ForeignPtr a -> (Ptr a -> GHC.Types.IO b) -> GHC.Types.IO b
  withMany :: forall a b res. (a -> (b -> res) -> res) -> [a] -> ([b] -> res) -> res
  withPool :: forall b. (Pool -> GHC.Types.IO b) -> GHC.Types.IO b
  wordPtrToPtr :: forall a. WordPtr -> Ptr a

module Foreign.StablePtr where
  -- Safety: Safe
  type StablePtr :: * -> *
  data StablePtr a = ...
  castPtrToStablePtr :: forall a. GHC.Internal.Ptr.Ptr () -> StablePtr a
  castStablePtrToPtr :: forall a. StablePtr a -> GHC.Internal.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 Foreign.Storable where
  -- Safety: Safe
  type Storable :: * -> Constraint
  class Storable a where
    sizeOf :: a -> GHC.Types.Int
    alignment :: a -> GHC.Types.Int
    peekElemOff :: GHC.Internal.Ptr.Ptr a -> GHC.Types.Int -> GHC.Types.IO a
    pokeElemOff :: GHC.Internal.Ptr.Ptr a -> GHC.Types.Int -> a -> GHC.Types.IO ()
    peekByteOff :: forall b. GHC.Internal.Ptr.Ptr b -> GHC.Types.Int -> GHC.Types.IO a
    pokeByteOff :: forall b. GHC.Internal.Ptr.Ptr b -> GHC.Types.Int -> a -> GHC.Types.IO ()
    peek :: GHC.Internal.Ptr.Ptr a -> GHC.Types.IO a
    poke :: GHC.Internal.Ptr.Ptr a -> a -> GHC.Types.IO ()
    {-# MINIMAL sizeOf, alignment, (peek | peekElemOff | peekByteOff), (poke | pokeElemOff | pokeByteOff) #-}

module GHC.Arr where
  -- Safety: None
  (!) :: forall i e. Ix i => Array i e -> i -> e
  (//) :: forall i e. Ix i => Array i e -> [(i, e)] -> Array i e
  type role Array nominal representational
  type Array :: * -> * -> *
  data Array i e = Array !i !i {-# UNPACK #-}GHC.Types.Int (GHC.Prim.Array# e)
  type Ix :: * -> Constraint
  class GHC.Classes.Ord a => Ix a where
    range :: (a, a) -> [a]
    index :: (a, a) -> a -> GHC.Types.Int
    unsafeIndex :: (a, a) -> a -> GHC.Types.Int
    inRange :: (a, a) -> a -> GHC.Types.Bool
    rangeSize :: (a, a) -> GHC.Types.Int
    unsafeRangeSize :: (a, a) -> GHC.Types.Int
    {-# MINIMAL range, (index | unsafeIndex), inRange #-}
  type role STArray nominal nominal representational
  type STArray :: * -> * -> * -> *
  data STArray s i e = STArray !i !i {-# UNPACK #-}GHC.Types.Int (GHC.Prim.MutableArray# s e)
  accum :: forall i e a. Ix i => (e -> a -> e) -> Array i e -> [(i, a)] -> Array i e
  accumArray :: forall i e a. Ix i => (e -> a -> e) -> e -> (i, i) -> [(i, a)] -> Array i e
  adjust :: forall e a s b. (e -> a -> e) -> GHC.Prim.MutableArray# s e -> (GHC.Types.Int, a) -> GHC.Internal.ST.STRep s b -> GHC.Internal.ST.STRep s b
  amap :: forall a b i. (a -> b) -> Array i a -> Array i b
  arrEleBottom :: forall a. a
  array :: forall i e. Ix i => (i, i) -> [(i, e)] -> Array i e
  assocs :: forall i e. Ix i => Array i e -> [(i, e)]
  badSafeIndex :: GHC.Types.Int -> GHC.Types.Int -> GHC.Types.Int
  bounds :: forall i e. Array i e -> (i, i)
  boundsSTArray :: forall s i e. STArray s i e -> (i, i)
  cmpArray :: forall i e. (Ix i, GHC.Classes.Ord e) => Array i e -> Array i e -> GHC.Types.Ordering
  cmpIntArray :: forall e. GHC.Classes.Ord e => Array GHC.Types.Int e -> Array GHC.Types.Int e -> GHC.Types.Ordering
  done :: forall i s e. i -> i -> GHC.Types.Int -> GHC.Prim.MutableArray# s e -> GHC.Internal.ST.STRep s (Array i e)
  elems :: forall i e. Array i e -> [e]
  eqArray :: forall i e. (Ix i, GHC.Classes.Eq e) => Array i e -> Array i e -> GHC.Types.Bool
  fill :: forall s e a. GHC.Prim.MutableArray# s e -> (GHC.Types.Int, e) -> GHC.Internal.ST.STRep s a -> GHC.Internal.ST.STRep s a
  foldl1Elems :: forall a i. (a -> a -> a) -> Array i a -> a
  foldlElems :: forall b a i. (b -> a -> b) -> b -> Array i a -> b
  foldlElems' :: forall b a i. (b -> a -> b) -> b -> Array i a -> b
  foldr1Elems :: forall a i. (a -> a -> a) -> Array i a -> a
  foldrElems :: forall a b i. (a -> b -> b) -> b -> Array i a -> b
  foldrElems' :: forall a b i. (a -> b -> b) -> b -> Array i a -> b
  freezeSTArray :: forall s i e. STArray s i e -> GHC.Internal.ST.ST s (Array i e)
  indices :: forall i e. Ix i => Array i e -> [i]
  ixmap :: forall i j e. (Ix i, Ix j) => (i, i) -> (i -> j) -> Array j e -> Array i e
  lessSafeIndex :: forall i. Ix i => (i, i) -> GHC.Types.Int -> i -> GHC.Types.Int
  listArray :: forall i e. Ix i => (i, i) -> [e] -> Array i e
  negRange :: GHC.Types.Int
  newSTArray :: forall i e s. Ix i => (i, i) -> e -> GHC.Internal.ST.ST s (STArray s i e)
  numElements :: forall i e. Array i e -> GHC.Types.Int
  numElementsSTArray :: forall s i e. STArray s i e -> GHC.Types.Int
  readSTArray :: forall i s e. Ix i => STArray s i e -> i -> GHC.Internal.ST.ST s e
  safeIndex :: forall i. Ix i => (i, i) -> GHC.Types.Int -> i -> GHC.Types.Int
  safeRangeSize :: forall i. Ix i => (i, i) -> GHC.Types.Int
  thawSTArray :: forall i e s. Array i e -> GHC.Internal.ST.ST s (STArray s i e)
  unsafeAccum :: forall e a i. (e -> a -> e) -> Array i e -> [(GHC.Types.Int, a)] -> Array i e
  unsafeAccumArray :: forall i e a. Ix i => (e -> a -> e) -> e -> (i, i) -> [(GHC.Types.Int, a)] -> Array i e
  unsafeAccumArray' :: forall e a i. (e -> a -> e) -> e -> (i, i) -> GHC.Types.Int -> [(GHC.Types.Int, a)] -> Array i e
  unsafeArray :: forall i e. Ix i => (i, i) -> [(GHC.Types.Int, e)] -> Array i e
  unsafeArray' :: forall i e. (i, i) -> GHC.Types.Int -> [(GHC.Types.Int, e)] -> Array i e
  unsafeAt :: forall i e. Array i e -> GHC.Types.Int -> e
  unsafeFreezeSTArray :: forall s i e. STArray s i e -> GHC.Internal.ST.ST s (Array i e)
  unsafeReadSTArray :: forall s i e. STArray s i e -> GHC.Types.Int -> GHC.Internal.ST.ST s e
  unsafeReplace :: forall i e. Array i e -> [(GHC.Types.Int, e)] -> Array i e
  unsafeThawSTArray :: forall i e s. Array i e -> GHC.Internal.ST.ST s (STArray s i e)
  unsafeWriteSTArray :: forall s i e. STArray s i e -> GHC.Types.Int -> e -> GHC.Internal.ST.ST s ()
  writeSTArray :: forall i s e. Ix i => STArray s i e -> i -> e -> GHC.Internal.ST.ST s ()

module GHC.ArrayArray where
  -- Safety: Safe
  type ArrayArray# :: GHC.Types.UnliftedType
  newtype ArrayArray# = ArrayArray# (GHC.Prim.Array# GHC.Prim.ByteArray#)
  type role MutableArrayArray# nominal
  type MutableArrayArray# :: * -> GHC.Types.UnliftedType
  newtype MutableArrayArray# s = MutableArrayArray# (GHC.Prim.MutableArray# s GHC.Prim.ByteArray#)
  copyArrayArray# :: forall s. ArrayArray# -> GHC.Prim.Int# -> MutableArrayArray# s -> GHC.Prim.Int# -> GHC.Prim.Int# -> GHC.Prim.State# s -> GHC.Prim.State# s
  copyMutableArrayArray# :: forall s. MutableArrayArray# s -> GHC.Prim.Int# -> MutableArrayArray# s -> GHC.Prim.Int# -> GHC.Prim.Int# -> GHC.Prim.State# s -> GHC.Prim.State# s
  indexArrayArrayArray# :: ArrayArray# -> GHC.Prim.Int# -> ArrayArray#
  indexByteArrayArray# :: ArrayArray# -> GHC.Prim.Int# -> GHC.Prim.ByteArray#
  newArrayArray# :: forall s. GHC.Prim.Int# -> GHC.Prim.State# s -> (# GHC.Prim.State# s, MutableArrayArray# s #)
  readArrayArrayArray# :: forall s. MutableArrayArray# s -> GHC.Prim.Int# -> GHC.Prim.State# s -> (# GHC.Prim.State# s, ArrayArray# #)
  readByteArrayArray# :: forall s. MutableArrayArray# s -> GHC.Prim.Int# -> GHC.Prim.State# s -> (# GHC.Prim.State# s, GHC.Prim.ByteArray# #)
  readMutableArrayArrayArray# :: forall s. MutableArrayArray# s -> GHC.Prim.Int# -> GHC.Prim.State# s -> (# GHC.Prim.State# s, MutableArrayArray# s #)
  readMutableByteArrayArray# :: forall s. MutableArrayArray# s -> GHC.Prim.Int# -> GHC.Prim.State# s -> (# GHC.Prim.State# s, GHC.Prim.MutableByteArray# s #)
  sameArrayArray# :: ArrayArray# -> ArrayArray# -> GHC.Prim.Int#
  sameMutableArrayArray# :: forall s. MutableArrayArray# s -> MutableArrayArray# s -> GHC.Prim.Int#
  sizeofArrayArray# :: ArrayArray# -> GHC.Prim.Int#
  sizeofMutableArrayArray# :: forall s. MutableArrayArray# s -> GHC.Prim.Int#
  unsafeFreezeArrayArray# :: forall s. MutableArrayArray# s -> GHC.Prim.State# s -> (# GHC.Prim.State# s, ArrayArray# #)
  writeArrayArrayArray# :: forall s. MutableArrayArray# s -> GHC.Prim.Int# -> ArrayArray# -> GHC.Prim.State# s -> GHC.Prim.State# s
  writeByteArrayArray# :: forall s. MutableArrayArray# s -> GHC.Prim.Int# -> GHC.Prim.ByteArray# -> GHC.Prim.State# s -> GHC.Prim.State# s
  writeMutableArrayArrayArray# :: forall s. MutableArrayArray# s -> GHC.Prim.Int# -> MutableArrayArray# s -> GHC.Prim.State# s -> GHC.Prim.State# s
  writeMutableByteArrayArray# :: forall s. MutableArrayArray# s -> GHC.Prim.Int# -> GHC.Prim.MutableByteArray# s -> GHC.Prim.State# s -> GHC.Prim.State# s

module GHC.Base where
  -- Safety: None
  ($) :: forall (repa :: RuntimeRep) (repb :: RuntimeRep) (a :: TYPE repa) (b :: TYPE repb). (a -> b) -> a -> b
  ($!) :: forall (r :: RuntimeRep) a (b :: TYPE r). (a -> b) -> a -> b
  (&&) :: Bool -> Bool -> Bool
  (*#) :: Int# -> Int# -> Int#
  (*##) :: Double# -> Double# -> Double#
  (**##) :: Double# -> Double# -> Double#
  (+#) :: Int# -> Int# -> Int#
  (+##) :: Double# -> Double# -> Double#
  (++) :: forall a. [a] -> [a] -> [a]
  (-#) :: Int# -> Int# -> Int#
  (-##) :: Double# -> Double# -> Double#
  (.) :: forall b c a. (b -> c) -> (a -> b) -> a -> c
  (/##) :: Double# -> Double# -> Double#
  (/=#) :: Int# -> Int# -> Int#
  (/=##) :: Double# -> Double# -> Int#
  (<#) :: Int# -> Int# -> Int#
  (<##) :: Double# -> Double# -> Int#
  (<**>) :: forall (f :: * -> *) a b. Applicative f => f a -> f (a -> b) -> f b
  (<=#) :: Int# -> Int# -> Int#
  (<=##) :: Double# -> Double# -> Int#
  (=<<) :: forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
  (==#) :: 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 Alternative :: (* -> *) -> Constraint
  class Applicative f => Alternative f where
    empty :: forall a. f a
    (<|>) :: forall a. f a -> f a -> f a
    some :: forall a. f a -> f [a]
    many :: forall a. f a -> f [a]
    {-# MINIMAL empty, (<|>) #-}
  type Any :: forall k. k
  type family Any where
  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 Array# :: forall {l :: Levity}. TYPE (BoxedRep l) -> UnliftedType
  data Array# a
  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 DataToTag :: forall {lev :: Levity}. TYPE (BoxedRep lev) -> Constraint
  class DataToTag a where
    dataToTag# :: a -> Int#
    {-# MINIMAL dataToTag# #-}
  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 Eq :: * -> Constraint
  class Eq a where
    (==) :: a -> a -> Bool
    (/=) :: a -> a -> Bool
    {-# MINIMAL (==) | (/=) #-}
  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 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 = IO (State# RealWorld -> (# State# RealWorld, a #))
  type role IOPort# nominal representational
  type IOPort# :: forall {l :: Levity}. * -> TYPE (BoxedRep l) -> UnliftedType
  data IOPort# a b
  type IP :: Symbol -> * -> Constraint
  class IP x a | x -> a where
    ip :: a
    {-# MINIMAL ip #-}
  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 KindBndr :: *
  type KindBndr = Int
  type KindRep :: *
  data KindRep = KindRepTyConApp TyCon [KindRep] | KindRepVar {-# UNPACK #-}KindBndr | KindRepApp KindRep KindRep | KindRepFun KindRep KindRep | KindRepTYPE !RuntimeRep | KindRepTypeLitS TypeLitSort Addr# | KindRepTypeLitD TypeLitSort [Char]
  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 Maybe :: * -> *
  data Maybe a = Nothing | Just a
  type Module :: *
  data Module = Module TrName TrName
  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 MonadPlus :: (* -> *) -> Constraint
  class (Alternative m, Monad m) => MonadPlus m where
    mzero :: forall a. m a
    mplus :: forall a. m a -> m a -> m a
    {-# MINIMAL #-}
  type Monoid :: * -> Constraint
  class Semigroup a => Monoid a where
    mempty :: a
    mappend :: a -> a -> a
    mconcat :: [a] -> a
    {-# MINIMAL mempty | mconcat #-}
  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 MutableByteArray# nominal
  type MutableByteArray# :: * -> UnliftedType
  data MutableByteArray# a
  type NonEmpty :: * -> *
  data NonEmpty a = a :| [a]
  type Opaque :: *
  data Opaque = forall a. O a
  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 PromptTag# :: * -> UnliftedType
  data PromptTag# a
  type role Proxy# phantom
  type Proxy# :: forall k. k -> ZeroBitType
  data Proxy# a
  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 Semigroup :: * -> Constraint
  class Semigroup a where
    (<>) :: a -> a -> a
    sconcat :: NonEmpty a -> a
    stimes :: forall b. GHC.Internal.Real.Integral b => b -> a -> a
    {-# MINIMAL (<>) | sconcat #-}
  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 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 String :: *
  type String = [Char]
  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#
  type TrName :: *
  data TrName = TrNameS Addr# | TrNameD [Char]
  type TyCon :: *
  data TyCon = TyCon Word64# Word64# Module TrName Int# KindRep
  type Type :: *
  type Type = TYPE LiftedRep
  type TypeLitSort :: *
  data TypeLitSort = TypeLitSymbol | TypeLitNat | TypeLitChar
  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 :: *
  data Void
  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
  absentErr :: forall a. a
  absurd :: forall a. Void -> a
  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# #)
  ap :: forall (m :: * -> *) a b. Monad m => m (a -> b) -> m a -> m b
  asTypeOf :: forall a. a -> a -> a
  asinDouble# :: Double# -> Double#
  asinFloat# :: Float# -> Float#
  asinhDouble# :: Double# -> Double#
  asinhFloat# :: Float# -> Float#
  assert :: forall a. Bool -> a -> a
  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# #)
  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]
  bindIO :: forall a b. IO a -> (a -> IO b) -> IO b
  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 #)
  castDoubleToWord64# :: Double# -> Word64#
  castFloatToWord32# :: Float# -> Word32#
  castWord32ToFloat# :: Word32# -> Float#
  castWord64ToDouble# :: Word64# -> Double#
  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#
  compareInt :: Int -> Int -> Ordering
  compareInt# :: Int# -> Int# -> Ordering
  compareWord :: Word -> Word -> Ordering
  compareWord# :: Word# -> Word# -> Ordering
  const :: forall a b. a -> b -> a
  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
  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
  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#
  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
  divInt :: Int -> Int -> Int
  divInt# :: Int# -> Int# -> Int#
  divInt16# :: Int16# -> Int16# -> Int16#
  divInt32# :: Int32# -> Int32# -> Int32#
  divInt8# :: Int8# -> Int8# -> Int8#
  divModInt :: Int -> Int -> (Int, Int)
  divModInt# :: Int# -> Int# -> (# Int#, Int# #)
  divModInt16# :: Int16# -> Int16# -> (# Int16#, Int16# #)
  divModInt32# :: Int32# -> Int32# -> (# Int32#, Int32# #)
  divModInt8# :: Int8# -> Int8# -> (# Int8#, Int8# #)
  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 -> Bool
  eqChar# :: Char# -> Char# -> Int#
  eqDouble :: Double -> Double -> Bool
  eqFloat :: Float -> Float -> Bool
  eqFloat# :: Float# -> Float# -> Int#
  eqInt :: Int -> Int -> Bool
  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#
  eqString :: String -> String -> Bool
  eqWord :: Word -> Word -> Bool
  eqWord# :: Word# -> Word# -> Int#
  eqWord16# :: Word16# -> Word16# -> Int#
  eqWord32# :: Word32# -> Word32# -> Int#
  eqWord64# :: Word64# -> Word64# -> Int#
  eqWord8# :: Word8# -> Word8# -> Int#
  error :: forall (r :: RuntimeRep) (a :: TYPE r). GHC.Internal.Stack.Types.HasCallStack => [Char] -> a
  errorWithoutStackTrace :: forall (r :: RuntimeRep) (a :: TYPE r). [Char] -> a
  expDouble# :: Double# -> Double#
  expFloat# :: Float# -> Float#
  expm1Double# :: Double# -> Double#
  expm1Float# :: Float# -> Float#
  fabsDouble# :: Double# -> Double#
  fabsFloat# :: Float# -> Float#
  failIO :: forall a. String -> IO a
  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 #) #)
  flip :: forall a b c. (a -> b -> c) -> b -> a -> c
  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#
  foldr :: forall a b. (a -> b -> b) -> b -> [a] -> b
  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#
  geInt :: Int -> Int -> Bool
  geInt16# :: Int16# -> Int16# -> Int#
  geInt32# :: Int32# -> Int32# -> Int#
  geInt64# :: Int64# -> Int64# -> Int#
  geInt8# :: Int8# -> Int8# -> Int#
  geWord :: Word -> Word -> Bool
  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 #)
  getTag :: forall {lev :: Levity} (a :: TYPE (BoxedRep lev)). DataToTag a => a -> Int#
  getThreadAllocationCounter# :: State# RealWorld -> (# State# RealWorld, Int64# #)
  gtAddr# :: Addr# -> Addr# -> Int#
  gtChar# :: Char# -> Char# -> Int#
  gtFloat# :: Float# -> Float# -> Int#
  gtInt :: Int -> Int -> Bool
  gtInt16# :: Int16# -> Int16# -> Int#
  gtInt32# :: Int32# -> Int32# -> Int#
  gtInt64# :: Int64# -> Int64# -> Int#
  gtInt8# :: Int8# -> Int8# -> Int#
  gtWord :: Word -> Word -> Bool
  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#
  id :: forall a. a -> a
  indexAddrArray# :: ByteArray# -> Int# -> Addr#
  indexAddrOffAddr# :: Addr# -> Int# -> Addr#
  indexArray# :: forall {l :: Levity} (a :: TYPE (BoxedRep l)). Array# a -> Int# -> (# a #)
  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#
  indexWord8OffAddrAsAddr# :: Addr# -> Int# -> Addr#
  indexWord8OffAddrAsChar# :: Addr# -> Int# -> Char#
  indexWord8OffAddrAsDouble# :: Addr# -> Int# -> Double#
  indexWord8OffAddrAsFloat# :: Addr# -> Int# -> Float#
  indexWord8OffAddrAsInt# :: Addr# -> Int# -> Int#
  indexWord8OffAddrAsInt16# :: Addr# -> Int# -> Int16#
  indexWord8OffAddrAsInt32# :: Addr# -> Int# -> Int32#
  indexWord8OffAddrAsInt64# :: Addr# -> Int# -> Int64#
  indexWord8OffAddrAsStablePtr# :: forall a. Addr# -> Int# -> StablePtr# a
  indexWord8OffAddrAsWideChar# :: Addr# -> Int# -> Char#
  indexWord8OffAddrAsWord# :: Addr# -> Int# -> Word#
  indexWord8OffAddrAsWord16# :: Addr# -> Int# -> Word16#
  indexWord8OffAddrAsWord32# :: Addr# -> Int# -> Word32#
  indexWord8OffAddrAsWord64# :: Addr# -> Int# -> Word64#
  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
  join :: forall (m :: * -> *) a. Monad m => m (m a) -> m a
  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#
  leInt :: Int -> Int -> Bool
  leInt16# :: Int16# -> Int16# -> Int#
  leInt32# :: Int32# -> Int32# -> Int#
  leInt64# :: Int64# -> Int64# -> Int#
  leInt8# :: Int8# -> Int8# -> Int#
  leWord :: Word -> Word -> Bool
  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
  liftA :: forall (f :: * -> *) a b. Applicative f => (a -> b) -> f a -> f b
  liftA3 :: forall (f :: * -> *) a b c d. Applicative f => (a -> b -> c -> d) -> f a -> f b -> f c -> f d
  liftM :: forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
  liftM2 :: forall (m :: * -> *) a1 a2 r. Monad m => (a1 -> a2 -> r) -> m a1 -> m a2 -> m r
  liftM3 :: forall (m :: * -> *) a1 a2 a3 r. Monad m => (a1 -> a2 -> a3 -> r) -> m a1 -> m a2 -> m a3 -> m r
  liftM4 :: forall (m :: * -> *) a1 a2 a3 a4 r. Monad m => (a1 -> a2 -> a3 -> a4 -> r) -> m a1 -> m a2 -> m a3 -> m a4 -> m r
  liftM5 :: forall (m :: * -> *) a1 a2 a3 a4 a5 r. Monad m => (a1 -> a2 -> a3 -> a4 -> a5 -> r) -> m a1 -> m a2 -> m a3 -> m a4 -> m a5 -> m r
  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#
  ltInt :: Int -> Int -> Bool
  ltInt16# :: Int16# -> Int16# -> Int#
  ltInt32# :: Int32# -> Int32# -> Int#
  ltInt64# :: Int64# -> Int64# -> Int#
  ltInt8# :: Int8# -> Int8# -> Int#
  ltWord :: Word -> Word -> Bool
  ltWord# :: Word# -> Word# -> Int#
  ltWord16# :: Word16# -> Word16# -> Int#
  ltWord32# :: Word32# -> Word32# -> Int#
  ltWord64# :: Word64# -> Word64# -> Int#
  ltWord8# :: Word8# -> Word8# -> Int#
  makeStableName# :: forall {l :: Levity} (a :: TYPE (BoxedRep l)). a -> State# RealWorld -> (# State# RealWorld, StableName# a #)
  makeStablePtr# :: forall {l :: Levity} (a :: TYPE (BoxedRep l)). a -> State# RealWorld -> (# State# RealWorld, StablePtr# a #)
  map :: forall a b. (a -> b) -> [a] -> [b]
  mapFB :: forall elt lst a. (elt -> lst -> lst) -> (a -> elt) -> a -> lst -> lst
  mapM :: forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
  maskAsyncExceptions# :: forall {q :: RuntimeRep} (a :: TYPE q). (State# RealWorld -> (# State# RealWorld, a #)) -> State# RealWorld -> (# State# RealWorld, a #)
  maskUninterruptible# :: forall {q :: RuntimeRep} (a :: TYPE q). (State# RealWorld -> (# State# RealWorld, a #)) -> State# RealWorld -> (# State# RealWorld, a #)
  maxInt :: Int
  minInt :: Int
  minusAddr# :: Addr# -> Addr# -> Int#
  minusDoubleX2# :: DoubleX2# -> DoubleX2# -> DoubleX2#
  minusDoubleX4# :: DoubleX4# -> DoubleX4# -> DoubleX4#
  minusDoubleX8# :: DoubleX8# -> DoubleX8# -> DoubleX8#
  minusFloat# :: Float# -> Float# -> Float#
  minusFloatX16# :: FloatX16# -> FloatX16# -> FloatX16#
  minusFloatX4# :: FloatX4# -> FloatX4# -> FloatX4#
  minusFloatX8# :: FloatX8# -> FloatX8# -> FloatX8#
  minusInt16X16# :: Int16X16# -> Int16X16# -> Int16X16#
  minusInt16X32# :: Int16X32# -> Int16X32# -> Int16X32#
  minusInt16X8# :: Int16X8# -> Int16X8# -> Int16X8#
  minusInt32X16# :: Int32X16# -> Int32X16# -> Int32X16#
  minusInt32X4# :: Int32X4# -> Int32X4# -> Int32X4#
  minusInt32X8# :: Int32X8# -> Int32X8# -> Int32X8#
  minusInt64X2# :: Int64X2# -> Int64X2# -> Int64X2#
  minusInt64X4# :: Int64X4# -> Int64X4# -> Int64X4#
  minusInt64X8# :: Int64X8# -> Int64X8# -> Int64X8#
  minusInt8X16# :: Int8X16# -> Int8X16# -> Int8X16#
  minusInt8X32# :: Int8X32# -> Int8X32# -> Int8X32#
  minusInt8X64# :: Int8X64# -> Int8X64# -> Int8X64#
  minusWord# :: Word# -> Word# -> Word#
  minusWord16X16# :: Word16X16# -> Word16X16# -> Word16X16#
  minusWord16X32# :: Word16X32# -> Word16X32# -> Word16X32#
  minusWord16X8# :: Word16X8# -> Word16X8# -> Word16X8#
  minusWord32X16# :: Word32X16# -> Word32X16# -> Word32X16#
  minusWord32X4# :: Word32X4# -> Word32X4# -> Word32X4#
  minusWord32X8# :: Word32X8# -> Word32X8# -> Word32X8#
  minusWord64X2# :: Word64X2# -> Word64X2# -> Word64X2#
  minusWord64X4# :: Word64X4# -> Word64X4# -> Word64X4#
  minusWord64X8# :: Word64X8# -> Word64X8# -> Word64X8#
  minusWord8X16# :: Word8X16# -> Word8X16# -> Word8X16#
  minusWord8X32# :: Word8X32# -> Word8X32# -> Word8X32#
  minusWord8X64# :: Word8X64# -> Word8X64# -> Word8X64#
  mkApUpd0# :: forall a. BCO -> (# a #)
  mkWeak# :: forall {l :: Levity} {k :: Levity} (a :: TYPE (BoxedRep l)) (b :: TYPE (BoxedRep k)) c. a -> b -> (State# RealWorld -> (# State# RealWorld, c #)) -> State# RealWorld -> (# State# RealWorld, Weak# b #)
  mkWeakNoFinalizer# :: forall {l :: Levity} {k :: Levity} (a :: TYPE (BoxedRep l)) (b :: TYPE (BoxedRep k)). a -> b -> State# RealWorld -> (# State# RealWorld, Weak# b #)
  modInt :: Int -> Int -> Int
  modInt# :: Int# -> Int# -> Int#
  modInt16# :: Int16# -> Int16# -> Int16#
  modInt32# :: Int32# -> Int32# -> Int32#
  modInt8# :: Int8# -> Int8# -> Int8#
  mulIntMayOflo# :: Int# -> Int# -> Int#
  mutableByteArrayContents# :: forall d. MutableByteArray# d -> Addr#
  myThreadId# :: State# RealWorld -> (# State# RealWorld, ThreadId# #)
  narrow16Int# :: Int# -> Int#
  narrow16Word# :: Word# -> Word#
  narrow32Int# :: Int# -> Int#
  narrow32Word# :: Word# -> Word#
  narrow8Int# :: Int# -> Int#
  narrow8Word# :: Word# -> Word#
  neAddr# :: Addr# -> Addr# -> Int#
  neChar :: Char -> Char -> Bool
  neChar# :: Char# -> Char# -> Int#
  neFloat# :: Float# -> Float# -> Int#
  neInt :: Int -> Int -> Bool
  neInt16# :: Int16# -> Int16# -> Int#
  neInt32# :: Int32# -> Int32# -> Int#
  neInt64# :: Int64# -> Int64# -> Int#
  neInt8# :: Int8# -> Int8# -> Int#
  neWord :: Word -> Word -> Bool
  neWord# :: Word# -> Word# -> Int#
  neWord16# :: Word16# -> Word16# -> Int#
  neWord32# :: Word32# -> Word32# -> Int#
  neWord64# :: Word64# -> Word64# -> Int#
  neWord8# :: Word8# -> Word8# -> Int#
  negateDouble# :: Double# -> Double#
  negateDoubleX2# :: DoubleX2# -> DoubleX2#
  negateDoubleX4# :: DoubleX4# -> DoubleX4#
  negateDoubleX8# :: DoubleX8# -> DoubleX8#
  negateFloat# :: Float# -> Float#
  negateFloatX16# :: FloatX16# -> FloatX16#
  negateFloatX4# :: FloatX4# -> FloatX4#
  negateFloatX8# :: FloatX8# -> FloatX8#
  negateInt# :: Int# -> Int#
  negateInt16# :: Int16# -> Int16#
  negateInt16X16# :: Int16X16# -> Int16X16#
  negateInt16X32# :: Int16X32# -> Int16X32#
  negateInt16X8# :: Int16X8# -> Int16X8#
  negateInt32# :: Int32# -> Int32#
  negateInt32X16# :: Int32X16# -> Int32X16#
  negateInt32X4# :: Int32X4# -> Int32X4#
  negateInt32X8# :: Int32X8# -> Int32X8#
  negateInt64# :: Int64# -> Int64#
  negateInt64X2# :: Int64X2# -> Int64X2#
  negateInt64X4# :: Int64X4# -> Int64X4#
  negateInt64X8# :: Int64X8# -> Int64X8#
  negateInt8# :: Int8# -> Int8#
  negateInt8X16# :: Int8X16# -> Int8X16#
  negateInt8X32# :: Int8X32# -> Int8X32#
  negateInt8X64# :: Int8X64# -> Int8X64#
  newAlignedPinnedByteArray# :: forall d. Int# -> Int# -> State# d -> (# State# d, MutableByteArray# d #)
  newArray# :: forall {l :: Levity} (a :: TYPE (BoxedRep l)) d. Int# -> a -> State# d -> (# State# d, MutableArray# d a #)
  newBCO# :: forall a d. ByteArray# -> ByteArray# -> Array# a -> Int# -> ByteArray# -> State# d -> (# State# d, BCO #)
  newByteArray# :: forall d. Int# -> State# d -> (# State# d, MutableByteArray# d #)
  newIOPort# :: forall {l :: Levity} d (a :: TYPE (BoxedRep l)). State# d -> (# State# d, IOPort# d a #)
  newMVar# :: forall {l :: Levity} d (a :: TYPE (BoxedRep l)). State# d -> (# State# d, MVar# d a #)
  newMutVar# :: forall {l :: Levity} (a :: TYPE (BoxedRep l)) d. a -> State# d -> (# State# d, MutVar# d a #)
  newPinnedByteArray# :: forall d. Int# -> State# d -> (# State# d, MutableByteArray# d #)
  newPromptTag# :: forall a. State# RealWorld -> (# State# RealWorld, PromptTag# a #)
  newSmallArray# :: forall {l :: Levity} (a :: TYPE (BoxedRep l)) d. Int# -> a -> State# d -> (# State# d, SmallMutableArray# d a #)
  newTVar# :: forall {l :: Levity} (a :: TYPE (BoxedRep l)) d. a -> State# d -> (# State# d, TVar# d a #)
  noDuplicate# :: forall d. State# d -> State# d
  noinline :: forall a. a -> a
  not :: Bool -> Bool
  not# :: Word# -> Word#
  not64# :: Word64# -> Word64#
  notI# :: Int# -> Int#
  notWord16# :: Word16# -> Word16#
  notWord32# :: Word32# -> Word32#
  notWord8# :: Word8# -> Word8#
  nullAddr# :: Addr#
  numSparks# :: forall d. State# d -> (# State# d, Int# #)
  oneShot :: forall {q :: RuntimeRep} {r :: RuntimeRep} (a :: TYPE q) (b :: TYPE r). (a -> b) -> a -> b
  or# :: Word# -> Word# -> Word#
  or64# :: Word64# -> Word64# -> Word64#
  orI# :: Int# -> Int# -> Int#
  orWord16# :: Word16# -> Word16# -> Word16#
  orWord32# :: Word32# -> Word32# -> Word32#
  orWord8# :: Word8# -> Word8# -> Word8#
  ord :: Char -> Int
  ord# :: Char# -> Int#
  otherwise :: Bool
  packDoubleX2# :: (# Double#, Double# #) -> DoubleX2#
  packDoubleX4# :: (# Double#, Double#, Double#, Double# #) -> DoubleX4#
  packDoubleX8# :: (# Double#, Double#, Double#, Double#, Double#, Double#, Double#, Double# #) -> DoubleX8#
  packFloatX16# :: (# Float#, Float#, Float#, Float#, Float#, Float#, Float#, Float#, Float#, Float#, Float#, Float#, Float#, Float#, Float#, Float# #) -> FloatX16#
  packFloatX4# :: (# Float#, Float#, Float#, Float# #) -> FloatX4#
  packFloatX8# :: (# Float#, Float#, Float#, Float#, Float#, Float#, Float#, Float# #) -> FloatX8#
  packInt16X16# :: (# Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16# #) -> Int16X16#
  packInt16X32# :: (# Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16# #) -> Int16X32#
  packInt16X8# :: (# Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16# #) -> Int16X8#
  packInt32X16# :: (# Int32#, Int32#, Int32#, Int32#, Int32#, Int32#, Int32#, Int32#, Int32#, Int32#, Int32#, Int32#, Int32#, Int32#, Int32#, Int32# #) -> Int32X16#
  packInt32X4# :: (# Int32#, Int32#, Int32#, Int32# #) -> Int32X4#
  packInt32X8# :: (# Int32#, Int32#, Int32#, Int32#, Int32#, Int32#, Int32#, Int32# #) -> Int32X8#
  packInt64X2# :: (# Int64#, Int64# #) -> Int64X2#
  packInt64X4# :: (# Int64#, Int64#, Int64#, Int64# #) -> Int64X4#
  packInt64X8# :: (# Int64#, Int64#, Int64#, Int64#, Int64#, Int64#, Int64#, Int64# #) -> Int64X8#
  packInt8X16# :: (# Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8# #) -> Int8X16#
  packInt8X32# :: (# Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8# #) -> Int8X32#
  packInt8X64# :: (# Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8# #) -> Int8X64#
  packWord16X16# :: (# Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16# #) -> Word16X16#
  packWord16X32# :: (# Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16# #) -> Word16X32#
  packWord16X8# :: (# Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16# #) -> Word16X8#
  packWord32X16# :: (# Word32#, Word32#, Word32#, Word32#, Word32#, Word32#, Word32#, Word32#, Word32#, Word32#, Word32#, Word32#, Word32#, Word32#, Word32#, Word32# #) -> Word32X16#
  packWord32X4# :: (# Word32#, Word32#, Word32#, Word32# #) -> Word32X4#
  packWord32X8# :: (# Word32#, Word32#, Word32#, Word32#, Word32#, Word32#, Word32#, Word32# #) -> Word32X8#
  packWord64X2# :: (# Word64#, Word64# #) -> Word64X2#
  packWord64X4# :: (# Word64#, Word64#, Word64#, Word64# #) -> Word64X4#
  packWord64X8# :: (# Word64#, Word64#, Word64#, Word64#, Word64#, Word64#, Word64#, Word64# #) -> Word64X8#
  packWord8X16# :: (# Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8# #) -> Word8X16#
  packWord8X32# :: (# Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8# #) -> Word8X32#
  packWord8X64# :: (# Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8# #) -> Word8X64#
  par# :: forall a. a -> Int#
  pdep# :: Word# -> Word# -> Word#
  pdep16# :: Word# -> Word# -> Word#
  pdep32# :: Word# -> Word# -> Word#
  pdep64# :: Word64# -> Word64# -> Word64#
  pdep8# :: Word# -> Word# -> Word#
  pext# :: Word# -> Word# -> Word#
  pext16# :: Word# -> Word# -> Word#
  pext32# :: Word# -> Word# -> Word#
  pext64# :: Word64# -> Word64# -> Word64#
  pext8# :: Word# -> Word# -> Word#
  plusAddr# :: Addr# -> Int# -> Addr#
  plusDoubleX2# :: DoubleX2# -> DoubleX2# -> DoubleX2#
  plusDoubleX4# :: DoubleX4# -> DoubleX4# -> DoubleX4#
  plusDoubleX8# :: DoubleX8# -> DoubleX8# -> DoubleX8#
  plusFloat# :: Float# -> Float# -> Float#
  plusFloatX16# :: FloatX16# -> FloatX16# -> FloatX16#
  plusFloatX4# :: FloatX4# -> FloatX4# -> FloatX4#
  plusFloatX8# :: FloatX8# -> FloatX8# -> FloatX8#
  plusInt16# :: Int16# -> Int16# -> Int16#
  plusInt16X16# :: Int16X16# -> Int16X16# -> Int16X16#
  plusInt16X32# :: Int16X32# -> Int16X32# -> Int16X32#
  plusInt16X8# :: Int16X8# -> Int16X8# -> Int16X8#
  plusInt32# :: Int32# -> Int32# -> Int32#
  plusInt32X16# :: Int32X16# -> Int32X16# -> Int32X16#
  plusInt32X4# :: Int32X4# -> Int32X4# -> Int32X4#
  plusInt32X8# :: Int32X8# -> Int32X8# -> Int32X8#
  plusInt64# :: Int64# -> Int64# -> Int64#
  plusInt64X2# :: Int64X2# -> Int64X2# -> Int64X2#
  plusInt64X4# :: Int64X4# -> Int64X4# -> Int64X4#
  plusInt64X8# :: Int64X8# -> Int64X8# -> Int64X8#
  plusInt8# :: Int8# -> Int8# -> Int8#
  plusInt8X16# :: Int8X16# -> Int8X16# -> Int8X16#
  plusInt8X32# :: Int8X32# -> Int8X32# -> Int8X32#
  plusInt8X64# :: Int8X64# -> Int8X64# -> Int8X64#
  plusWord# :: Word# -> Word# -> Word#
  plusWord16# :: Word16# -> Word16# -> Word16#
  plusWord16X16# :: Word16X16# -> Word16X16# -> Word16X16#
  plusWord16X32# :: Word16X32# -> Word16X32# -> Word16X32#
  plusWord16X8# :: Word16X8# -> Word16X8# -> Word16X8#
  plusWord2# :: Word# -> Word# -> (# Word#, Word# #)
  plusWord32# :: Word32# -> Word32# -> Word32#
  plusWord32X16# :: Word32X16# -> Word32X16# -> Word32X16#
  plusWord32X4# :: Word32X4# -> Word32X4# -> Word32X4#
  plusWord32X8# :: Word32X8# -> Word32X8# -> Word32X8#
  plusWord64# :: Word64# -> Word64# -> Word64#
  plusWord64X2# :: Word64X2# -> Word64X2# -> Word64X2#
  plusWord64X4# :: Word64X4# -> Word64X4# -> Word64X4#
  plusWord64X8# :: Word64X8# -> Word64X8# -> Word64X8#
  plusWord8# :: Word8# -> Word8# -> Word8#
  plusWord8X16# :: Word8X16# -> Word8X16# -> Word8X16#
  plusWord8X32# :: Word8X32# -> Word8X32# -> Word8X32#
  plusWord8X64# :: Word8X64# -> Word8X64# -> Word8X64#
  popCnt# :: Word# -> Word#
  popCnt16# :: Word# -> Word#
  popCnt32# :: Word# -> Word#
  popCnt64# :: Word64# -> Word#
  popCnt8# :: Word# -> Word#
  powerFloat# :: Float# -> Float# -> Float#
  prefetchAddr0# :: forall d. Addr# -> Int# -> State# d -> State# d
  prefetchAddr1# :: forall d. Addr# -> Int# -> State# d -> State# d
  prefetchAddr2# :: forall d. Addr# -> Int# -> State# d -> State# d
  prefetchAddr3# :: forall d. Addr# -> Int# -> State# d -> State# d
  prefetchByteArray0# :: forall d. ByteArray# -> Int# -> State# d -> State# d
  prefetchByteArray1# :: forall d. ByteArray# -> Int# -> State# d -> State# d
  prefetchByteArray2# :: forall d. ByteArray# -> Int# -> State# d -> State# d
  prefetchByteArray3# :: forall d. ByteArray# -> Int# -> State# d -> State# d
  prefetchMutableByteArray0# :: forall d. MutableByteArray# d -> Int# -> State# d -> State# d
  prefetchMutableByteArray1# :: forall d. MutableByteArray# d -> Int# -> State# d -> State# d
  prefetchMutableByteArray2# :: forall d. MutableByteArray# d -> Int# -> State# d -> State# d
  prefetchMutableByteArray3# :: forall d. MutableByteArray# d -> Int# -> State# d -> State# d
  prefetchValue0# :: forall a d. a -> State# d -> State# d
  prefetchValue1# :: forall a d. a -> State# d -> State# d
  prefetchValue2# :: forall a d. a -> State# d -> State# d
  prefetchValue3# :: forall a d. a -> State# d -> State# d
  prompt# :: forall a. PromptTag# a -> (State# RealWorld -> (# State# RealWorld, a #)) -> State# RealWorld -> (# State# RealWorld, a #)
  proxy# :: forall {k} (a :: k). Proxy# a
  putMVar# :: forall {l :: Levity} d (a :: TYPE (BoxedRep l)). MVar# d a -> a -> State# d -> State# d
  quotInt :: Int -> Int -> Int
  quotInt# :: Int# -> Int# -> Int#
  quotInt16# :: Int16# -> Int16# -> Int16#
  quotInt16X16# :: Int16X16# -> Int16X16# -> Int16X16#
  quotInt16X32# :: Int16X32# -> Int16X32# -> Int16X32#
  quotInt16X8# :: Int16X8# -> Int16X8# -> Int16X8#
  quotInt32# :: Int32# -> Int32# -> Int32#
  quotInt32X16# :: Int32X16# -> Int32X16# -> Int32X16#
  quotInt32X4# :: Int32X4# -> Int32X4# -> Int32X4#
  quotInt32X8# :: Int32X8# -> Int32X8# -> Int32X8#
  quotInt64# :: Int64# -> Int64# -> Int64#
  quotInt64X2# :: Int64X2# -> Int64X2# -> Int64X2#
  quotInt64X4# :: Int64X4# -> Int64X4# -> Int64X4#
  quotInt64X8# :: Int64X8# -> Int64X8# -> Int64X8#
  quotInt8# :: Int8# -> Int8# -> Int8#
  quotInt8X16# :: Int8X16# -> Int8X16# -> Int8X16#
  quotInt8X32# :: Int8X32# -> Int8X32# -> Int8X32#
  quotInt8X64# :: Int8X64# -> Int8X64# -> Int8X64#
  quotRemInt :: Int -> Int -> (Int, Int)
  quotRemInt# :: Int# -> Int# -> (# Int#, Int# #)
  quotRemInt16# :: Int16# -> Int16# -> (# Int16#, Int16# #)
  quotRemInt32# :: Int32# -> Int32# -> (# Int32#, Int32# #)
  quotRemInt8# :: Int8# -> Int8# -> (# Int8#, Int8# #)
  quotRemWord# :: Word# -> Word# -> (# Word#, Word# #)
  quotRemWord16# :: Word16# -> Word16# -> (# Word16#, Word16# #)
  quotRemWord2# :: Word# -> Word# -> Word# -> (# Word#, Word# #)
  quotRemWord32# :: Word32# -> Word32# -> (# Word32#, Word32# #)
  quotRemWord8# :: Word8# -> Word8# -> (# Word8#, Word8# #)
  quotWord# :: Word# -> Word# -> Word#
  quotWord16# :: Word16# -> Word16# -> Word16#
  quotWord16X16# :: Word16X16# -> Word16X16# -> Word16X16#
  quotWord16X32# :: Word16X32# -> Word16X32# -> Word16X32#
  quotWord16X8# :: Word16X8# -> Word16X8# -> Word16X8#
  quotWord32# :: Word32# -> Word32# -> Word32#
  quotWord32X16# :: Word32X16# -> Word32X16# -> Word32X16#
  quotWord32X4# :: Word32X4# -> Word32X4# -> Word32X4#
  quotWord32X8# :: Word32X8# -> Word32X8# -> Word32X8#
  quotWord64# :: Word64# -> Word64# -> Word64#
  quotWord64X2# :: Word64X2# -> Word64X2# -> Word64X2#
  quotWord64X4# :: Word64X4# -> Word64X4# -> Word64X4#
  quotWord64X8# :: Word64X8# -> Word64X8# -> Word64X8#
  quotWord8# :: Word8# -> Word8# -> Word8#
  quotWord8X16# :: Word8X16# -> Word8X16# -> Word8X16#
  quotWord8X32# :: Word8X32# -> Word8X32# -> Word8X32#
  quotWord8X64# :: Word8X64# -> Word8X64# -> Word8X64#
  raise# :: forall {l :: Levity} {r :: RuntimeRep} (a :: TYPE (BoxedRep l)) (b :: TYPE r). a -> b
  raiseDivZero# :: forall {r :: RuntimeRep} (b :: TYPE r). (# #) -> b
  raiseIO# :: forall {l :: Levity} {r :: RuntimeRep} (a :: TYPE (BoxedRep l)) (b :: TYPE r). a -> State# RealWorld -> (# State# RealWorld, b #)
  raiseOverflow# :: forall {r :: RuntimeRep} (b :: TYPE r). (# #) -> b
  raiseUnderflow# :: forall {r :: RuntimeRep} (b :: TYPE r). (# #) -> b
  readAddrArray# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Addr# #)
  readAddrOffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Addr# #)
  readArray# :: forall {l :: Levity} d (a :: TYPE (BoxedRep l)). MutableArray# d a -> Int# -> State# d -> (# State# d, a #)
  readCharArray# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Char# #)
  readCharOffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Char# #)
  readDoubleArray# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Double# #)
  readDoubleArrayAsDoubleX2# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, DoubleX2# #)
  readDoubleArrayAsDoubleX4# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, DoubleX4# #)
  readDoubleArrayAsDoubleX8# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, DoubleX8# #)
  readDoubleOffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Double# #)
  readDoubleOffAddrAsDoubleX2# :: forall d. Addr# -> Int# -> State# d -> (# State# d, DoubleX2# #)
  readDoubleOffAddrAsDoubleX4# :: forall d. Addr# -> Int# -> State# d -> (# State# d, DoubleX4# #)
  readDoubleOffAddrAsDoubleX8# :: forall d. Addr# -> Int# -> State# d -> (# State# d, DoubleX8# #)
  readDoubleX2Array# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, DoubleX2# #)
  readDoubleX2OffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, DoubleX2# #)
  readDoubleX4Array# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, DoubleX4# #)
  readDoubleX4OffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, DoubleX4# #)
  readDoubleX8Array# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, DoubleX8# #)
  readDoubleX8OffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, DoubleX8# #)
  readFloatArray# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Float# #)
  readFloatArrayAsFloatX16# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, FloatX16# #)
  readFloatArrayAsFloatX4# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, FloatX4# #)
  readFloatArrayAsFloatX8# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, FloatX8# #)
  readFloatOffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Float# #)
  readFloatOffAddrAsFloatX16# :: forall d. Addr# -> Int# -> State# d -> (# State# d, FloatX16# #)
  readFloatOffAddrAsFloatX4# :: forall d. Addr# -> Int# -> State# d -> (# State# d, FloatX4# #)
  readFloatOffAddrAsFloatX8# :: forall d. Addr# -> Int# -> State# d -> (# State# d, FloatX8# #)
  readFloatX16Array# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, FloatX16# #)
  readFloatX16OffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, FloatX16# #)
  readFloatX4Array# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, FloatX4# #)
  readFloatX4OffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, FloatX4# #)
  readFloatX8Array# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, FloatX8# #)
  readFloatX8OffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, FloatX8# #)
  readIOPort# :: forall {l :: Levity} d (a :: TYPE (BoxedRep l)). IOPort# d a -> State# d -> (# State# d, a #)
  readInt16Array# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Int16# #)
  readInt16ArrayAsInt16X16# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Int16X16# #)
  readInt16ArrayAsInt16X32# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Int16X32# #)
  readInt16ArrayAsInt16X8# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Int16X8# #)
  readInt16OffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Int16# #)
  readInt16OffAddrAsInt16X16# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Int16X16# #)
  readInt16OffAddrAsInt16X32# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Int16X32# #)
  readInt16OffAddrAsInt16X8# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Int16X8# #)
  readInt16X16Array# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Int16X16# #)
  readInt16X16OffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Int16X16# #)
  readInt16X32Array# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Int16X32# #)
  readInt16X32OffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Int16X32# #)
  readInt16X8Array# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Int16X8# #)
  readInt16X8OffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Int16X8# #)
  readInt32Array# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Int32# #)
  readInt32ArrayAsInt32X16# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Int32X16# #)
  readInt32ArrayAsInt32X4# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Int32X4# #)
  readInt32ArrayAsInt32X8# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Int32X8# #)
  readInt32OffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Int32# #)
  readInt32OffAddrAsInt32X16# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Int32X16# #)
  readInt32OffAddrAsInt32X4# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Int32X4# #)
  readInt32OffAddrAsInt32X8# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Int32X8# #)
  readInt32X16Array# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Int32X16# #)
  readInt32X16OffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Int32X16# #)
  readInt32X4Array# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Int32X4# #)
  readInt32X4OffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Int32X4# #)
  readInt32X8Array# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Int32X8# #)
  readInt32X8OffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Int32X8# #)
  readInt64Array# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Int64# #)
  readInt64ArrayAsInt64X2# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Int64X2# #)
  readInt64ArrayAsInt64X4# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Int64X4# #)
  readInt64ArrayAsInt64X8# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Int64X8# #)
  readInt64OffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Int64# #)
  readInt64OffAddrAsInt64X2# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Int64X2# #)
  readInt64OffAddrAsInt64X4# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Int64X4# #)
  readInt64OffAddrAsInt64X8# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Int64X8# #)
  readInt64X2Array# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Int64X2# #)
  readInt64X2OffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Int64X2# #)
  readInt64X4Array# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Int64X4# #)
  readInt64X4OffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Int64X4# #)
  readInt64X8Array# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Int64X8# #)
  readInt64X8OffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Int64X8# #)
  readInt8Array# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Int8# #)
  readInt8ArrayAsInt8X16# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Int8X16# #)
  readInt8ArrayAsInt8X32# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Int8X32# #)
  readInt8ArrayAsInt8X64# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Int8X64# #)
  readInt8OffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Int8# #)
  readInt8OffAddrAsInt8X16# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Int8X16# #)
  readInt8OffAddrAsInt8X32# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Int8X32# #)
  readInt8OffAddrAsInt8X64# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Int8X64# #)
  readInt8X16Array# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Int8X16# #)
  readInt8X16OffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Int8X16# #)
  readInt8X32Array# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Int8X32# #)
  readInt8X32OffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Int8X32# #)
  readInt8X64Array# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Int8X64# #)
  readInt8X64OffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Int8X64# #)
  readIntArray# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Int# #)
  readIntOffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Int# #)
  readMVar# :: forall {l :: Levity} d (a :: TYPE (BoxedRep l)). MVar# d a -> State# d -> (# State# d, a #)
  readMutVar# :: forall {l :: Levity} d (a :: TYPE (BoxedRep l)). MutVar# d a -> State# d -> (# State# d, a #)
  readSmallArray# :: forall {l :: Levity} d (a :: TYPE (BoxedRep l)). SmallMutableArray# d a -> Int# -> State# d -> (# State# d, a #)
  readStablePtrArray# :: forall d a. MutableByteArray# d -> Int# -> State# d -> (# State# d, StablePtr# a #)
  readStablePtrOffAddr# :: forall d a. Addr# -> Int# -> State# d -> (# State# d, StablePtr# a #)
  readTVar# :: forall {l :: Levity} d (a :: TYPE (BoxedRep l)). TVar# d a -> State# d -> (# State# d, a #)
  readTVarIO# :: forall {l :: Levity} d (a :: TYPE (BoxedRep l)). TVar# d a -> State# d -> (# State# d, a #)
  readWideCharArray# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Char# #)
  readWideCharOffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Char# #)
  readWord16Array# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Word16# #)
  readWord16ArrayAsWord16X16# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Word16X16# #)
  readWord16ArrayAsWord16X32# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Word16X32# #)
  readWord16ArrayAsWord16X8# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Word16X8# #)
  readWord16OffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Word16# #)
  readWord16OffAddrAsWord16X16# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Word16X16# #)
  readWord16OffAddrAsWord16X32# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Word16X32# #)
  readWord16OffAddrAsWord16X8# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Word16X8# #)
  readWord16X16Array# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Word16X16# #)
  readWord16X16OffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Word16X16# #)
  readWord16X32Array# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Word16X32# #)
  readWord16X32OffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Word16X32# #)
  readWord16X8Array# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Word16X8# #)
  readWord16X8OffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Word16X8# #)
  readWord32Array# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Word32# #)
  readWord32ArrayAsWord32X16# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Word32X16# #)
  readWord32ArrayAsWord32X4# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Word32X4# #)
  readWord32ArrayAsWord32X8# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Word32X8# #)
  readWord32OffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Word32# #)
  readWord32OffAddrAsWord32X16# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Word32X16# #)
  readWord32OffAddrAsWord32X4# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Word32X4# #)
  readWord32OffAddrAsWord32X8# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Word32X8# #)
  readWord32X16Array# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Word32X16# #)
  readWord32X16OffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Word32X16# #)
  readWord32X4Array# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Word32X4# #)
  readWord32X4OffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Word32X4# #)
  readWord32X8Array# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Word32X8# #)
  readWord32X8OffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Word32X8# #)
  readWord64Array# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Word64# #)
  readWord64ArrayAsWord64X2# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Word64X2# #)
  readWord64ArrayAsWord64X4# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Word64X4# #)
  readWord64ArrayAsWord64X8# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Word64X8# #)
  readWord64OffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Word64# #)
  readWord64OffAddrAsWord64X2# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Word64X2# #)
  readWord64OffAddrAsWord64X4# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Word64X4# #)
  readWord64OffAddrAsWord64X8# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Word64X8# #)
  readWord64X2Array# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Word64X2# #)
  readWord64X2OffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Word64X2# #)
  readWord64X4Array# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Word64X4# #)
  readWord64X4OffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Word64X4# #)
  readWord64X8Array# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Word64X8# #)
  readWord64X8OffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Word64X8# #)
  readWord8Array# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Word8# #)
  readWord8ArrayAsAddr# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Addr# #)
  readWord8ArrayAsChar# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Char# #)
  readWord8ArrayAsDouble# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Double# #)
  readWord8ArrayAsFloat# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Float# #)
  readWord8ArrayAsInt# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Int# #)
  readWord8ArrayAsInt16# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Int16# #)
  readWord8ArrayAsInt32# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Int32# #)
  readWord8ArrayAsInt64# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Int64# #)
  readWord8ArrayAsStablePtr# :: forall d a. MutableByteArray# d -> Int# -> State# d -> (# State# d, StablePtr# a #)
  readWord8ArrayAsWideChar# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Char# #)
  readWord8ArrayAsWord# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Word# #)
  readWord8ArrayAsWord16# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Word16# #)
  readWord8ArrayAsWord32# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Word32# #)
  readWord8ArrayAsWord64# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Word64# #)
  readWord8ArrayAsWord8X16# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Word8X16# #)
  readWord8ArrayAsWord8X32# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Word8X32# #)
  readWord8ArrayAsWord8X64# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Word8X64# #)
  readWord8OffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Word8# #)
  readWord8OffAddrAsAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Addr# #)
  readWord8OffAddrAsChar# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Char# #)
  readWord8OffAddrAsDouble# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Double# #)
  readWord8OffAddrAsFloat# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Float# #)
  readWord8OffAddrAsInt# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Int# #)
  readWord8OffAddrAsInt16# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Int16# #)
  readWord8OffAddrAsInt32# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Int32# #)
  readWord8OffAddrAsInt64# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Int64# #)
  readWord8OffAddrAsStablePtr# :: forall d a. Addr# -> Int# -> State# d -> (# State# d, StablePtr# a #)
  readWord8OffAddrAsWideChar# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Char# #)
  readWord8OffAddrAsWord# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Word# #)
  readWord8OffAddrAsWord16# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Word16# #)
  readWord8OffAddrAsWord32# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Word32# #)
  readWord8OffAddrAsWord64# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Word64# #)
  readWord8OffAddrAsWord8X16# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Word8X16# #)
  readWord8OffAddrAsWord8X32# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Word8X32# #)
  readWord8OffAddrAsWord8X64# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Word8X64# #)
  readWord8X16Array# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Word8X16# #)
  readWord8X16OffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Word8X16# #)
  readWord8X32Array# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Word8X32# #)
  readWord8X32OffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Word8X32# #)
  readWord8X64Array# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Word8X64# #)
  readWord8X64OffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Word8X64# #)
  readWordArray# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Word# #)
  readWordOffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Word# #)
  realWorld# :: State# RealWorld
  reallyUnsafePtrEquality :: forall a. a -> a -> Int#
  reallyUnsafePtrEquality# :: forall {l :: Levity} {k :: Levity} (a :: TYPE (BoxedRep l)) (b :: TYPE (BoxedRep k)). a -> b -> Int#
  remAddr# :: Addr# -> Int# -> Int#
  remInt :: Int -> Int -> Int
  remInt# :: Int# -> Int# -> Int#
  remInt16# :: Int16# -> Int16# -> Int16#
  remInt16X16# :: Int16X16# -> Int16X16# -> Int16X16#
  remInt16X32# :: Int16X32# -> Int16X32# -> Int16X32#
  remInt16X8# :: Int16X8# -> Int16X8# -> Int16X8#
  remInt32# :: Int32# -> Int32# -> Int32#
  remInt32X16# :: Int32X16# -> Int32X16# -> Int32X16#
  remInt32X4# :: Int32X4# -> Int32X4# -> Int32X4#
  remInt32X8# :: Int32X8# -> Int32X8# -> Int32X8#
  remInt64# :: Int64# -> Int64# -> Int64#
  remInt64X2# :: Int64X2# -> Int64X2# -> Int64X2#
  remInt64X4# :: Int64X4# -> Int64X4# -> Int64X4#
  remInt64X8# :: Int64X8# -> Int64X8# -> Int64X8#
  remInt8# :: Int8# -> Int8# -> Int8#
  remInt8X16# :: Int8X16# -> Int8X16# -> Int8X16#
  remInt8X32# :: Int8X32# -> Int8X32# -> Int8X32#
  remInt8X64# :: Int8X64# -> Int8X64# -> Int8X64#
  remWord# :: Word# -> Word# -> Word#
  remWord16# :: Word16# -> Word16# -> Word16#
  remWord16X16# :: Word16X16# -> Word16X16# -> Word16X16#
  remWord16X32# :: Word16X32# -> Word16X32# -> Word16X32#
  remWord16X8# :: Word16X8# -> Word16X8# -> Word16X8#
  remWord32# :: Word32# -> Word32# -> Word32#
  remWord32X16# :: Word32X16# -> Word32X16# -> Word32X16#
  remWord32X4# :: Word32X4# -> Word32X4# -> Word32X4#
  remWord32X8# :: Word32X8# -> Word32X8# -> Word32X8#
  remWord64# :: Word64# -> Word64# -> Word64#
  remWord64X2# :: Word64X2# -> Word64X2# -> Word64X2#
  remWord64X4# :: Word64X4# -> Word64X4# -> Word64X4#
  remWord64X8# :: Word64X8# -> Word64X8# -> Word64X8#
  remWord8# :: Word8# -> Word8# -> Word8#
  remWord8X16# :: Word8X16# -> Word8X16# -> Word8X16#
  remWord8X32# :: Word8X32# -> Word8X32# -> Word8X32#
  remWord8X64# :: Word8X64# -> Word8X64# -> Word8X64#
  resizeMutableByteArray# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, MutableByteArray# d #)
  retry# :: forall {l :: Levity} (a :: TYPE (BoxedRep l)). State# RealWorld -> (# State# RealWorld, a #)
  returnIO :: forall a. a -> IO a
  rightSection :: forall {q :: RuntimeRep} {r :: RuntimeRep} {s :: RuntimeRep} (a :: TYPE q) (b :: TYPE r) (c :: TYPE s). (a -> b -> c) -> b -> a -> c
  runRW# :: forall (r :: RuntimeRep) (o :: TYPE r). (State# RealWorld -> o) -> o
  sameArray# :: forall {l :: Levity} (a :: TYPE (BoxedRep l)). Array# a -> Array# a -> Int#
  sameByteArray# :: ByteArray# -> ByteArray# -> Int#
  sameIOPort# :: forall {l :: Levity} s (a :: TYPE (BoxedRep l)). IOPort# s a -> IOPort# s a -> Int#
  sameMVar# :: forall {l :: Levity} s (a :: TYPE (BoxedRep l)). MVar# s a -> MVar# s a -> Int#
  sameMutVar# :: forall {l :: Levity} s (a :: TYPE (BoxedRep l)). MutVar# s a -> MutVar# s a -> Int#
  sameMutableArray# :: forall {l :: Levity} s (a :: TYPE (BoxedRep l)). MutableArray# s a -> MutableArray# s a -> Int#
  sameMutableByteArray# :: forall s. MutableByteArray# s -> MutableByteArray# s -> Int#
  samePromptTag# :: forall a. PromptTag# a -> PromptTag# a -> Int#
  sameSmallArray# :: forall {l :: Levity} (a :: TYPE (BoxedRep l)). SmallArray# a -> SmallArray# a -> Int#
  sameSmallMutableArray# :: forall {l :: Levity} s (a :: TYPE (BoxedRep l)). SmallMutableArray# s a -> SmallMutableArray# s a -> Int#
  sameTVar# :: forall {l :: Levity} s (a :: TYPE (BoxedRep l)). TVar# s a -> TVar# s a -> Int#
  seq :: forall {r :: RuntimeRep} a (b :: TYPE r). a -> b -> b
  seq# :: forall a d. a -> State# d -> (# State# d, a #)
  sequence :: forall (m :: * -> *) a. Monad m => [m a] -> m [a]
  setAddrRange# :: Addr# -> Int# -> Int# -> State# RealWorld -> State# RealWorld
  setByteArray# :: forall d. MutableByteArray# d -> Int# -> Int# -> Int# -> State# d -> State# d
  setThreadAllocationCounter# :: Int64# -> State# RealWorld -> State# RealWorld
  shiftL# :: Word# -> Int# -> Word#
  shiftRL# :: Word# -> Int# -> Word#
  shift_mask :: Int# -> Int# -> Int#
  shrinkMutableByteArray# :: forall d. MutableByteArray# d -> Int# -> State# d -> State# d
  shrinkSmallMutableArray# :: forall {l :: Levity} d (a :: TYPE (BoxedRep l)). SmallMutableArray# d a -> Int# -> State# d -> State# d
  sinDouble# :: Double# -> Double#
  sinFloat# :: Float# -> Float#
  sinhDouble# :: Double# -> Double#
  sinhFloat# :: Float# -> Float#
  sizeofArray# :: forall {l :: Levity} (a :: TYPE (BoxedRep l)). Array# a -> Int#
  sizeofByteArray# :: ByteArray# -> Int#
  sizeofMutableArray# :: forall {l :: Levity} d (a :: TYPE (BoxedRep l)). MutableArray# d a -> Int#
  sizeofMutableByteArray# :: forall d. MutableByteArray# d -> Int#
  sizeofSmallArray# :: forall {l :: Levity} (a :: TYPE (BoxedRep l)). SmallArray# a -> Int#
  sizeofSmallMutableArray# :: forall {l :: Levity} d (a :: TYPE (BoxedRep l)). SmallMutableArray# d a -> Int#
  spark# :: forall a d. a -> State# d -> (# State# d, a #)
  sqrtDouble# :: Double# -> Double#
  sqrtFloat# :: Float# -> Float#
  stableNameToInt# :: forall {l :: Levity} (a :: TYPE (BoxedRep l)). StableName# a -> Int#
  subInt16# :: Int16# -> Int16# -> Int16#
  subInt32# :: Int32# -> Int32# -> Int32#
  subInt64# :: Int64# -> Int64# -> Int64#
  subInt8# :: Int8# -> Int8# -> Int8#
  subIntC# :: Int# -> Int# -> (# Int#, Int# #)
  subWord16# :: Word16# -> Word16# -> Word16#
  subWord32# :: Word32# -> Word32# -> Word32#
  subWord64# :: Word64# -> Word64# -> Word64#
  subWord8# :: Word8# -> Word8# -> Word8#
  subWordC# :: Word# -> Word# -> (# Word#, Int# #)
  tagToEnum# :: forall a. Int# -> a
  takeMVar# :: forall {l :: Levity} d (a :: TYPE (BoxedRep l)). MVar# d a -> State# d -> (# State# d, a #)
  tanDouble# :: Double# -> Double#
  tanFloat# :: Float# -> Float#
  tanhDouble# :: Double# -> Double#
  tanhFloat# :: Float# -> Float#
  thawArray# :: forall {l :: Levity} (a :: TYPE (BoxedRep l)) d. Array# a -> Int# -> Int# -> State# d -> (# State# d, MutableArray# d a #)
  thawSmallArray# :: forall {l :: Levity} (a :: TYPE (BoxedRep l)) d. SmallArray# a -> Int# -> Int# -> State# d -> (# State# d, SmallMutableArray# d a #)
  thenIO :: forall a b. IO a -> IO b -> IO b
  threadLabel# :: ThreadId# -> State# RealWorld -> (# State# RealWorld, Int#, ByteArray# #)
  threadStatus# :: ThreadId# -> State# RealWorld -> (# State# RealWorld, Int#, Int#, Int# #)
  timesDoubleX2# :: DoubleX2# -> DoubleX2# -> DoubleX2#
  timesDoubleX4# :: DoubleX4# -> DoubleX4# -> DoubleX4#
  timesDoubleX8# :: DoubleX8# -> DoubleX8# -> DoubleX8#
  timesFloat# :: Float# -> Float# -> Float#
  timesFloatX16# :: FloatX16# -> FloatX16# -> FloatX16#
  timesFloatX4# :: FloatX4# -> FloatX4# -> FloatX4#
  timesFloatX8# :: FloatX8# -> FloatX8# -> FloatX8#
  timesInt16# :: Int16# -> Int16# -> Int16#
  timesInt16X16# :: Int16X16# -> Int16X16# -> Int16X16#
  timesInt16X32# :: Int16X32# -> Int16X32# -> Int16X32#
  timesInt16X8# :: Int16X8# -> Int16X8# -> Int16X8#
  timesInt2# :: Int# -> Int# -> (# Int#, Int#, Int# #)
  timesInt32# :: Int32# -> Int32# -> Int32#
  timesInt32X16# :: Int32X16# -> Int32X16# -> Int32X16#
  timesInt32X4# :: Int32X4# -> Int32X4# -> Int32X4#
  timesInt32X8# :: Int32X8# -> Int32X8# -> Int32X8#
  timesInt64# :: Int64# -> Int64# -> Int64#
  timesInt64X2# :: Int64X2# -> Int64X2# -> Int64X2#
  timesInt64X4# :: Int64X4# -> Int64X4# -> Int64X4#
  timesInt64X8# :: Int64X8# -> Int64X8# -> Int64X8#
  timesInt8# :: Int8# -> Int8# -> Int8#
  timesInt8X16# :: Int8X16# -> Int8X16# -> Int8X16#
  timesInt8X32# :: Int8X32# -> Int8X32# -> Int8X32#
  timesInt8X64# :: Int8X64# -> Int8X64# -> Int8X64#
  timesWord# :: Word# -> Word# -> Word#
  timesWord16# :: Word16# -> Word16# -> Word16#
  timesWord16X16# :: Word16X16# -> Word16X16# -> Word16X16#
  timesWord16X32# :: Word16X32# -> Word16X32# -> Word16X32#
  timesWord16X8# :: Word16X8# -> Word16X8# -> Word16X8#
  timesWord2# :: Word# -> Word# -> (# Word#, Word# #)
  timesWord32# :: Word32# -> Word32# -> Word32#
  timesWord32X16# :: Word32X16# -> Word32X16# -> Word32X16#
  timesWord32X4# :: Word32X4# -> Word32X4# -> Word32X4#
  timesWord32X8# :: Word32X8# -> Word32X8# -> Word32X8#
  timesWord64# :: Word64# -> Word64# -> Word64#
  timesWord64X2# :: Word64X2# -> Word64X2# -> Word64X2#
  timesWord64X4# :: Word64X4# -> Word64X4# -> Word64X4#
  timesWord64X8# :: Word64X8# -> Word64X8# -> Word64X8#
  timesWord8# :: Word8# -> Word8# -> Word8#
  timesWord8X16# :: Word8X16# -> Word8X16# -> Word8X16#
  timesWord8X32# :: Word8X32# -> Word8X32# -> Word8X32#
  timesWord8X64# :: Word8X64# -> Word8X64# -> Word8X64#
  touch# :: forall {l :: Levity} (a :: TYPE (BoxedRep l)) d. a -> State# d -> State# d
  traceBinaryEvent# :: forall d. Addr# -> Int# -> State# d -> State# d
  traceEvent# :: forall d. Addr# -> State# d -> State# d
  traceMarker# :: forall d. Addr# -> State# d -> State# d
  tryPutMVar# :: forall {l :: Levity} d (a :: TYPE (BoxedRep l)). MVar# d a -> a -> State# d -> (# State# d, Int# #)
  tryReadMVar# :: forall {l :: Levity} d (a :: TYPE (BoxedRep l)). MVar# d a -> State# d -> (# State# d, Int#, a #)
  tryTakeMVar# :: forall {l :: Levity} d (a :: TYPE (BoxedRep l)). MVar# d a -> State# d -> (# State# d, Int#, a #)
  unIO :: forall a. IO a -> State# RealWorld -> (# State# RealWorld, a #)
  uncheckedIShiftL# :: Int# -> Int# -> Int#
  uncheckedIShiftL64# :: Int64# -> Int# -> Int64#
  uncheckedIShiftRA# :: Int# -> Int# -> Int#
  uncheckedIShiftRA64# :: Int64# -> Int# -> Int64#
  uncheckedIShiftRL# :: Int# -> Int# -> Int#
  uncheckedIShiftRL64# :: Int64# -> Int# -> Int64#
  uncheckedShiftL# :: Word# -> Int# -> Word#
  uncheckedShiftL64# :: Word64# -> Int# -> Word64#
  uncheckedShiftLInt16# :: Int16# -> Int# -> Int16#
  uncheckedShiftLInt32# :: Int32# -> Int# -> Int32#
  uncheckedShiftLInt8# :: Int8# -> Int# -> Int8#
  uncheckedShiftLWord16# :: Word16# -> Int# -> Word16#
  uncheckedShiftLWord32# :: Word32# -> Int# -> Word32#
  uncheckedShiftLWord8# :: Word8# -> Int# -> Word8#
  uncheckedShiftRAInt16# :: Int16# -> Int# -> Int16#
  uncheckedShiftRAInt32# :: Int32# -> Int# -> Int32#
  uncheckedShiftRAInt8# :: Int8# -> Int# -> Int8#
  uncheckedShiftRL# :: Word# -> Int# -> Word#
  uncheckedShiftRL64# :: Word64# -> Int# -> Word64#
  uncheckedShiftRLInt16# :: Int16# -> Int# -> Int16#
  uncheckedShiftRLInt32# :: Int32# -> Int# -> Int32#
  uncheckedShiftRLInt8# :: Int8# -> Int# -> Int8#
  uncheckedShiftRLWord16# :: Word16# -> Int# -> Word16#
  uncheckedShiftRLWord32# :: Word32# -> Int# -> Word32#
  uncheckedShiftRLWord8# :: Word8# -> Int# -> Word8#
  undefined :: forall (r :: RuntimeRep) (a :: TYPE r). GHC.Internal.Stack.Types.HasCallStack => a
  unmaskAsyncExceptions# :: forall {q :: RuntimeRep} (a :: TYPE q). (State# RealWorld -> (# State# RealWorld, a #)) -> State# RealWorld -> (# State# RealWorld, a #)
  unpackAppendCString# :: Addr# -> [Char] -> [Char]
  unpackAppendCStringUtf8# :: Addr# -> [Char] -> [Char]
  unpackCString# :: Addr# -> [Char]
  unpackCStringUtf8# :: Addr# -> [Char]
  unpackClosure# :: forall a b. a -> (# Addr#, ByteArray#, Array# b #)
  unpackDoubleX2# :: DoubleX2# -> (# Double#, Double# #)
  unpackDoubleX4# :: DoubleX4# -> (# Double#, Double#, Double#, Double# #)
  unpackDoubleX8# :: DoubleX8# -> (# Double#, Double#, Double#, Double#, Double#, Double#, Double#, Double# #)
  unpackFloatX16# :: FloatX16# -> (# Float#, Float#, Float#, Float#, Float#, Float#, Float#, Float#, Float#, Float#, Float#, Float#, Float#, Float#, Float#, Float# #)
  unpackFloatX4# :: FloatX4# -> (# Float#, Float#, Float#, Float# #)
  unpackFloatX8# :: FloatX8# -> (# Float#, Float#, Float#, Float#, Float#, Float#, Float#, Float# #)
  unpackFoldrCString# :: forall a. Addr# -> (Char -> a -> a) -> a -> a
  unpackFoldrCStringUtf8# :: forall a. Addr# -> (Char -> a -> a) -> a -> a
  unpackInt16X16# :: Int16X16# -> (# Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16# #)
  unpackInt16X32# :: Int16X32# -> (# Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16# #)
  unpackInt16X8# :: Int16X8# -> (# Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16# #)
  unpackInt32X16# :: Int32X16# -> (# Int32#, Int32#, Int32#, Int32#, Int32#, Int32#, Int32#, Int32#, Int32#, Int32#, Int32#, Int32#, Int32#, Int32#, Int32#, Int32# #)
  unpackInt32X4# :: Int32X4# -> (# Int32#, Int32#, Int32#, Int32# #)
  unpackInt32X8# :: Int32X8# -> (# Int32#, Int32#, Int32#, Int32#, Int32#, Int32#, Int32#, Int32# #)
  unpackInt64X2# :: Int64X2# -> (# Int64#, Int64# #)
  unpackInt64X4# :: Int64X4# -> (# Int64#, Int64#, Int64#, Int64# #)
  unpackInt64X8# :: Int64X8# -> (# Int64#, Int64#, Int64#, Int64#, Int64#, Int64#, Int64#, Int64# #)
  unpackInt8X16# :: Int8X16# -> (# Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8# #)
  unpackInt8X32# :: Int8X32# -> (# Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8# #)
  unpackInt8X64# :: Int8X64# -> (# Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8# #)
  unpackNBytes# :: Addr# -> Int# -> [Char]
  unpackWord16X16# :: Word16X16# -> (# Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16# #)
  unpackWord16X32# :: Word16X32# -> (# Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16# #)
  unpackWord16X8# :: Word16X8# -> (# Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16# #)
  unpackWord32X16# :: Word32X16# -> (# Word32#, Word32#, Word32#, Word32#, Word32#, Word32#, Word32#, Word32#, Word32#, Word32#, Word32#, Word32#, Word32#, Word32#, Word32#, Word32# #)
  unpackWord32X4# :: Word32X4# -> (# Word32#, Word32#, Word32#, Word32# #)
  unpackWord32X8# :: Word32X8# -> (# Word32#, Word32#, Word32#, Word32#, Word32#, Word32#, Word32#, Word32# #)
  unpackWord64X2# :: Word64X2# -> (# Word64#, Word64# #)
  unpackWord64X4# :: Word64X4# -> (# Word64#, Word64#, Word64#, Word64# #)
  unpackWord64X8# :: Word64X8# -> (# Word64#, Word64#, Word64#, Word64#, Word64#, Word64#, Word64#, Word64# #)
  unpackWord8X16# :: Word8X16# -> (# Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8# #)
  unpackWord8X32# :: Word8X32# -> (# Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8# #)
  unpackWord8X64# :: Word8X64# -> (# Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8# #)
  unsafeChr :: Int -> Char
  unsafeFreezeArray# :: forall {l :: Levity} d (a :: TYPE (BoxedRep l)). MutableArray# d a -> State# d -> (# State# d, Array# a #)
  unsafeFreezeByteArray# :: forall d. MutableByteArray# d -> State# d -> (# State# d, ByteArray# #)
  unsafeFreezeSmallArray# :: forall {l :: Levity} d (a :: TYPE (BoxedRep l)). SmallMutableArray# d a -> State# d -> (# State# d, SmallArray# a #)
  unsafePtrEquality# :: forall (a :: UnliftedType) (b :: UnliftedType). a -> b -> Int#
  unsafeThawArray# :: forall {l :: Levity} (a :: TYPE (BoxedRep l)) d. Array# a -> State# d -> (# State# d, MutableArray# d a #)
  unsafeThawByteArray# :: forall d. ByteArray# -> State# d -> (# State# d, MutableByteArray# d #)
  unsafeThawSmallArray# :: forall {l :: Levity} (a :: TYPE (BoxedRep l)) d. SmallArray# a -> State# d -> (# State# d, SmallMutableArray# d a #)
  until :: forall a. (a -> Bool) -> (a -> a) -> a -> a
  vacuous :: forall (f :: * -> *) a. Functor f => f Void -> f a
  void# :: (# #)
  waitRead# :: forall d. Int# -> State# d -> State# d
  waitWrite# :: forall d. Int# -> State# d -> State# d
  when :: forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
  whereFrom# :: forall a d. a -> State# d -> (# State# d, Addr# #)
  word16ToInt16# :: Word16# -> Int16#
  word16ToWord# :: Word16# -> Word#
  word2Double# :: Word# -> Double#
  word2Float# :: Word# -> Float#
  word2Int# :: Word# -> Int#
  word32ToInt32# :: Word32# -> Int32#
  word32ToWord# :: Word32# -> Word#
  word64ToInt64# :: Word64# -> Int64#
  word64ToWord# :: Word64# -> Word#
  word8ToInt8# :: Word8# -> Int8#
  word8ToWord# :: Word8# -> Word#
  wordToWord16# :: Word# -> Word16#
  wordToWord32# :: Word# -> Word32#
  wordToWord64# :: Word# -> Word64#
  wordToWord8# :: Word# -> Word8#
  writeAddrArray# :: forall d. MutableByteArray# d -> Int# -> Addr# -> State# d -> State# d
  writeAddrOffAddr# :: forall d. Addr# -> Int# -> Addr# -> State# d -> State# d
  writeArray# :: forall {l :: Levity} d (a :: TYPE (BoxedRep l)). MutableArray# d a -> Int# -> a -> State# d -> State# d
  writeCharArray# :: forall d. MutableByteArray# d -> Int# -> Char# -> State# d -> State# d
  writeCharOffAddr# :: forall d. Addr# -> Int# -> Char# -> State# d -> State# d
  writeDoubleArray# :: forall d. MutableByteArray# d -> Int# -> Double# -> State# d -> State# d
  writeDoubleArrayAsDoubleX2# :: forall d. MutableByteArray# d -> Int# -> DoubleX2# -> State# d -> State# d
  writeDoubleArrayAsDoubleX4# :: forall d. MutableByteArray# d -> Int# -> DoubleX4# -> State# d -> State# d
  writeDoubleArrayAsDoubleX8# :: forall d. MutableByteArray# d -> Int# -> DoubleX8# -> State# d -> State# d
  writeDoubleOffAddr# :: forall d. Addr# -> Int# -> Double# -> State# d -> State# d
  writeDoubleOffAddrAsDoubleX2# :: forall d. Addr# -> Int# -> DoubleX2# -> State# d -> State# d
  writeDoubleOffAddrAsDoubleX4# :: forall d. Addr# -> Int# -> DoubleX4# -> State# d -> State# d
  writeDoubleOffAddrAsDoubleX8# :: forall d. Addr# -> Int# -> DoubleX8# -> State# d -> State# d
  writeDoubleX2Array# :: forall d. MutableByteArray# d -> Int# -> DoubleX2# -> State# d -> State# d
  writeDoubleX2OffAddr# :: forall d. Addr# -> Int# -> DoubleX2# -> State# d -> State# d
  writeDoubleX4Array# :: forall d. MutableByteArray# d -> Int# -> DoubleX4# -> State# d -> State# d
  writeDoubleX4OffAddr# :: forall d. Addr# -> Int# -> DoubleX4# -> State# d -> State# d
  writeDoubleX8Array# :: forall d. MutableByteArray# d -> Int# -> DoubleX8# -> State# d -> State# d
  writeDoubleX8OffAddr# :: forall d. Addr# -> Int# -> DoubleX8# -> State# d -> State# d
  writeFloatArray# :: forall d. MutableByteArray# d -> Int# -> Float# -> State# d -> State# d
  writeFloatArrayAsFloatX16# :: forall d. MutableByteArray# d -> Int# -> FloatX16# -> State# d -> State# d
  writeFloatArrayAsFloatX4# :: forall d. MutableByteArray# d -> Int# -> FloatX4# -> State# d -> State# d
  writeFloatArrayAsFloatX8# :: forall d. MutableByteArray# d -> Int# -> FloatX8# -> State# d -> State# d
  writeFloatOffAddr# :: forall d. Addr# -> Int# -> Float# -> State# d -> State# d
  writeFloatOffAddrAsFloatX16# :: forall d. Addr# -> Int# -> FloatX16# -> State# d -> State# d
  writeFloatOffAddrAsFloatX4# :: forall d. Addr# -> Int# -> FloatX4# -> State# d -> State# d
  writeFloatOffAddrAsFloatX8# :: forall d. Addr# -> Int# -> FloatX8# -> State# d -> State# d
  writeFloatX16Array# :: forall d. MutableByteArray# d -> Int# -> FloatX16# -> State# d -> State# d
  writeFloatX16OffAddr# :: forall d. Addr# -> Int# -> FloatX16# -> State# d -> State# d
  writeFloatX4Array# :: forall d. MutableByteArray# d -> Int# -> FloatX4# -> State# d -> State# d
  writeFloatX4OffAddr# :: forall d. Addr# -> Int# -> FloatX4# -> State# d -> State# d
  writeFloatX8Array# :: forall d. MutableByteArray# d -> Int# -> FloatX8# -> State# d -> State# d
  writeFloatX8OffAddr# :: forall d. Addr# -> Int# -> FloatX8# -> State# d -> State# d
  writeIOPort# :: forall {l :: Levity} d (a :: TYPE (BoxedRep l)). IOPort# d a -> a -> State# d -> (# State# d, Int# #)
  writeInt16Array# :: forall d. MutableByteArray# d -> Int# -> Int16# -> State# d -> State# d
  writeInt16ArrayAsInt16X16# :: forall d. MutableByteArray# d -> Int# -> Int16X16# -> State# d -> State# d
  writeInt16ArrayAsInt16X32# :: forall d. MutableByteArray# d -> Int# -> Int16X32# -> State# d -> State# d
  writeInt16ArrayAsInt16X8# :: forall d. MutableByteArray# d -> Int# -> Int16X8# -> State# d -> State# d
  writeInt16OffAddr# :: forall d. Addr# -> Int# -> Int16# -> State# d -> State# d
  writeInt16OffAddrAsInt16X16# :: forall d. Addr# -> Int# -> Int16X16# -> State# d -> State# d
  writeInt16OffAddrAsInt16X32# :: forall d. Addr# -> Int# -> Int16X32# -> State# d -> State# d
  writeInt16OffAddrAsInt16X8# :: forall d. Addr# -> Int# -> Int16X8# -> State# d -> State# d
  writeInt16X16Array# :: forall d. MutableByteArray# d -> Int# -> Int16X16# -> State# d -> State# d
  writeInt16X16OffAddr# :: forall d. Addr# -> Int# -> Int16X16# -> State# d -> State# d
  writeInt16X32Array# :: forall d. MutableByteArray# d -> Int# -> Int16X32# -> State# d -> State# d
  writeInt16X32OffAddr# :: forall d. Addr# -> Int# -> Int16X32# -> State# d -> State# d
  writeInt16X8Array# :: forall d. MutableByteArray# d -> Int# -> Int16X8# -> State# d -> State# d
  writeInt16X8OffAddr# :: forall d. Addr# -> Int# -> Int16X8# -> State# d -> State# d
  writeInt32Array# :: forall d. MutableByteArray# d -> Int# -> Int32# -> State# d -> State# d
  writeInt32ArrayAsInt32X16# :: forall d. MutableByteArray# d -> Int# -> Int32X16# -> State# d -> State# d
  writeInt32ArrayAsInt32X4# :: forall d. MutableByteArray# d -> Int# -> Int32X4# -> State# d -> State# d
  writeInt32ArrayAsInt32X8# :: forall d. MutableByteArray# d -> Int# -> Int32X8# -> State# d -> State# d
  writeInt32OffAddr# :: forall d. Addr# -> Int# -> Int32# -> State# d -> State# d
  writeInt32OffAddrAsInt32X16# :: forall d. Addr# -> Int# -> Int32X16# -> State# d -> State# d
  writeInt32OffAddrAsInt32X4# :: forall d. Addr# -> Int# -> Int32X4# -> State# d -> State# d
  writeInt32OffAddrAsInt32X8# :: forall d. Addr# -> Int# -> Int32X8# -> State# d -> State# d
  writeInt32X16Array# :: forall d. MutableByteArray# d -> Int# -> Int32X16# -> State# d -> State# d
  writeInt32X16OffAddr# :: forall d. Addr# -> Int# -> Int32X16# -> State# d -> State# d
  writeInt32X4Array# :: forall d. MutableByteArray# d -> Int# -> Int32X4# -> State# d -> State# d
  writeInt32X4OffAddr# :: forall d. Addr# -> Int# -> Int32X4# -> State# d -> State# d
  writeInt32X8Array# :: forall d. MutableByteArray# d -> Int# -> Int32X8# -> State# d -> State# d
  writeInt32X8OffAddr# :: forall d. Addr# -> Int# -> Int32X8# -> State# d -> State# d
  writeInt64Array# :: forall d. MutableByteArray# d -> Int# -> Int64# -> State# d -> State# d
  writeInt64ArrayAsInt64X2# :: forall d. MutableByteArray# d -> Int# -> Int64X2# -> State# d -> State# d
  writeInt64ArrayAsInt64X4# :: forall d. MutableByteArray# d -> Int# -> Int64X4# -> State# d -> State# d
  writeInt64ArrayAsInt64X8# :: forall d. MutableByteArray# d -> Int# -> Int64X8# -> State# d -> State# d
  writeInt64OffAddr# :: forall d. Addr# -> Int# -> Int64# -> State# d -> State# d
  writeInt64OffAddrAsInt64X2# :: forall d. Addr# -> Int# -> Int64X2# -> State# d -> State# d
  writeInt64OffAddrAsInt64X4# :: forall d. Addr# -> Int# -> Int64X4# -> State# d -> State# d
  writeInt64OffAddrAsInt64X8# :: forall d. Addr# -> Int# -> Int64X8# -> State# d -> State# d
  writeInt64X2Array# :: forall d. MutableByteArray# d -> Int# -> Int64X2# -> State# d -> State# d
  writeInt64X2OffAddr# :: forall d. Addr# -> Int# -> Int64X2# -> State# d -> State# d
  writeInt64X4Array# :: forall d. MutableByteArray# d -> Int# -> Int64X4# -> State# d -> State# d
  writeInt64X4OffAddr# :: forall d. Addr# -> Int# -> Int64X4# -> State# d -> State# d
  writeInt64X8Array# :: forall d. MutableByteArray# d -> Int# -> Int64X8# -> State# d -> State# d
  writeInt64X8OffAddr# :: forall d. Addr# -> Int# -> Int64X8# -> State# d -> State# d
  writeInt8Array# :: forall d. MutableByteArray# d -> Int# -> Int8# -> State# d -> State# d
  writeInt8ArrayAsInt8X16# :: forall d. MutableByteArray# d -> Int# -> Int8X16# -> State# d -> State# d
  writeInt8ArrayAsInt8X32# :: forall d. MutableByteArray# d -> Int# -> Int8X32# -> State# d -> State# d
  writeInt8ArrayAsInt8X64# :: forall d. MutableByteArray# d -> Int# -> Int8X64# -> State# d -> State# d
  writeInt8OffAddr# :: forall d. Addr# -> Int# -> Int8# -> State# d -> State# d
  writeInt8OffAddrAsInt8X16# :: forall d. Addr# -> Int# -> Int8X16# -> State# d -> State# d
  writeInt8OffAddrAsInt8X32# :: forall d. Addr# -> Int# -> Int8X32# -> State# d -> State# d
  writeInt8OffAddrAsInt8X64# :: forall d. Addr# -> Int# -> Int8X64# -> State# d -> State# d
  writeInt8X16Array# :: forall d. MutableByteArray# d -> Int# -> Int8X16# -> State# d -> State# d
  writeInt8X16OffAddr# :: forall d. Addr# -> Int# -> Int8X16# -> State# d -> State# d
  writeInt8X32Array# :: forall d. MutableByteArray# d -> Int# -> Int8X32# -> State# d -> State# d
  writeInt8X32OffAddr# :: forall d. Addr# -> Int# -> Int8X32# -> State# d -> State# d
  writeInt8X64Array# :: forall d. MutableByteArray# d -> Int# -> Int8X64# -> State# d -> State# d
  writeInt8X64OffAddr# :: forall d. Addr# -> Int# -> Int8X64# -> State# d -> State# d
  writeIntArray# :: forall d. MutableByteArray# d -> Int# -> Int# -> State# d -> State# d
  writeIntOffAddr# :: forall d. Addr# -> Int# -> Int# -> State# d -> State# d
  writeMutVar# :: forall {l :: Levity} d (a :: TYPE (BoxedRep l)). MutVar# d a -> a -> State# d -> State# d
  writeSmallArray# :: forall {l :: Levity} d (a :: TYPE (BoxedRep l)). SmallMutableArray# d a -> Int# -> a -> State# d -> State# d
  writeStablePtrArray# :: forall d a. MutableByteArray# d -> Int# -> StablePtr# a -> State# d -> State# d
  writeStablePtrOffAddr# :: forall a d. Addr# -> Int# -> StablePtr# a -> State# d -> State# d
  writeTVar# :: forall {l :: Levity} d (a :: TYPE (BoxedRep l)). TVar# d a -> a -> State# d -> State# d
  writeWideCharArray# :: forall d. MutableByteArray# d -> Int# -> Char# -> State# d -> State# d
  writeWideCharOffAddr# :: forall d. Addr# -> Int# -> Char# -> State# d -> State# d
  writeWord16Array# :: forall d. MutableByteArray# d -> Int# -> Word16# -> State# d -> State# d
  writeWord16ArrayAsWord16X16# :: forall d. MutableByteArray# d -> Int# -> Word16X16# -> State# d -> State# d
  writeWord16ArrayAsWord16X32# :: forall d. MutableByteArray# d -> Int# -> Word16X32# -> State# d -> State# d
  writeWord16ArrayAsWord16X8# :: forall d. MutableByteArray# d -> Int# -> Word16X8# -> State# d -> State# d
  writeWord16OffAddr# :: forall d. Addr# -> Int# -> Word16# -> State# d -> State# d
  writeWord16OffAddrAsWord16X16# :: forall d. Addr# -> Int# -> Word16X16# -> State# d -> State# d
  writeWord16OffAddrAsWord16X32# :: forall d. Addr# -> Int# -> Word16X32# -> State# d -> State# d
  writeWord16OffAddrAsWord16X8# :: forall d. Addr# -> Int# -> Word16X8# -> State# d -> State# d
  writeWord16X16Array# :: forall d. MutableByteArray# d -> Int# -> Word16X16# -> State# d -> State# d
  writeWord16X16OffAddr# :: forall d. Addr# -> Int# -> Word16X16# -> State# d -> State# d
  writeWord16X32Array# :: forall d. MutableByteArray# d -> Int# -> Word16X32# -> State# d -> State# d
  writeWord16X32OffAddr# :: forall d. Addr# -> Int# -> Word16X32# -> State# d -> State# d
  writeWord16X8Array# :: forall d. MutableByteArray# d -> Int# -> Word16X8# -> State# d -> State# d
  writeWord16X8OffAddr# :: forall d. Addr# -> Int# -> Word16X8# -> State# d -> State# d
  writeWord32Array# :: forall d. MutableByteArray# d -> Int# -> Word32# -> State# d -> State# d
  writeWord32ArrayAsWord32X16# :: forall d. MutableByteArray# d -> Int# -> Word32X16# -> State# d -> State# d
  writeWord32ArrayAsWord32X4# :: forall d. MutableByteArray# d -> Int# -> Word32X4# -> State# d -> State# d
  writeWord32ArrayAsWord32X8# :: forall d. MutableByteArray# d -> Int# -> Word32X8# -> State# d -> State# d
  writeWord32OffAddr# :: forall d. Addr# -> Int# -> Word32# -> State# d -> State# d
  writeWord32OffAddrAsWord32X16# :: forall d. Addr# -> Int# -> Word32X16# -> State# d -> State# d
  writeWord32OffAddrAsWord32X4# :: forall d. Addr# -> Int# -> Word32X4# -> State# d -> State# d
  writeWord32OffAddrAsWord32X8# :: forall d. Addr# -> Int# -> Word32X8# -> State# d -> State# d
  writeWord32X16Array# :: forall d. MutableByteArray# d -> Int# -> Word32X16# -> State# d -> State# d
  writeWord32X16OffAddr# :: forall d. Addr# -> Int# -> Word32X16# -> State# d -> State# d
  writeWord32X4Array# :: forall d. MutableByteArray# d -> Int# -> Word32X4# -> State# d -> State# d
  writeWord32X4OffAddr# :: forall d. Addr# -> Int# -> Word32X4# -> State# d -> State# d
  writeWord32X8Array# :: forall d. MutableByteArray# d -> Int# -> Word32X8# -> State# d -> State# d
  writeWord32X8OffAddr# :: forall d. Addr# -> Int# -> Word32X8# -> State# d -> State# d
  writeWord64Array# :: forall d. MutableByteArray# d -> Int# -> Word64# -> State# d -> State# d
  writeWord64ArrayAsWord64X2# :: forall d. MutableByteArray# d -> Int# -> Word64X2# -> State# d -> State# d
  writeWord64ArrayAsWord64X4# :: forall d. MutableByteArray# d -> Int# -> Word64X4# -> State# d -> State# d
  writeWord64ArrayAsWord64X8# :: forall d. MutableByteArray# d -> Int# -> Word64X8# -> State# d -> State# d
  writeWord64OffAddr# :: forall d. Addr# -> Int# -> Word64# -> State# d -> State# d
  writeWord64OffAddrAsWord64X2# :: forall d. Addr# -> Int# -> Word64X2# -> State# d -> State# d
  writeWord64OffAddrAsWord64X4# :: forall d. Addr# -> Int# -> Word64X4# -> State# d -> State# d
  writeWord64OffAddrAsWord64X8# :: forall d. Addr# -> Int# -> Word64X8# -> State# d -> State# d
  writeWord64X2Array# :: forall d. MutableByteArray# d -> Int# -> Word64X2# -> State# d -> State# d
  writeWord64X2OffAddr# :: forall d. Addr# -> Int# -> Word64X2# -> State# d -> State# d
  writeWord64X4Array# :: forall d. MutableByteArray# d -> Int# -> Word64X4# -> State# d -> State# d
  writeWord64X4OffAddr# :: forall d. Addr# -> Int# -> Word64X4# -> State# d -> State# d
  writeWord64X8Array# :: forall d. MutableByteArray# d -> Int# -> Word64X8# -> State# d -> State# d
  writeWord64X8OffAddr# :: forall d. Addr# -> Int# -> Word64X8# -> State# d -> State# d
  writeWord8Array# :: forall d. MutableByteArray# d -> Int# -> Word8# -> State# d -> State# d
  writeWord8ArrayAsAddr# :: forall d. MutableByteArray# d -> Int# -> Addr# -> State# d -> State# d
  writeWord8ArrayAsChar# :: forall d. MutableByteArray# d -> Int# -> Char# -> State# d -> State# d
  writeWord8ArrayAsDouble# :: forall d. MutableByteArray# d -> Int# -> Double# -> State# d -> State# d
  writeWord8ArrayAsFloat# :: forall d. MutableByteArray# d -> Int# -> Float# -> State# d -> State# d
  writeWord8ArrayAsInt# :: forall d. MutableByteArray# d -> Int# -> Int# -> State# d -> State# d
  writeWord8ArrayAsInt16# :: forall d. MutableByteArray# d -> Int# -> Int16# -> State# d -> State# d
  writeWord8ArrayAsInt32# :: forall d. MutableByteArray# d -> Int# -> Int32# -> State# d -> State# d
  writeWord8ArrayAsInt64# :: forall d. MutableByteArray# d -> Int# -> Int64# -> State# d -> State# d
  writeWord8ArrayAsStablePtr# :: forall d a. MutableByteArray# d -> Int# -> StablePtr# a -> State# d -> State# d
  writeWord8ArrayAsWideChar# :: forall d. MutableByteArray# d -> Int# -> Char# -> State# d -> State# d
  writeWord8ArrayAsWord# :: forall d. MutableByteArray# d -> Int# -> Word# -> State# d -> State# d
  writeWord8ArrayAsWord16# :: forall d. MutableByteArray# d -> Int# -> Word16# -> State# d -> State# d
  writeWord8ArrayAsWord32# :: forall d. MutableByteArray# d -> Int# -> Word32# -> State# d -> State# d
  writeWord8ArrayAsWord64# :: forall d. MutableByteArray# d -> Int# -> Word64# -> State# d -> State# d
  writeWord8ArrayAsWord8X16# :: forall d. MutableByteArray# d -> Int# -> Word8X16# -> State# d -> State# d
  writeWord8ArrayAsWord8X32# :: forall d. MutableByteArray# d -> Int# -> Word8X32# -> State# d -> State# d
  writeWord8ArrayAsWord8X64# :: forall d. MutableByteArray# d -> Int# -> Word8X64# -> State# d -> State# d
  writeWord8OffAddr# :: forall d. Addr# -> Int# -> Word8# -> State# d -> State# d
  writeWord8OffAddrAsAddr# :: forall d. Addr# -> Int# -> Addr# -> State# d -> State# d
  writeWord8OffAddrAsChar# :: forall d. Addr# -> Int# -> Char# -> State# d -> State# d
  writeWord8OffAddrAsDouble# :: forall d. Addr# -> Int# -> Double# -> State# d -> State# d
  writeWord8OffAddrAsFloat# :: forall d. Addr# -> Int# -> Float# -> State# d -> State# d
  writeWord8OffAddrAsInt# :: forall d. Addr# -> Int# -> Int# -> State# d -> State# d
  writeWord8OffAddrAsInt16# :: forall d. Addr# -> Int# -> Int16# -> State# d -> State# d
  writeWord8OffAddrAsInt32# :: forall d. Addr# -> Int# -> Int32# -> State# d -> State# d
  writeWord8OffAddrAsInt64# :: forall d. Addr# -> Int# -> Int64# -> State# d -> State# d
  writeWord8OffAddrAsStablePtr# :: forall a d. Addr# -> Int# -> StablePtr# a -> State# d -> State# d
  writeWord8OffAddrAsWideChar# :: forall d. Addr# -> Int# -> Char# -> State# d -> State# d
  writeWord8OffAddrAsWord# :: forall d. Addr# -> Int# -> Word# -> State# d -> State# d
  writeWord8OffAddrAsWord16# :: forall d. Addr# -> Int# -> Word16# -> State# d -> State# d
  writeWord8OffAddrAsWord32# :: forall d. Addr# -> Int# -> Word32# -> State# d -> State# d
  writeWord8OffAddrAsWord64# :: forall d. Addr# -> Int# -> Word64# -> State# d -> State# d
  writeWord8OffAddrAsWord8X16# :: forall d. Addr# -> Int# -> Word8X16# -> State# d -> State# d
  writeWord8OffAddrAsWord8X32# :: forall d. Addr# -> Int# -> Word8X32# -> State# d -> State# d
  writeWord8OffAddrAsWord8X64# :: forall d. Addr# -> Int# -> Word8X64# -> State# d -> State# d
  writeWord8X16Array# :: forall d. MutableByteArray# d -> Int# -> Word8X16# -> State# d -> State# d
  writeWord8X16OffAddr# :: forall d. Addr# -> Int# -> Word8X16# -> State# d -> State# d
  writeWord8X32Array# :: forall d. MutableByteArray# d -> Int# -> Word8X32# -> State# d -> State# d
  writeWord8X32OffAddr# :: forall d. Addr# -> Int# -> Word8X32# -> State# d -> State# d
  writeWord8X64Array# :: forall d. MutableByteArray# d -> Int# -> Word8X64# -> State# d -> State# d
  writeWord8X64OffAddr# :: forall d. Addr# -> Int# -> Word8X64# -> State# d -> State# d
  writeWordArray# :: forall d. MutableByteArray# d -> Int# -> Word# -> State# d -> State# d
  writeWordOffAddr# :: forall d. Addr# -> Int# -> Word# -> State# d -> State# d
  xor# :: Word# -> Word# -> Word#
  xor64# :: Word64# -> Word64# -> Word64#
  xorI# :: Int# -> Int# -> Int#
  xorWord16# :: Word16# -> Word16# -> Word16#
  xorWord32# :: Word32# -> Word32# -> Word32#
  xorWord8# :: Word8# -> Word8# -> Word8#
  yield# :: State# RealWorld -> State# RealWorld
  (||) :: Bool -> Bool -> Bool
  type (~) :: forall k. k -> k -> Constraint
  class (a ~ b) => (~) a b
    {-# MINIMAL #-}
  type (~~) :: forall k0 k1. k0 -> k1 -> Constraint
  class (a ~~ b) => (~~) a b
    {-# MINIMAL #-}

module GHC.Bits where
  -- Safety: Safe
  type Bits :: * -> Constraint
  class GHC.Classes.Eq a => Bits a where
    (.&.) :: a -> a -> a
    (.|.) :: a -> a -> a
    xor :: a -> a -> a
    complement :: a -> a
    shift :: a -> GHC.Types.Int -> a
    rotate :: a -> GHC.Types.Int -> a
    zeroBits :: a
    bit :: GHC.Types.Int -> a
    setBit :: a -> GHC.Types.Int -> a
    clearBit :: a -> GHC.Types.Int -> a
    complementBit :: a -> GHC.Types.Int -> a
    testBit :: a -> GHC.Types.Int -> GHC.Types.Bool
    bitSizeMaybe :: a -> GHC.Internal.Maybe.Maybe GHC.Types.Int
    bitSize :: a -> GHC.Types.Int
    isSigned :: a -> GHC.Types.Bool
    shiftL :: a -> GHC.Types.Int -> a
    unsafeShiftL :: a -> GHC.Types.Int -> a
    shiftR :: a -> GHC.Types.Int -> a
    unsafeShiftR :: a -> GHC.Types.Int -> a
    rotateL :: a -> GHC.Types.Int -> a
    rotateR :: a -> GHC.Types.Int -> a
    popCount :: a -> GHC.Types.Int
    {-# MINIMAL (.&.), (.|.), xor, complement, (shift | (shiftL, shiftR)), (rotate | (rotateL, rotateR)), bitSize, bitSizeMaybe, isSigned, testBit, bit, popCount #-}
  type FiniteBits :: * -> Constraint
  class Bits b => FiniteBits b where
    finiteBitSize :: b -> GHC.Types.Int
    countLeadingZeros :: b -> GHC.Types.Int
    countTrailingZeros :: b -> GHC.Types.Int
    {-# MINIMAL finiteBitSize #-}
  bitDefault :: forall a. (Bits a, GHC.Internal.Num.Num a) => GHC.Types.Int -> a
  popCountDefault :: forall a. (Bits a, GHC.Internal.Num.Num a) => a -> GHC.Types.Int
  testBitDefault :: forall a. (Bits a, GHC.Internal.Num.Num a) => a -> GHC.Types.Int -> GHC.Types.Bool
  toIntegralSized :: forall a b. (GHC.Internal.Real.Integral a, GHC.Internal.Real.Integral b, Bits a, Bits b) => a -> GHC.Internal.Maybe.Maybe b

module GHC.ByteOrder where
  -- Safety: Safe
  type ByteOrder :: *
  data ByteOrder = BigEndian | LittleEndian
  targetByteOrder :: ByteOrder

module GHC.Char where
  -- Safety: Safe
  chr :: GHC.Types.Int -> GHC.Types.Char
  eqChar :: GHC.Types.Char -> GHC.Types.Char -> GHC.Types.Bool
  neChar :: GHC.Types.Char -> GHC.Types.Char -> GHC.Types.Bool

module GHC.Clock where
  -- Safety: Safe
  getMonotonicTime :: GHC.Types.IO GHC.Types.Double
  getMonotonicTimeNSec :: GHC.Types.IO GHC.Internal.Word.Word64

module GHC.Conc where
  -- Safety: Unsafe
  type BlockReason :: *
  data BlockReason = BlockedOnMVar | BlockedOnBlackHole | BlockedOnException | BlockedOnSTM | BlockedOnForeignCall | BlockedOnOther
  type HandlerFun :: *
  type HandlerFun = GHC.Internal.ForeignPtr.ForeignPtr GHC.Internal.Word.Word8 -> GHC.Types.IO ()
  type PrimMVar :: *
  data PrimMVar
  type STM :: * -> *
  newtype STM a = STM (GHC.Prim.State# GHC.Prim.RealWorld -> (# GHC.Prim.State# GHC.Prim.RealWorld, a #))
  type Signal :: *
  type Signal = GHC.Internal.Foreign.C.Types.CInt
  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.Internal.Exception.Type.Exception e => STM a -> (e -> STM a) -> STM a
  childHandler :: GHC.Internal.Exception.Type.SomeException -> GHC.Types.IO ()
  closeFdWith :: (GHC.Internal.System.Posix.Types.Fd -> GHC.Types.IO ()) -> GHC.Internal.System.Posix.Types.Fd -> GHC.Types.IO ()
  disableAllocationLimit :: GHC.Types.IO ()
  enableAllocationLimit :: GHC.Types.IO ()
  ensureIOManagerIsRunning :: 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
  getAllocationCounter :: GHC.Types.IO GHC.Internal.Int.Int64
  getNumCapabilities :: GHC.Types.IO GHC.Types.Int
  getNumProcessors :: GHC.Types.IO GHC.Types.Int
  getUncaughtExceptionHandler :: GHC.Types.IO (GHC.Internal.Exception.Type.SomeException -> GHC.Types.IO ())
  ioManagerCapabilitiesChanged :: GHC.Types.IO ()
  killThread :: ThreadId -> GHC.Types.IO ()
  labelThread :: ThreadId -> GHC.Internal.Base.String -> GHC.Types.IO ()
  listThreads :: GHC.Types.IO [ThreadId]
  mkWeakThreadId :: ThreadId -> GHC.Types.IO (GHC.Internal.Weak.Weak ThreadId)
  myThreadId :: GHC.Types.IO ThreadId
  newStablePtrPrimMVar :: forall a. GHC.Internal.MVar.MVar a -> GHC.Types.IO (GHC.Internal.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
  registerDelay :: GHC.Types.Int -> GHC.Types.IO (TVar GHC.Types.Bool)
  reportError :: GHC.Internal.Exception.Type.SomeException -> GHC.Types.IO ()
  reportHeapOverflow :: GHC.Types.IO ()
  reportStackOverflow :: GHC.Types.IO ()
  retry :: forall a. STM a
  runHandlers :: GHC.Internal.ForeignPtr.ForeignPtr GHC.Internal.Word.Word8 -> Signal -> GHC.Types.IO ()
  runSparks :: GHC.Types.IO ()
  setAllocationCounter :: GHC.Internal.Int.Int64 -> GHC.Types.IO ()
  setHandler :: Signal -> GHC.Internal.Maybe.Maybe (HandlerFun, GHC.Internal.Data.Dynamic.Dynamic) -> GHC.Types.IO (GHC.Internal.Maybe.Maybe (HandlerFun, GHC.Internal.Data.Dynamic.Dynamic))
  setNumCapabilities :: GHC.Types.Int -> GHC.Types.IO ()
  setUncaughtExceptionHandler :: (GHC.Internal.Exception.Type.SomeException -> GHC.Types.IO ()) -> GHC.Types.IO ()
  threadCapability :: ThreadId -> GHC.Types.IO (GHC.Types.Int, GHC.Types.Bool)
  threadDelay :: GHC.Types.Int -> GHC.Types.IO ()
  threadStatus :: ThreadId -> GHC.Types.IO ThreadStatus
  threadWaitRead :: GHC.Internal.System.Posix.Types.Fd -> GHC.Types.IO ()
  threadWaitReadSTM :: GHC.Internal.System.Posix.Types.Fd -> GHC.Types.IO (STM (), GHC.Types.IO ())
  threadWaitWrite :: GHC.Internal.System.Posix.Types.Fd -> GHC.Types.IO ()
  threadWaitWriteSTM :: GHC.Internal.System.Posix.Types.Fd -> GHC.Types.IO (STM (), GHC.Types.IO ())
  throwSTM :: forall e a. GHC.Internal.Exception.Type.Exception e => e -> STM a
  throwTo :: forall e. GHC.Internal.Exception.Type.Exception e => ThreadId -> e -> GHC.Types.IO ()
  unsafeIOToSTM :: forall a. GHC.Types.IO a -> STM a
  withMVar :: forall a b. GHC.Internal.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.Conc.IO where

-- ignored


module GHC.Conc.Signal where
  -- Safety: Safe
  type HandlerFun :: *
  type HandlerFun = GHC.Internal.ForeignPtr.ForeignPtr GHC.Internal.Word.Word8 -> GHC.Types.IO ()
  type Signal :: *
  type Signal = GHC.Internal.Foreign.C.Types.CInt
  runHandlers :: GHC.Internal.ForeignPtr.ForeignPtr GHC.Internal.Word.Word8 -> Signal -> GHC.Types.IO ()
  runHandlersPtr :: GHC.Internal.Ptr.Ptr GHC.Internal.Word.Word8 -> Signal -> GHC.Types.IO ()
  setHandler :: Signal -> GHC.Internal.Maybe.Maybe (HandlerFun, GHC.Internal.Data.Dynamic.Dynamic) -> GHC.Types.IO (GHC.Internal.Maybe.Maybe (HandlerFun, GHC.Internal.Data.Dynamic.Dynamic))

module GHC.Conc.Sync where
  -- Safety: None
  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.Internal.Exception.Type.Exception e => STM a -> (e -> STM a) -> STM a
  childHandler :: GHC.Internal.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.Internal.Word.Word64
  getAllocationCounter :: GHC.Types.IO GHC.Internal.Int.Int64
  getNumCapabilities :: GHC.Types.IO GHC.Types.Int
  getNumProcessors :: GHC.Types.IO GHC.Types.Int
  getUncaughtExceptionHandler :: GHC.Types.IO (GHC.Internal.Exception.Type.SomeException -> GHC.Types.IO ())
  killThread :: ThreadId -> GHC.Types.IO ()
  labelThread :: ThreadId -> GHC.Internal.Base.String -> GHC.Types.IO ()
  labelThreadByteArray# :: ThreadId -> GHC.Prim.ByteArray# -> GHC.Types.IO ()
  listThreads :: GHC.Types.IO [ThreadId]
  mkWeakThreadId :: ThreadId -> GHC.Types.IO (GHC.Internal.Weak.Weak ThreadId)
  modifyMVar_ :: forall a. GHC.Internal.MVar.MVar a -> (a -> GHC.Types.IO a) -> GHC.Types.IO ()
  myThreadId :: GHC.Types.IO ThreadId
  newStablePtrPrimMVar :: forall a. GHC.Internal.MVar.MVar a -> GHC.Types.IO (GHC.Internal.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.Internal.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.Internal.Int.Int64 -> GHC.Types.IO ()
  setNumCapabilities :: GHC.Types.Int -> GHC.Types.IO ()
  setUncaughtExceptionHandler :: (GHC.Internal.Exception.Type.SomeException -> GHC.Types.IO ()) -> GHC.Types.IO ()
  sharedCAF :: forall a. a -> (GHC.Internal.Ptr.Ptr a -> GHC.Types.IO (GHC.Internal.Ptr.Ptr a)) -> GHC.Types.IO a
  showThreadId :: ThreadId -> GHC.Internal.Base.String
  threadCapability :: ThreadId -> GHC.Types.IO (GHC.Types.Int, GHC.Types.Bool)
  threadLabel :: ThreadId -> GHC.Types.IO (GHC.Internal.Maybe.Maybe GHC.Internal.Base.String)
  threadStatus :: ThreadId -> GHC.Types.IO ThreadStatus
  throwSTM :: forall e a. GHC.Internal.Exception.Type.Exception e => e -> STM a
  throwTo :: forall e. GHC.Internal.Exception.Type.Exception e => ThreadId -> e -> GHC.Types.IO ()
  unsafeIOToSTM :: forall a. GHC.Types.IO a -> STM a
  withMVar :: forall a b. GHC.Internal.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: Safe

module GHC.Constants where
  -- Safety: None

module GHC.Desugar where
  -- Safety: Safe
  (>>>) :: forall (arr :: * -> * -> *) a b c. GHC.Internal.Control.Arrow.Arrow arr => arr a b -> arr b c -> arr a c
  type AnnotationWrapper :: *
  data AnnotationWrapper = forall a. GHC.Internal.Data.Data.Data a => AnnotationWrapper a
  toAnnotationWrapper :: forall a. GHC.Internal.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.Internal.Ptr.Ptr GHC.Internal.Word.Word8 -> (GHC.Types.Char, GHC.Types.Int)
  utf8DecodeForeignPtr :: GHC.Internal.ForeignPtr.ForeignPtr GHC.Internal.Word.Word8 -> GHC.Types.Int -> GHC.Types.Int -> [GHC.Types.Char]
  utf8EncodeByteArray# :: GHC.Internal.Base.String -> GHC.Prim.ByteArray#
  utf8EncodePtr :: GHC.Internal.Ptr.Ptr GHC.Internal.Word.Word8 -> GHC.Internal.Base.String -> GHC.Types.IO ()
  utf8EncodedLength :: GHC.Internal.Base.String -> GHC.Types.Int

module GHC.Enum where
  -- Safety: Safe
  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.Internal.Show.Show a => GHC.Internal.Base.String -> a -> b
  predError :: forall a. GHC.Internal.Base.String -> a
  succError :: forall a. GHC.Internal.Base.String -> a
  toEnumError :: forall a b. GHC.Internal.Show.Show a => GHC.Internal.Base.String -> GHC.Types.Int -> (a, a) -> b

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

module GHC.Err where
  -- Safety: Safe
  absentErr :: forall a. a
  error :: forall (r :: GHC.Types.RuntimeRep) (a :: TYPE r). GHC.Internal.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.Internal.Stack.Types.HasCallStack => a

module GHC.Event where
  -- Safety: Safe
  type Event :: *
  newtype Event = ...
  type EventManager :: *
  data EventManager = ...
  type FdKey :: *
  data FdKey
    = ghc-internal-0.1.0.0:GHC.Internal.Event.Manager.FdKey {keyFd :: ! {-# UNPACK #-}(GHC.Internal.System.Posix.Types.N:Fd[0]
                                                                                       ; GHC.Internal.Foreign.C.Types.N:CInt[0])GHC.Internal.System.Posix.Types.Fd,
                                                             ...}
  type IOCallback :: *
  type IOCallback = FdKey -> Event -> GHC.Types.IO ()
  type Lifetime :: *
  data Lifetime = OneShot | MultiShot
  type TimeoutCallback :: *
  type TimeoutCallback = GHC.Types.IO ()
  type TimeoutKey :: *
  newtype TimeoutKey = ...
  type TimerManager :: *
  data TimerManager = ...
  closeFd :: EventManager -> (GHC.Internal.System.Posix.Types.Fd -> GHC.Types.IO ()) -> GHC.Internal.System.Posix.Types.Fd -> GHC.Types.IO ()
  evtRead :: Event
  evtWrite :: Event
  getSystemEventManager :: GHC.Types.IO (GHC.Internal.Maybe.Maybe EventManager)
  getSystemTimerManager :: GHC.Types.IO TimerManager
  new :: GHC.Types.IO EventManager
  registerFd :: EventManager -> IOCallback -> GHC.Internal.System.Posix.Types.Fd -> Event -> Lifetime -> GHC.Types.IO FdKey
  registerTimeout :: TimerManager -> GHC.Types.Int -> TimeoutCallback -> GHC.Types.IO TimeoutKey
  unregisterFd :: EventManager -> FdKey -> GHC.Types.IO ()
  unregisterFd_ :: EventManager -> FdKey -> GHC.Types.IO GHC.Types.Bool
  unregisterTimeout :: TimerManager -> TimeoutKey -> GHC.Types.IO ()
  updateTimeout :: TimerManager -> TimeoutKey -> GHC.Types.Int -> GHC.Types.IO ()

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 ghc-internal-0.1.0.0:GHC.Internal.Event.Unique.Unique
  type TimeoutQueue :: *
  type TimeoutQueue = ghc-internal-0.1.0.0:GHC.Internal.Event.PSQ.PSQ TimeoutCallback

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

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

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

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

module GHC.Exts where
  -- Safety: None
  (*#) :: 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 DataToTag :: forall {lev :: Levity}. TYPE (BoxedRep lev) -> Constraint
  class DataToTag a where
    dataToTag# :: a -> Int#
    {-# MINIMAL dataToTag# #-}
  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.Internal.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 #)
  castDoubleToWord64# :: Double# -> Word64#
  castFloatToWord32# :: Float# -> Word32#
  castWord32ToFloat# :: Word32# -> Float#
  castWord64ToDouble# :: Word64# -> Double#
  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.Internal.Base.String]
  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#
  indexWord8OffAddrAsAddr# :: Addr# -> Int# -> Addr#
  indexWord8OffAddrAsChar# :: Addr# -> Int# -> Char#
  indexWord8OffAddrAsDouble# :: Addr# -> Int# -> Double#
  indexWord8OffAddrAsFloat# :: Addr# -> Int# -> Float#
  indexWord8OffAddrAsInt# :: Addr# -> Int# -> Int#
  indexWord8OffAddrAsInt16# :: Addr# -> Int# -> Int16#
  indexWord8OffAddrAsInt32# :: Addr# -> Int# -> Int32#
  indexWord8OffAddrAsInt64# :: Addr# -> Int# -> Int64#
  indexWord8OffAddrAsStablePtr# :: forall a. Addr# -> Int# -> StablePtr# a
  indexWord8OffAddrAsWideChar# :: Addr# -> Int# -> Char#
  indexWord8OffAddrAsWord# :: Addr# -> Int# -> Word#
  indexWord8OffAddrAsWord16# :: Addr# -> Int# -> Word16#
  indexWord8OffAddrAsWord32# :: Addr# -> Int# -> Word32#
  indexWord8OffAddrAsWord64# :: Addr# -> Int# -> Word64#
  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#
  ltWord64# :: Word64# -> Word64# -> Int#
  ltWord8# :: Word8# -> Word8# -> Int#
  makeStableName# :: forall {l :: Levity} (a :: TYPE (BoxedRep l)). a -> State# RealWorld -> (# State# RealWorld, StableName# a #)
  makeStablePtr# :: forall {l :: Levity} (a :: TYPE (BoxedRep l)). a -> State# RealWorld -> (# State# RealWorld, StablePtr# a #)
  maskAsyncExceptions# :: forall {q :: RuntimeRep} (a :: TYPE q). (State# RealWorld -> (# State# RealWorld, a #)) -> State# RealWorld -> (# State# RealWorld, a #)
  maskUninterruptible# :: forall {q :: RuntimeRep} (a :: TYPE q). (State# RealWorld -> (# State# RealWorld, a #)) -> State# RealWorld -> (# State# RealWorld, a #)
  maxTupleSize :: Int
  minusAddr# :: Addr# -> Addr# -> Int#
  minusDoubleX2# :: DoubleX2# -> DoubleX2# -> DoubleX2#
  minusDoubleX4# :: DoubleX4# -> DoubleX4# -> DoubleX4#
  minusDoubleX8# :: DoubleX8# -> DoubleX8# -> DoubleX8#
  minusFloat# :: Float# -> Float# -> Float#
  minusFloatX16# :: FloatX16# -> FloatX16# -> FloatX16#
  minusFloatX4# :: FloatX4# -> FloatX4# -> FloatX4#
  minusFloatX8# :: FloatX8# -> FloatX8# -> FloatX8#
  minusInt16X16# :: Int16X16# -> Int16X16# -> Int16X16#
  minusInt16X32# :: Int16X32# -> Int16X32# -> Int16X32#
  minusInt16X8# :: Int16X8# -> Int16X8# -> Int16X8#
  minusInt32X16# :: Int32X16# -> Int32X16# -> Int32X16#
  minusInt32X4# :: Int32X4# -> Int32X4# -> Int32X4#
  minusInt32X8# :: Int32X8# -> Int32X8# -> Int32X8#
  minusInt64X2# :: Int64X2# -> Int64X2# -> Int64X2#
  minusInt64X4# :: Int64X4# -> Int64X4# -> Int64X4#
  minusInt64X8# :: Int64X8# -> Int64X8# -> Int64X8#
  minusInt8X16# :: Int8X16# -> Int8X16# -> Int8X16#
  minusInt8X32# :: Int8X32# -> Int8X32# -> Int8X32#
  minusInt8X64# :: Int8X64# -> Int8X64# -> Int8X64#
  minusWord# :: Word# -> Word# -> Word#
  minusWord16X16# :: Word16X16# -> Word16X16# -> Word16X16#
  minusWord16X32# :: Word16X32# -> Word16X32# -> Word16X32#
  minusWord16X8# :: Word16X8# -> Word16X8# -> Word16X8#
  minusWord32X16# :: Word32X16# -> Word32X16# -> Word32X16#
  minusWord32X4# :: Word32X4# -> Word32X4# -> Word32X4#
  minusWord32X8# :: Word32X8# -> Word32X8# -> Word32X8#
  minusWord64X2# :: Word64X2# -> Word64X2# -> Word64X2#
  minusWord64X4# :: Word64X4# -> Word64X4# -> Word64X4#
  minusWord64X8# :: Word64X8# -> Word64X8# -> Word64X8#
  minusWord8X16# :: Word8X16# -> Word8X16# -> Word8X16#
  minusWord8X32# :: Word8X32# -> Word8X32# -> Word8X32#
  minusWord8X64# :: Word8X64# -> Word8X64# -> Word8X64#
  mkApUpd0# :: forall a. BCO -> (# a #)
  mkWeak# :: forall {l :: Levity} {k :: Levity} (a :: TYPE (BoxedRep l)) (b :: TYPE (BoxedRep k)) c. a -> b -> (State# RealWorld -> (# State# RealWorld, c #)) -> State# RealWorld -> (# State# RealWorld, Weak# b #)
  mkWeakNoFinalizer# :: forall {l :: Levity} {k :: Levity} (a :: TYPE (BoxedRep l)) (b :: TYPE (BoxedRep k)). a -> b -> State# RealWorld -> (# State# RealWorld, Weak# b #)
  mulIntMayOflo# :: Int# -> Int# -> Int#
  mutableByteArrayContents# :: forall d. MutableByteArray# d -> Addr#
  myThreadId# :: State# RealWorld -> (# State# RealWorld, ThreadId# #)
  narrow16Int# :: Int# -> Int#
  narrow16Word# :: Word# -> Word#
  narrow32Int# :: Int# -> Int#
  narrow32Word# :: Word# -> Word#
  narrow8Int# :: Int# -> Int#
  narrow8Word# :: Word# -> Word#
  neAddr# :: Addr# -> Addr# -> Int#
  neChar# :: Char# -> Char# -> Int#
  neFloat# :: Float# -> Float# -> Int#
  neInt16# :: Int16# -> Int16# -> Int#
  neInt32# :: Int32# -> Int32# -> Int#
  neInt64# :: Int64# -> Int64# -> Int#
  neInt8# :: Int8# -> Int8# -> Int#
  neWord# :: Word# -> Word# -> Int#
  neWord16# :: Word16# -> Word16# -> Int#
  neWord32# :: Word32# -> Word32# -> Int#
  neWord64# :: Word64# -> Word64# -> Int#
  neWord8# :: Word8# -> Word8# -> Int#
  negateDouble# :: Double# -> Double#
  negateDoubleX2# :: DoubleX2# -> DoubleX2#
  negateDoubleX4# :: DoubleX4# -> DoubleX4#
  negateDoubleX8# :: DoubleX8# -> DoubleX8#
  negateFloat# :: Float# -> Float#
  negateFloatX16# :: FloatX16# -> FloatX16#
  negateFloatX4# :: FloatX4# -> FloatX4#
  negateFloatX8# :: FloatX8# -> FloatX8#
  negateInt# :: Int# -> Int#
  negateInt16# :: Int16# -> Int16#
  negateInt16X16# :: Int16X16# -> Int16X16#
  negateInt16X32# :: Int16X32# -> Int16X32#
  negateInt16X8# :: Int16X8# -> Int16X8#
  negateInt32# :: Int32# -> Int32#
  negateInt32X16# :: Int32X16# -> Int32X16#
  negateInt32X4# :: Int32X4# -> Int32X4#
  negateInt32X8# :: Int32X8# -> Int32X8#
  negateInt64# :: Int64# -> Int64#
  negateInt64X2# :: Int64X2# -> Int64X2#
  negateInt64X4# :: Int64X4# -> Int64X4#
  negateInt64X8# :: Int64X8# -> Int64X8#
  negateInt8# :: Int8# -> Int8#
  negateInt8X16# :: Int8X16# -> Int8X16#
  negateInt8X32# :: Int8X32# -> Int8X32#
  negateInt8X64# :: Int8X64# -> Int8X64#
  newAlignedPinnedByteArray# :: forall d. Int# -> Int# -> State# d -> (# State# d, MutableByteArray# d #)
  newArray# :: forall {l :: Levity} (a :: TYPE (BoxedRep l)) d. Int# -> a -> State# d -> (# State# d, MutableArray# d a #)
  newArrayArray# :: forall s. Int# -> State# s -> (# State# s, MutableArrayArray# s #)
  newBCO# :: forall a d. ByteArray# -> ByteArray# -> Array# a -> Int# -> ByteArray# -> State# d -> (# State# d, BCO #)
  newByteArray# :: forall d. Int# -> State# d -> (# State# d, MutableByteArray# d #)
  newIOPort# :: forall {l :: Levity} d (a :: TYPE (BoxedRep l)). State# d -> (# State# d, IOPort# d a #)
  newMVar# :: forall {l :: Levity} d (a :: TYPE (BoxedRep l)). State# d -> (# State# d, MVar# d a #)
  newMutVar# :: forall {l :: Levity} (a :: TYPE (BoxedRep l)) d. a -> State# d -> (# State# d, MutVar# d a #)
  newPinnedByteArray# :: forall d. Int# -> State# d -> (# State# d, MutableByteArray# d #)
  newPromptTag# :: forall a. State# RealWorld -> (# State# RealWorld, PromptTag# a #)
  newSmallArray# :: forall {l :: Levity} (a :: TYPE (BoxedRep l)) d. Int# -> a -> State# d -> (# State# d, SmallMutableArray# d a #)
  newTVar# :: forall {l :: Levity} (a :: TYPE (BoxedRep l)) d. a -> State# d -> (# State# d, TVar# d a #)
  noDuplicate# :: forall d. State# d -> State# d
  noinline :: forall a. a -> a
  not# :: Word# -> Word#
  not64# :: Word64# -> Word64#
  notI# :: Int# -> Int#
  notWord16# :: Word16# -> Word16#
  notWord32# :: Word32# -> Word32#
  notWord8# :: Word8# -> Word8#
  nullAddr# :: Addr#
  numSparks# :: forall d. State# d -> (# State# d, Int# #)
  oneShot :: forall {q :: RuntimeRep} {r :: RuntimeRep} (a :: TYPE q) (b :: TYPE r). (a -> b) -> a -> b
  or# :: Word# -> Word# -> Word#
  or64# :: Word64# -> Word64# -> Word64#
  orI# :: Int# -> Int# -> Int#
  orWord16# :: Word16# -> Word16# -> Word16#
  orWord32# :: Word32# -> Word32# -> Word32#
  orWord8# :: Word8# -> Word8# -> Word8#
  ord# :: Char# -> Int#
  packDoubleX2# :: (# Double#, Double# #) -> DoubleX2#
  packDoubleX4# :: (# Double#, Double#, Double#, Double# #) -> DoubleX4#
  packDoubleX8# :: (# Double#, Double#, Double#, Double#, Double#, Double#, Double#, Double# #) -> DoubleX8#
  packFloatX16# :: (# Float#, Float#, Float#, Float#, Float#, Float#, Float#, Float#, Float#, Float#, Float#, Float#, Float#, Float#, Float#, Float# #) -> FloatX16#
  packFloatX4# :: (# Float#, Float#, Float#, Float# #) -> FloatX4#
  packFloatX8# :: (# Float#, Float#, Float#, Float#, Float#, Float#, Float#, Float# #) -> FloatX8#
  packInt16X16# :: (# Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16# #) -> Int16X16#
  packInt16X32# :: (# Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16# #) -> Int16X32#
  packInt16X8# :: (# Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16# #) -> Int16X8#
  packInt32X16# :: (# Int32#, Int32#, Int32#, Int32#, Int32#, Int32#, Int32#, Int32#, Int32#, Int32#, Int32#, Int32#, Int32#, Int32#, Int32#, Int32# #) -> Int32X16#
  packInt32X4# :: (# Int32#, Int32#, Int32#, Int32# #) -> Int32X4#
  packInt32X8# :: (# Int32#, Int32#, Int32#, Int32#, Int32#, Int32#, Int32#, Int32# #) -> Int32X8#
  packInt64X2# :: (# Int64#, Int64# #) -> Int64X2#
  packInt64X4# :: (# Int64#, Int64#, Int64#, Int64# #) -> Int64X4#
  packInt64X8# :: (# Int64#, Int64#, Int64#, Int64#, Int64#, Int64#, Int64#, Int64# #) -> Int64X8#
  packInt8X16# :: (# Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8# #) -> Int8X16#
  packInt8X32# :: (# Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8# #) -> Int8X32#
  packInt8X64# :: (# Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8# #) -> Int8X64#
  packWord16X16# :: (# Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16# #) -> Word16X16#
  packWord16X32# :: (# Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16# #) -> Word16X32#
  packWord16X8# :: (# Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16# #) -> Word16X8#
  packWord32X16# :: (# Word32#, Word32#, Word32#, Word32#, Word32#, Word32#, Word32#, Word32#, Word32#, Word32#, Word32#, Word32#, Word32#, Word32#, Word32#, Word32# #) -> Word32X16#
  packWord32X4# :: (# Word32#, Word32#, Word32#, Word32# #) -> Word32X4#
  packWord32X8# :: (# Word32#, Word32#, Word32#, Word32#, Word32#, Word32#, Word32#, Word32# #) -> Word32X8#
  packWord64X2# :: (# Word64#, Word64# #) -> Word64X2#
  packWord64X4# :: (# Word64#, Word64#, Word64#, Word64# #) -> Word64X4#
  packWord64X8# :: (# Word64#, Word64#, Word64#, Word64#, Word64#, Word64#, Word64#, Word64# #) -> Word64X8#
  packWord8X16# :: (# Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8# #) -> Word8X16#
  packWord8X32# :: (# Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8# #) -> Word8X32#
  packWord8X64# :: (# Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8# #) -> Word8X64#
  par# :: forall a. a -> Int#
  pdep# :: Word# -> Word# -> Word#
  pdep16# :: Word# -> Word# -> Word#
  pdep32# :: Word# -> Word# -> Word#
  pdep64# :: Word64# -> Word64# -> Word64#
  pdep8# :: Word# -> Word# -> Word#
  pext# :: Word# -> Word# -> Word#
  pext16# :: Word# -> Word# -> Word#
  pext32# :: Word# -> Word# -> Word#
  pext64# :: Word64# -> Word64# -> Word64#
  pext8# :: Word# -> Word# -> Word#
  plusAddr# :: Addr# -> Int# -> Addr#
  plusDoubleX2# :: DoubleX2# -> DoubleX2# -> DoubleX2#
  plusDoubleX4# :: DoubleX4# -> DoubleX4# -> DoubleX4#
  plusDoubleX8# :: DoubleX8# -> DoubleX8# -> DoubleX8#
  plusFloat# :: Float# -> Float# -> Float#
  plusFloatX16# :: FloatX16# -> FloatX16# -> FloatX16#
  plusFloatX4# :: FloatX4# -> FloatX4# -> FloatX4#
  plusFloatX8# :: FloatX8# -> FloatX8# -> FloatX8#
  plusInt16# :: Int16# -> Int16# -> Int16#
  plusInt16X16# :: Int16X16# -> Int16X16# -> Int16X16#
  plusInt16X32# :: Int16X32# -> Int16X32# -> Int16X32#
  plusInt16X8# :: Int16X8# -> Int16X8# -> Int16X8#
  plusInt32# :: Int32# -> Int32# -> Int32#
  plusInt32X16# :: Int32X16# -> Int32X16# -> Int32X16#
  plusInt32X4# :: Int32X4# -> Int32X4# -> Int32X4#
  plusInt32X8# :: Int32X8# -> Int32X8# -> Int32X8#
  plusInt64# :: Int64# -> Int64# -> Int64#
  plusInt64X2# :: Int64X2# -> Int64X2# -> Int64X2#
  plusInt64X4# :: Int64X4# -> Int64X4# -> Int64X4#
  plusInt64X8# :: Int64X8# -> Int64X8# -> Int64X8#
  plusInt8# :: Int8# -> Int8# -> Int8#
  plusInt8X16# :: Int8X16# -> Int8X16# -> Int8X16#
  plusInt8X32# :: Int8X32# -> Int8X32# -> Int8X32#
  plusInt8X64# :: Int8X64# -> Int8X64# -> Int8X64#
  plusWord# :: Word# -> Word# -> Word#
  plusWord16# :: Word16# -> Word16# -> Word16#
  plusWord16X16# :: Word16X16# -> Word16X16# -> Word16X16#
  plusWord16X32# :: Word16X32# -> Word16X32# -> Word16X32#
  plusWord16X8# :: Word16X8# -> Word16X8# -> Word16X8#
  plusWord2# :: Word# -> Word# -> (# Word#, Word# #)
  plusWord32# :: Word32# -> Word32# -> Word32#
  plusWord32X16# :: Word32X16# -> Word32X16# -> Word32X16#
  plusWord32X4# :: Word32X4# -> Word32X4# -> Word32X4#
  plusWord32X8# :: Word32X8# -> Word32X8# -> Word32X8#
  plusWord64# :: Word64# -> Word64# -> Word64#
  plusWord64X2# :: Word64X2# -> Word64X2# -> Word64X2#
  plusWord64X4# :: Word64X4# -> Word64X4# -> Word64X4#
  plusWord64X8# :: Word64X8# -> Word64X8# -> Word64X8#
  plusWord8# :: Word8# -> Word8# -> Word8#
  plusWord8X16# :: Word8X16# -> Word8X16# -> Word8X16#
  plusWord8X32# :: Word8X32# -> Word8X32# -> Word8X32#
  plusWord8X64# :: Word8X64# -> Word8X64# -> Word8X64#
  popCnt# :: Word# -> Word#
  popCnt16# :: Word# -> Word#
  popCnt32# :: Word# -> Word#
  popCnt64# :: Word64# -> Word#
  popCnt8# :: Word# -> Word#
  powerFloat# :: Float# -> Float# -> Float#
  prefetchAddr0# :: forall d. Addr# -> Int# -> State# d -> State# d
  prefetchAddr1# :: forall d. Addr# -> Int# -> State# d -> State# d
  prefetchAddr2# :: forall d. Addr# -> Int# -> State# d -> State# d
  prefetchAddr3# :: forall d. Addr# -> Int# -> State# d -> State# d
  prefetchByteArray0# :: forall d. ByteArray# -> Int# -> State# d -> State# d
  prefetchByteArray1# :: forall d. ByteArray# -> Int# -> State# d -> State# d
  prefetchByteArray2# :: forall d. ByteArray# -> Int# -> State# d -> State# d
  prefetchByteArray3# :: forall d. ByteArray# -> Int# -> State# d -> State# d
  prefetchMutableByteArray0# :: forall d. MutableByteArray# d -> Int# -> State# d -> State# d
  prefetchMutableByteArray1# :: forall d. MutableByteArray# d -> Int# -> State# d -> State# d
  prefetchMutableByteArray2# :: forall d. MutableByteArray# d -> Int# -> State# d -> State# d
  prefetchMutableByteArray3# :: forall d. MutableByteArray# d -> Int# -> State# d -> State# d
  prefetchValue0# :: forall a d. a -> State# d -> State# d
  prefetchValue1# :: forall a d. a -> State# d -> State# d
  prefetchValue2# :: forall a d. a -> State# d -> State# d
  prefetchValue3# :: forall a d. a -> State# d -> State# d
  prompt# :: forall a. PromptTag# a -> (State# RealWorld -> (# State# RealWorld, a #)) -> State# RealWorld -> (# State# RealWorld, a #)
  proxy# :: forall {k} (a :: k). Proxy# a
  putMVar# :: forall {l :: Levity} d (a :: TYPE (BoxedRep l)). MVar# d a -> a -> State# d -> State# d
  quotInt# :: Int# -> Int# -> Int#
  quotInt16# :: Int16# -> Int16# -> Int16#
  quotInt16X16# :: Int16X16# -> Int16X16# -> Int16X16#
  quotInt16X32# :: Int16X32# -> Int16X32# -> Int16X32#
  quotInt16X8# :: Int16X8# -> Int16X8# -> Int16X8#
  quotInt32# :: Int32# -> Int32# -> Int32#
  quotInt32X16# :: Int32X16# -> Int32X16# -> Int32X16#
  quotInt32X4# :: Int32X4# -> Int32X4# -> Int32X4#
  quotInt32X8# :: Int32X8# -> Int32X8# -> Int32X8#
  quotInt64# :: Int64# -> Int64# -> Int64#
  quotInt64X2# :: Int64X2# -> Int64X2# -> Int64X2#
  quotInt64X4# :: Int64X4# -> Int64X4# -> Int64X4#
  quotInt64X8# :: Int64X8# -> Int64X8# -> Int64X8#
  quotInt8# :: Int8# -> Int8# -> Int8#
  quotInt8X16# :: Int8X16# -> Int8X16# -> Int8X16#
  quotInt8X32# :: Int8X32# -> Int8X32# -> Int8X32#
  quotInt8X64# :: Int8X64# -> Int8X64# -> Int8X64#
  quotRemInt# :: Int# -> Int# -> (# Int#, Int# #)
  quotRemInt16# :: Int16# -> Int16# -> (# Int16#, Int16# #)
  quotRemInt32# :: Int32# -> Int32# -> (# Int32#, Int32# #)
  quotRemInt8# :: Int8# -> Int8# -> (# Int8#, Int8# #)
  quotRemWord# :: Word# -> Word# -> (# Word#, Word# #)
  quotRemWord16# :: Word16# -> Word16# -> (# Word16#, Word16# #)
  quotRemWord2# :: Word# -> Word# -> Word# -> (# Word#, Word# #)
  quotRemWord32# :: Word32# -> Word32# -> (# Word32#, Word32# #)
  quotRemWord8# :: Word8# -> Word8# -> (# Word8#, Word8# #)
  quotWord# :: Word# -> Word# -> Word#
  quotWord16# :: Word16# -> Word16# -> Word16#
  quotWord16X16# :: Word16X16# -> Word16X16# -> Word16X16#
  quotWord16X32# :: Word16X32# -> Word16X32# -> Word16X32#
  quotWord16X8# :: Word16X8# -> Word16X8# -> Word16X8#
  quotWord32# :: Word32# -> Word32# -> Word32#
  quotWord32X16# :: Word32X16# -> Word32X16# -> Word32X16#
  quotWord32X4# :: Word32X4# -> Word32X4# -> Word32X4#
  quotWord32X8# :: Word32X8# -> Word32X8# -> Word32X8#
  quotWord64# :: Word64# -> Word64# -> Word64#
  quotWord64X2# :: Word64X2# -> Word64X2# -> Word64X2#
  quotWord64X4# :: Word64X4# -> Word64X4# -> Word64X4#
  quotWord64X8# :: Word64X8# -> Word64X8# -> Word64X8#
  quotWord8# :: Word8# -> Word8# -> Word8#
  quotWord8X16# :: Word8X16# -> Word8X16# -> Word8X16#
  quotWord8X32# :: Word8X32# -> Word8X32# -> Word8X32#
  quotWord8X64# :: Word8X64# -> Word8X64# -> Word8X64#
  raise# :: forall {l :: Levity} {r :: RuntimeRep} (a :: TYPE (BoxedRep l)) (b :: TYPE r). a -> b
  raiseDivZero# :: forall {r :: RuntimeRep} (b :: TYPE r). (# #) -> b
  raiseIO# :: forall {l :: Levity} {r :: RuntimeRep} (a :: TYPE (BoxedRep l)) (b :: TYPE r). a -> State# RealWorld -> (# State# RealWorld, b #)
  raiseOverflow# :: forall {r :: RuntimeRep} (b :: TYPE r). (# #) -> b
  raiseUnderflow# :: forall {r :: RuntimeRep} (b :: TYPE r). (# #) -> b
  readAddrArray# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Addr# #)
  readAddrOffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Addr# #)
  readArray# :: forall {l :: Levity} d (a :: TYPE (BoxedRep l)). MutableArray# d a -> Int# -> State# d -> (# State# d, a #)
  readArrayArrayArray# :: forall s. MutableArrayArray# s -> Int# -> State# s -> (# State# s, ArrayArray# #)
  readByteArrayArray# :: forall s. MutableArrayArray# s -> Int# -> State# s -> (# State# s, ByteArray# #)
  readCharArray# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Char# #)
  readCharOffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Char# #)
  readDoubleArray# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Double# #)
  readDoubleArrayAsDoubleX2# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, DoubleX2# #)
  readDoubleArrayAsDoubleX4# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, DoubleX4# #)
  readDoubleArrayAsDoubleX8# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, DoubleX8# #)
  readDoubleOffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Double# #)
  readDoubleOffAddrAsDoubleX2# :: forall d. Addr# -> Int# -> State# d -> (# State# d, DoubleX2# #)
  readDoubleOffAddrAsDoubleX4# :: forall d. Addr# -> Int# -> State# d -> (# State# d, DoubleX4# #)
  readDoubleOffAddrAsDoubleX8# :: forall d. Addr# -> Int# -> State# d -> (# State# d, DoubleX8# #)
  readDoubleX2Array# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, DoubleX2# #)
  readDoubleX2OffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, DoubleX2# #)
  readDoubleX4Array# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, DoubleX4# #)
  readDoubleX4OffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, DoubleX4# #)
  readDoubleX8Array# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, DoubleX8# #)
  readDoubleX8OffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, DoubleX8# #)
  readFloatArray# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Float# #)
  readFloatArrayAsFloatX16# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, FloatX16# #)
  readFloatArrayAsFloatX4# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, FloatX4# #)
  readFloatArrayAsFloatX8# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, FloatX8# #)
  readFloatOffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Float# #)
  readFloatOffAddrAsFloatX16# :: forall d. Addr# -> Int# -> State# d -> (# State# d, FloatX16# #)
  readFloatOffAddrAsFloatX4# :: forall d. Addr# -> Int# -> State# d -> (# State# d, FloatX4# #)
  readFloatOffAddrAsFloatX8# :: forall d. Addr# -> Int# -> State# d -> (# State# d, FloatX8# #)
  readFloatX16Array# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, FloatX16# #)
  readFloatX16OffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, FloatX16# #)
  readFloatX4Array# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, FloatX4# #)
  readFloatX4OffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, FloatX4# #)
  readFloatX8Array# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, FloatX8# #)
  readFloatX8OffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, FloatX8# #)
  readIOPort# :: forall {l :: Levity} d (a :: TYPE (BoxedRep l)). IOPort# d a -> State# d -> (# State# d, a #)
  readInt16Array# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Int16# #)
  readInt16ArrayAsInt16X16# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Int16X16# #)
  readInt16ArrayAsInt16X32# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Int16X32# #)
  readInt16ArrayAsInt16X8# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Int16X8# #)
  readInt16OffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Int16# #)
  readInt16OffAddrAsInt16X16# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Int16X16# #)
  readInt16OffAddrAsInt16X32# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Int16X32# #)
  readInt16OffAddrAsInt16X8# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Int16X8# #)
  readInt16X16Array# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Int16X16# #)
  readInt16X16OffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Int16X16# #)
  readInt16X32Array# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Int16X32# #)
  readInt16X32OffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Int16X32# #)
  readInt16X8Array# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Int16X8# #)
  readInt16X8OffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Int16X8# #)
  readInt32Array# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Int32# #)
  readInt32ArrayAsInt32X16# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Int32X16# #)
  readInt32ArrayAsInt32X4# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Int32X4# #)
  readInt32ArrayAsInt32X8# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Int32X8# #)
  readInt32OffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Int32# #)
  readInt32OffAddrAsInt32X16# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Int32X16# #)
  readInt32OffAddrAsInt32X4# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Int32X4# #)
  readInt32OffAddrAsInt32X8# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Int32X8# #)
  readInt32X16Array# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Int32X16# #)
  readInt32X16OffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Int32X16# #)
  readInt32X4Array# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Int32X4# #)
  readInt32X4OffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Int32X4# #)
  readInt32X8Array# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Int32X8# #)
  readInt32X8OffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Int32X8# #)
  readInt64Array# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Int64# #)
  readInt64ArrayAsInt64X2# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Int64X2# #)
  readInt64ArrayAsInt64X4# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Int64X4# #)
  readInt64ArrayAsInt64X8# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Int64X8# #)
  readInt64OffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Int64# #)
  readInt64OffAddrAsInt64X2# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Int64X2# #)
  readInt64OffAddrAsInt64X4# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Int64X4# #)
  readInt64OffAddrAsInt64X8# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Int64X8# #)
  readInt64X2Array# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Int64X2# #)
  readInt64X2OffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Int64X2# #)
  readInt64X4Array# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Int64X4# #)
  readInt64X4OffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Int64X4# #)
  readInt64X8Array# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Int64X8# #)
  readInt64X8OffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Int64X8# #)
  readInt8Array# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Int8# #)
  readInt8ArrayAsInt8X16# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Int8X16# #)
  readInt8ArrayAsInt8X32# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Int8X32# #)
  readInt8ArrayAsInt8X64# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Int8X64# #)
  readInt8OffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Int8# #)
  readInt8OffAddrAsInt8X16# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Int8X16# #)
  readInt8OffAddrAsInt8X32# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Int8X32# #)
  readInt8OffAddrAsInt8X64# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Int8X64# #)
  readInt8X16Array# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Int8X16# #)
  readInt8X16OffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Int8X16# #)
  readInt8X32Array# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Int8X32# #)
  readInt8X32OffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Int8X32# #)
  readInt8X64Array# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Int8X64# #)
  readInt8X64OffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Int8X64# #)
  readIntArray# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Int# #)
  readIntOffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Int# #)
  readMVar# :: forall {l :: Levity} d (a :: TYPE (BoxedRep l)). MVar# d a -> State# d -> (# State# d, a #)
  readMutVar# :: forall {l :: Levity} d (a :: TYPE (BoxedRep l)). MutVar# d a -> State# d -> (# State# d, a #)
  readMutableArrayArrayArray# :: forall s. MutableArrayArray# s -> Int# -> State# s -> (# State# s, MutableArrayArray# s #)
  readMutableByteArrayArray# :: forall s. MutableArrayArray# s -> Int# -> State# s -> (# State# s, MutableByteArray# s #)
  readSmallArray# :: forall {l :: Levity} d (a :: TYPE (BoxedRep l)). SmallMutableArray# d a -> Int# -> State# d -> (# State# d, a #)
  readStablePtrArray# :: forall d a. MutableByteArray# d -> Int# -> State# d -> (# State# d, StablePtr# a #)
  readStablePtrOffAddr# :: forall d a. Addr# -> Int# -> State# d -> (# State# d, StablePtr# a #)
  readTVar# :: forall {l :: Levity} d (a :: TYPE (BoxedRep l)). TVar# d a -> State# d -> (# State# d, a #)
  readTVarIO# :: forall {l :: Levity} d (a :: TYPE (BoxedRep l)). TVar# d a -> State# d -> (# State# d, a #)
  readWideCharArray# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Char# #)
  readWideCharOffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Char# #)
  readWord16Array# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Word16# #)
  readWord16ArrayAsWord16X16# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Word16X16# #)
  readWord16ArrayAsWord16X32# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Word16X32# #)
  readWord16ArrayAsWord16X8# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Word16X8# #)
  readWord16OffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Word16# #)
  readWord16OffAddrAsWord16X16# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Word16X16# #)
  readWord16OffAddrAsWord16X32# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Word16X32# #)
  readWord16OffAddrAsWord16X8# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Word16X8# #)
  readWord16X16Array# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Word16X16# #)
  readWord16X16OffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Word16X16# #)
  readWord16X32Array# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Word16X32# #)
  readWord16X32OffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Word16X32# #)
  readWord16X8Array# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Word16X8# #)
  readWord16X8OffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Word16X8# #)
  readWord32Array# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Word32# #)
  readWord32ArrayAsWord32X16# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Word32X16# #)
  readWord32ArrayAsWord32X4# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Word32X4# #)
  readWord32ArrayAsWord32X8# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Word32X8# #)
  readWord32OffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Word32# #)
  readWord32OffAddrAsWord32X16# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Word32X16# #)
  readWord32OffAddrAsWord32X4# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Word32X4# #)
  readWord32OffAddrAsWord32X8# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Word32X8# #)
  readWord32X16Array# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Word32X16# #)
  readWord32X16OffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Word32X16# #)
  readWord32X4Array# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Word32X4# #)
  readWord32X4OffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Word32X4# #)
  readWord32X8Array# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Word32X8# #)
  readWord32X8OffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Word32X8# #)
  readWord64Array# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Word64# #)
  readWord64ArrayAsWord64X2# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Word64X2# #)
  readWord64ArrayAsWord64X4# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Word64X4# #)
  readWord64ArrayAsWord64X8# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Word64X8# #)
  readWord64OffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Word64# #)
  readWord64OffAddrAsWord64X2# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Word64X2# #)
  readWord64OffAddrAsWord64X4# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Word64X4# #)
  readWord64OffAddrAsWord64X8# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Word64X8# #)
  readWord64X2Array# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Word64X2# #)
  readWord64X2OffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Word64X2# #)
  readWord64X4Array# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Word64X4# #)
  readWord64X4OffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Word64X4# #)
  readWord64X8Array# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Word64X8# #)
  readWord64X8OffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Word64X8# #)
  readWord8Array# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Word8# #)
  readWord8ArrayAsAddr# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Addr# #)
  readWord8ArrayAsChar# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Char# #)
  readWord8ArrayAsDouble# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Double# #)
  readWord8ArrayAsFloat# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Float# #)
  readWord8ArrayAsInt# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Int# #)
  readWord8ArrayAsInt16# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Int16# #)
  readWord8ArrayAsInt32# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Int32# #)
  readWord8ArrayAsInt64# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Int64# #)
  readWord8ArrayAsStablePtr# :: forall d a. MutableByteArray# d -> Int# -> State# d -> (# State# d, StablePtr# a #)
  readWord8ArrayAsWideChar# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Char# #)
  readWord8ArrayAsWord# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Word# #)
  readWord8ArrayAsWord16# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Word16# #)
  readWord8ArrayAsWord32# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Word32# #)
  readWord8ArrayAsWord64# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Word64# #)
  readWord8ArrayAsWord8X16# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Word8X16# #)
  readWord8ArrayAsWord8X32# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Word8X32# #)
  readWord8ArrayAsWord8X64# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Word8X64# #)
  readWord8OffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Word8# #)
  readWord8OffAddrAsAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Addr# #)
  readWord8OffAddrAsChar# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Char# #)
  readWord8OffAddrAsDouble# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Double# #)
  readWord8OffAddrAsFloat# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Float# #)
  readWord8OffAddrAsInt# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Int# #)
  readWord8OffAddrAsInt16# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Int16# #)
  readWord8OffAddrAsInt32# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Int32# #)
  readWord8OffAddrAsInt64# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Int64# #)
  readWord8OffAddrAsStablePtr# :: forall d a. Addr# -> Int# -> State# d -> (# State# d, StablePtr# a #)
  readWord8OffAddrAsWideChar# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Char# #)
  readWord8OffAddrAsWord# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Word# #)
  readWord8OffAddrAsWord16# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Word16# #)
  readWord8OffAddrAsWord32# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Word32# #)
  readWord8OffAddrAsWord64# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Word64# #)
  readWord8OffAddrAsWord8X16# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Word8X16# #)
  readWord8OffAddrAsWord8X32# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Word8X32# #)
  readWord8OffAddrAsWord8X64# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Word8X64# #)
  readWord8X16Array# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Word8X16# #)
  readWord8X16OffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Word8X16# #)
  readWord8X32Array# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Word8X32# #)
  readWord8X32OffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Word8X32# #)
  readWord8X64Array# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Word8X64# #)
  readWord8X64OffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Word8X64# #)
  readWordArray# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Word# #)
  readWordOffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Word# #)
  realWorld# :: State# RealWorld
  reallyUnsafePtrEquality :: forall a. a -> a -> Int#
  reallyUnsafePtrEquality# :: forall {l :: Levity} {k :: Levity} (a :: TYPE (BoxedRep l)) (b :: TYPE (BoxedRep k)). a -> b -> Int#
  remAddr# :: Addr# -> Int# -> Int#
  remInt# :: Int# -> Int# -> Int#
  remInt16# :: Int16# -> Int16# -> Int16#
  remInt16X16# :: Int16X16# -> Int16X16# -> Int16X16#
  remInt16X32# :: Int16X32# -> Int16X32# -> Int16X32#
  remInt16X8# :: Int16X8# -> Int16X8# -> Int16X8#
  remInt32# :: Int32# -> Int32# -> Int32#
  remInt32X16# :: Int32X16# -> Int32X16# -> Int32X16#
  remInt32X4# :: Int32X4# -> Int32X4# -> Int32X4#
  remInt32X8# :: Int32X8# -> Int32X8# -> Int32X8#
  remInt64# :: Int64# -> Int64# -> Int64#
  remInt64X2# :: Int64X2# -> Int64X2# -> Int64X2#
  remInt64X4# :: Int64X4# -> Int64X4# -> Int64X4#
  remInt64X8# :: Int64X8# -> Int64X8# -> Int64X8#
  remInt8# :: Int8# -> Int8# -> Int8#
  remInt8X16# :: Int8X16# -> Int8X16# -> Int8X16#
  remInt8X32# :: Int8X32# -> Int8X32# -> Int8X32#
  remInt8X64# :: Int8X64# -> Int8X64# -> Int8X64#
  remWord# :: Word# -> Word# -> Word#
  remWord16# :: Word16# -> Word16# -> Word16#
  remWord16X16# :: Word16X16# -> Word16X16# -> Word16X16#
  remWord16X32# :: Word16X32# -> Word16X32# -> Word16X32#
  remWord16X8# :: Word16X8# -> Word16X8# -> Word16X8#
  remWord32# :: Word32# -> Word32# -> Word32#
  remWord32X16# :: Word32X16# -> Word32X16# -> Word32X16#
  remWord32X4# :: Word32X4# -> Word32X4# -> Word32X4#
  remWord32X8# :: Word32X8# -> Word32X8# -> Word32X8#
  remWord64# :: Word64# -> Word64# -> Word64#
  remWord64X2# :: Word64X2# -> Word64X2# -> Word64X2#
  remWord64X4# :: Word64X4# -> Word64X4# -> Word64X4#
  remWord64X8# :: Word64X8# -> Word64X8# -> Word64X8#
  remWord8# :: Word8# -> Word8# -> Word8#
  remWord8X16# :: Word8X16# -> Word8X16# -> Word8X16#
  remWord8X32# :: Word8X32# -> Word8X32# -> Word8X32#
  remWord8X64# :: Word8X64# -> Word8X64# -> Word8X64#
  resizeMutableByteArray# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, MutableByteArray# d #)
  resizeSmallMutableArray# :: forall s a. SmallMutableArray# s a -> Int# -> a -> State# s -> (# State# s, SmallMutableArray# s a #)
  retry# :: forall {l :: Levity} (a :: TYPE (BoxedRep l)). State# RealWorld -> (# State# RealWorld, a #)
  rightSection :: forall {q :: RuntimeRep} {r :: RuntimeRep} {s :: RuntimeRep} (a :: TYPE q) (b :: TYPE r) (c :: TYPE s). (a -> b -> c) -> b -> a -> c
  runRW# :: forall (r :: RuntimeRep) (o :: TYPE r). (State# RealWorld -> o) -> o
  sameArray# :: forall {l :: Levity} (a :: TYPE (BoxedRep l)). Array# a -> Array# a -> Int#
  sameArrayArray# :: ArrayArray# -> ArrayArray# -> Int#
  sameByteArray# :: ByteArray# -> ByteArray# -> Int#
  sameIOPort# :: forall {l :: Levity} s (a :: TYPE (BoxedRep l)). IOPort# s a -> IOPort# s a -> Int#
  sameMVar# :: forall {l :: Levity} s (a :: TYPE (BoxedRep l)). MVar# s a -> MVar# s a -> Int#
  sameMutVar# :: forall {l :: Levity} s (a :: TYPE (BoxedRep l)). MutVar# s a -> MutVar# s a -> Int#
  sameMutableArray# :: forall {l :: Levity} s (a :: TYPE (BoxedRep l)). MutableArray# s a -> MutableArray# s a -> Int#
  sameMutableArrayArray# :: forall s. MutableArrayArray# s -> MutableArrayArray# s -> Int#
  sameMutableByteArray# :: forall s. MutableByteArray# s -> MutableByteArray# s -> Int#
  samePromptTag# :: forall a. PromptTag# a -> PromptTag# a -> Int#
  sameSmallArray# :: forall {l :: Levity} (a :: TYPE (BoxedRep l)). SmallArray# a -> SmallArray# a -> Int#
  sameSmallMutableArray# :: forall {l :: Levity} s (a :: TYPE (BoxedRep l)). SmallMutableArray# s a -> SmallMutableArray# s a -> Int#
  sameTVar# :: forall {l :: Levity} s (a :: TYPE (BoxedRep l)). TVar# s a -> TVar# s a -> Int#
  seq :: forall {r :: RuntimeRep} a (b :: TYPE r). a -> b -> b
  seq# :: forall a d. a -> State# d -> (# State# d, a #)
  setAddrRange# :: Addr# -> Int# -> Int# -> State# RealWorld -> State# RealWorld
  setByteArray# :: forall d. MutableByteArray# d -> Int# -> Int# -> Int# -> State# d -> State# d
  setThreadAllocationCounter# :: Int64# -> State# RealWorld -> State# RealWorld
  shiftL# :: Word# -> Int# -> Word#
  shiftRL# :: Word# -> Int# -> Word#
  shrinkMutableByteArray# :: forall d. MutableByteArray# d -> Int# -> State# d -> State# d
  shrinkSmallMutableArray# :: forall {l :: Levity} d (a :: TYPE (BoxedRep l)). SmallMutableArray# d a -> Int# -> State# d -> State# d
  sinDouble# :: Double# -> Double#
  sinFloat# :: Float# -> Float#
  sinhDouble# :: Double# -> Double#
  sinhFloat# :: Float# -> Float#
  sizeofArray# :: forall {l :: Levity} (a :: TYPE (BoxedRep l)). Array# a -> Int#
  sizeofArrayArray# :: ArrayArray# -> Int#
  sizeofByteArray# :: ByteArray# -> Int#
  sizeofMutableArray# :: forall {l :: Levity} d (a :: TYPE (BoxedRep l)). MutableArray# d a -> Int#
  sizeofMutableArrayArray# :: forall s. MutableArrayArray# s -> Int#
  sizeofMutableByteArray# :: forall d. MutableByteArray# d -> Int#
  sizeofSmallArray# :: forall {l :: Levity} (a :: TYPE (BoxedRep l)). SmallArray# a -> Int#
  sizeofSmallMutableArray# :: forall {l :: Levity} d (a :: TYPE (BoxedRep l)). SmallMutableArray# d a -> Int#
  sortWith :: forall b a. GHC.Classes.Ord b => (a -> b) -> [a] -> [a]
  spark# :: forall a d. a -> State# d -> (# State# d, a #)
  sqrtDouble# :: Double# -> Double#
  sqrtFloat# :: Float# -> Float#
  stableNameToInt# :: forall {l :: Levity} (a :: TYPE (BoxedRep l)). StableName# a -> Int#
  subInt16# :: Int16# -> Int16# -> Int16#
  subInt32# :: Int32# -> Int32# -> Int32#
  subInt64# :: Int64# -> Int64# -> Int64#
  subInt8# :: Int8# -> Int8# -> Int8#
  subIntC# :: Int# -> Int# -> (# Int#, Int# #)
  subWord16# :: Word16# -> Word16# -> Word16#
  subWord32# :: Word32# -> Word32# -> Word32#
  subWord64# :: Word64# -> Word64# -> Word64#
  subWord8# :: Word8# -> Word8# -> Word8#
  subWordC# :: Word# -> Word# -> (# Word#, Int# #)
  tagToEnum# :: forall a. Int# -> a
  takeMVar# :: forall {l :: Levity} d (a :: TYPE (BoxedRep l)). MVar# d a -> State# d -> (# State# d, a #)
  tanDouble# :: Double# -> Double#
  tanFloat# :: Float# -> Float#
  tanhDouble# :: Double# -> Double#
  tanhFloat# :: Float# -> Float#
  thawArray# :: forall {l :: Levity} (a :: TYPE (BoxedRep l)) d. Array# a -> Int# -> Int# -> State# d -> (# State# d, MutableArray# d a #)
  thawSmallArray# :: forall {l :: Levity} (a :: TYPE (BoxedRep l)) d. SmallArray# a -> Int# -> Int# -> State# d -> (# State# d, SmallMutableArray# d a #)
  the :: forall a. GHC.Classes.Eq a => [a] -> a
  threadLabel# :: ThreadId# -> State# RealWorld -> (# State# RealWorld, Int#, ByteArray# #)
  threadStatus# :: ThreadId# -> State# RealWorld -> (# State# RealWorld, Int#, Int#, Int# #)
  timesDoubleX2# :: DoubleX2# -> DoubleX2# -> DoubleX2#
  timesDoubleX4# :: DoubleX4# -> DoubleX4# -> DoubleX4#
  timesDoubleX8# :: DoubleX8# -> DoubleX8# -> DoubleX8#
  timesFloat# :: Float# -> Float# -> Float#
  timesFloatX16# :: FloatX16# -> FloatX16# -> FloatX16#
  timesFloatX4# :: FloatX4# -> FloatX4# -> FloatX4#
  timesFloatX8# :: FloatX8# -> FloatX8# -> FloatX8#
  timesInt16# :: Int16# -> Int16# -> Int16#
  timesInt16X16# :: Int16X16# -> Int16X16# -> Int16X16#
  timesInt16X32# :: Int16X32# -> Int16X32# -> Int16X32#
  timesInt16X8# :: Int16X8# -> Int16X8# -> Int16X8#
  timesInt2# :: Int# -> Int# -> (# Int#, Int#, Int# #)
  timesInt32# :: Int32# -> Int32# -> Int32#
  timesInt32X16# :: Int32X16# -> Int32X16# -> Int32X16#
  timesInt32X4# :: Int32X4# -> Int32X4# -> Int32X4#
  timesInt32X8# :: Int32X8# -> Int32X8# -> Int32X8#
  timesInt64# :: Int64# -> Int64# -> Int64#
  timesInt64X2# :: Int64X2# -> Int64X2# -> Int64X2#
  timesInt64X4# :: Int64X4# -> Int64X4# -> Int64X4#
  timesInt64X8# :: Int64X8# -> Int64X8# -> Int64X8#
  timesInt8# :: Int8# -> Int8# -> Int8#
  timesInt8X16# :: Int8X16# -> Int8X16# -> Int8X16#
  timesInt8X32# :: Int8X32# -> Int8X32# -> Int8X32#
  timesInt8X64# :: Int8X64# -> Int8X64# -> Int8X64#
  timesWord# :: Word# -> Word# -> Word#
  timesWord16# :: Word16# -> Word16# -> Word16#
  timesWord16X16# :: Word16X16# -> Word16X16# -> Word16X16#
  timesWord16X32# :: Word16X32# -> Word16X32# -> Word16X32#
  timesWord16X8# :: Word16X8# -> Word16X8# -> Word16X8#
  timesWord2# :: Word# -> Word# -> (# Word#, Word# #)
  timesWord32# :: Word32# -> Word32# -> Word32#
  timesWord32X16# :: Word32X16# -> Word32X16# -> Word32X16#
  timesWord32X4# :: Word32X4# -> Word32X4# -> Word32X4#
  timesWord32X8# :: Word32X8# -> Word32X8# -> Word32X8#
  timesWord64# :: Word64# -> Word64# -> Word64#
  timesWord64X2# :: Word64X2# -> Word64X2# -> Word64X2#
  timesWord64X4# :: Word64X4# -> Word64X4# -> Word64X4#
  timesWord64X8# :: Word64X8# -> Word64X8# -> Word64X8#
  timesWord8# :: Word8# -> Word8# -> Word8#
  timesWord8X16# :: Word8X16# -> Word8X16# -> Word8X16#
  timesWord8X32# :: Word8X32# -> Word8X32# -> Word8X32#
  timesWord8X64# :: Word8X64# -> Word8X64# -> Word8X64#
  touch# :: forall {l :: Levity} (a :: TYPE (BoxedRep l)) d. a -> State# d -> State# d
  traceBinaryEvent# :: forall d. Addr# -> Int# -> State# d -> State# d
  traceEvent :: GHC.Internal.Base.String -> GHC.Types.IO ()
  traceEvent# :: forall d. Addr# -> State# d -> State# d
  traceMarker# :: forall d. Addr# -> State# d -> State# d
  tryPutMVar# :: forall {l :: Levity} d (a :: TYPE (BoxedRep l)). MVar# d a -> a -> State# d -> (# State# d, Int# #)
  tryReadMVar# :: forall {l :: Levity} d (a :: TYPE (BoxedRep l)). MVar# d a -> State# d -> (# State# d, Int#, a #)
  tryTakeMVar# :: forall {l :: Levity} d (a :: TYPE (BoxedRep l)). MVar# d a -> State# d -> (# State# d, Int#, a #)
  uncheckedIShiftL# :: Int# -> Int# -> Int#
  uncheckedIShiftL64# :: Int64# -> Int# -> Int64#
  uncheckedIShiftRA# :: Int# -> Int# -> Int#
  uncheckedIShiftRA64# :: Int64# -> Int# -> Int64#
  uncheckedIShiftRL# :: Int# -> Int# -> Int#
  uncheckedIShiftRL64# :: Int64# -> Int# -> Int64#
  uncheckedShiftL# :: Word# -> Int# -> Word#
  uncheckedShiftL64# :: Word64# -> Int# -> Word64#
  uncheckedShiftLInt16# :: Int16# -> Int# -> Int16#
  uncheckedShiftLInt32# :: Int32# -> Int# -> Int32#
  uncheckedShiftLInt8# :: Int8# -> Int# -> Int8#
  uncheckedShiftLWord16# :: Word16# -> Int# -> Word16#
  uncheckedShiftLWord32# :: Word32# -> Int# -> Word32#
  uncheckedShiftLWord8# :: Word8# -> Int# -> Word8#
  uncheckedShiftRAInt16# :: Int16# -> Int# -> Int16#
  uncheckedShiftRAInt32# :: Int32# -> Int# -> Int32#
  uncheckedShiftRAInt8# :: Int8# -> Int# -> Int8#
  uncheckedShiftRL# :: Word# -> Int# -> Word#
  uncheckedShiftRL64# :: Word64# -> Int# -> Word64#
  uncheckedShiftRLInt16# :: Int16# -> Int# -> Int16#
  uncheckedShiftRLInt32# :: Int32# -> Int# -> Int32#
  uncheckedShiftRLInt8# :: Int8# -> Int# -> Int8#
  uncheckedShiftRLWord16# :: Word16# -> Int# -> Word16#
  uncheckedShiftRLWord32# :: Word32# -> Int# -> Word32#
  uncheckedShiftRLWord8# :: Word8# -> Int# -> Word8#
  unmaskAsyncExceptions# :: forall {q :: RuntimeRep} (a :: TYPE q). (State# RealWorld -> (# State# RealWorld, a #)) -> State# RealWorld -> (# State# RealWorld, a #)
  unpackAppendCString# :: Addr# -> [Char] -> [Char]
  unpackCString# :: Addr# -> [Char]
  unpackCStringUtf8# :: Addr# -> [Char]
  unpackClosure# :: forall a b. a -> (# Addr#, ByteArray#, Array# b #)
  unpackDoubleX2# :: DoubleX2# -> (# Double#, Double# #)
  unpackDoubleX4# :: DoubleX4# -> (# Double#, Double#, Double#, Double# #)
  unpackDoubleX8# :: DoubleX8# -> (# Double#, Double#, Double#, Double#, Double#, Double#, Double#, Double# #)
  unpackFloatX16# :: FloatX16# -> (# Float#, Float#, Float#, Float#, Float#, Float#, Float#, Float#, Float#, Float#, Float#, Float#, Float#, Float#, Float#, Float# #)
  unpackFloatX4# :: FloatX4# -> (# Float#, Float#, Float#, Float# #)
  unpackFloatX8# :: FloatX8# -> (# Float#, Float#, Float#, Float#, Float#, Float#, Float#, Float# #)
  unpackFoldrCString# :: forall a. Addr# -> (Char -> a -> a) -> a -> a
  unpackInt16X16# :: Int16X16# -> (# Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16# #)
  unpackInt16X32# :: Int16X32# -> (# Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16# #)
  unpackInt16X8# :: Int16X8# -> (# Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16# #)
  unpackInt32X16# :: Int32X16# -> (# Int32#, Int32#, Int32#, Int32#, Int32#, Int32#, Int32#, Int32#, Int32#, Int32#, Int32#, Int32#, Int32#, Int32#, Int32#, Int32# #)
  unpackInt32X4# :: Int32X4# -> (# Int32#, Int32#, Int32#, Int32# #)
  unpackInt32X8# :: Int32X8# -> (# Int32#, Int32#, Int32#, Int32#, Int32#, Int32#, Int32#, Int32# #)
  unpackInt64X2# :: Int64X2# -> (# Int64#, Int64# #)
  unpackInt64X4# :: Int64X4# -> (# Int64#, Int64#, Int64#, Int64# #)
  unpackInt64X8# :: Int64X8# -> (# Int64#, Int64#, Int64#, Int64#, Int64#, Int64#, Int64#, Int64# #)
  unpackInt8X16# :: Int8X16# -> (# Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8# #)
  unpackInt8X32# :: Int8X32# -> (# Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8# #)
  unpackInt8X64# :: Int8X64# -> (# Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8# #)
  unpackNBytes# :: Addr# -> Int# -> [Char]
  unpackWord16X16# :: Word16X16# -> (# Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16# #)
  unpackWord16X32# :: Word16X32# -> (# Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16# #)
  unpackWord16X8# :: Word16X8# -> (# Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16# #)
  unpackWord32X16# :: Word32X16# -> (# Word32#, Word32#, Word32#, Word32#, Word32#, Word32#, Word32#, Word32#, Word32#, Word32#, Word32#, Word32#, Word32#, Word32#, Word32#, Word32# #)
  unpackWord32X4# :: Word32X4# -> (# Word32#, Word32#, Word32#, Word32# #)
  unpackWord32X8# :: Word32X8# -> (# Word32#, Word32#, Word32#, Word32#, Word32#, Word32#, Word32#, Word32# #)
  unpackWord64X2# :: Word64X2# -> (# Word64#, Word64# #)
  unpackWord64X4# :: Word64X4# -> (# Word64#, Word64#, Word64#, Word64# #)
  unpackWord64X8# :: Word64X8# -> (# Word64#, Word64#, Word64#, Word64#, Word64#, Word64#, Word64#, Word64# #)
  unpackWord8X16# :: Word8X16# -> (# Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8# #)
  unpackWord8X32# :: Word8X32# -> (# Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8# #)
  unpackWord8X64# :: Word8X64# -> (# Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8# #)
  unsafeCoerce# :: forall (q :: RuntimeRep) (r :: RuntimeRep) (a :: TYPE q) (b :: TYPE r). a -> b
  unsafeFreezeArray# :: forall {l :: Levity} d (a :: TYPE (BoxedRep l)). MutableArray# d a -> State# d -> (# State# d, Array# a #)
  unsafeFreezeArrayArray# :: forall s. MutableArrayArray# s -> State# s -> (# State# s, ArrayArray# #)
  unsafeFreezeByteArray# :: forall d. MutableByteArray# d -> State# d -> (# State# d, ByteArray# #)
  unsafeFreezeSmallArray# :: forall {l :: Levity} d (a :: TYPE (BoxedRep l)). SmallMutableArray# d a -> State# d -> (# State# d, SmallArray# a #)
  unsafePtrEquality# :: forall (a :: UnliftedType) (b :: UnliftedType). a -> b -> Int#
  unsafeThawArray# :: forall {l :: Levity} (a :: TYPE (BoxedRep l)) d. Array# a -> State# d -> (# State# d, MutableArray# d a #)
  unsafeThawByteArray# :: forall d. ByteArray# -> State# d -> (# State# d, MutableByteArray# d #)
  unsafeThawSmallArray# :: forall {l :: Levity} (a :: TYPE (BoxedRep l)) d. SmallArray# a -> State# d -> (# State# d, SmallMutableArray# d a #)
  void# :: (# #)
  waitRead# :: forall d. Int# -> State# d -> State# d
  waitWrite# :: forall d. Int# -> State# d -> State# d
  whereFrom# :: forall a d. a -> State# d -> (# State# d, Addr# #)
  word16ToInt16# :: Word16# -> Int16#
  word16ToWord# :: Word16# -> Word#
  word2Double# :: Word# -> Double#
  word2Float# :: Word# -> Float#
  word2Int# :: Word# -> Int#
  word32ToInt32# :: Word32# -> Int32#
  word32ToWord# :: Word32# -> Word#
  word64ToInt64# :: Word64# -> Int64#
  word64ToWord# :: Word64# -> Word#
  word8ToInt8# :: Word8# -> Int8#
  word8ToWord# :: Word8# -> Word#
  wordToWord16# :: Word# -> Word16#
  wordToWord32# :: Word# -> Word32#
  wordToWord64# :: Word# -> Word64#
  wordToWord8# :: Word# -> Word8#
  writeAddrArray# :: forall d. MutableByteArray# d -> Int# -> Addr# -> State# d -> State# d
  writeAddrOffAddr# :: forall d. Addr# -> Int# -> Addr# -> State# d -> State# d
  writeArray# :: forall {l :: Levity} d (a :: TYPE (BoxedRep l)). MutableArray# d a -> Int# -> a -> State# d -> State# d
  writeArrayArrayArray# :: forall s. MutableArrayArray# s -> Int# -> ArrayArray# -> State# s -> State# s
  writeByteArrayArray# :: forall s. MutableArrayArray# s -> Int# -> ByteArray# -> State# s -> State# s
  writeCharArray# :: forall d. MutableByteArray# d -> Int# -> Char# -> State# d -> State# d
  writeCharOffAddr# :: forall d. Addr# -> Int# -> Char# -> State# d -> State# d
  writeDoubleArray# :: forall d. MutableByteArray# d -> Int# -> Double# -> State# d -> State# d
  writeDoubleArrayAsDoubleX2# :: forall d. MutableByteArray# d -> Int# -> DoubleX2# -> State# d -> State# d
  writeDoubleArrayAsDoubleX4# :: forall d. MutableByteArray# d -> Int# -> DoubleX4# -> State# d -> State# d
  writeDoubleArrayAsDoubleX8# :: forall d. MutableByteArray# d -> Int# -> DoubleX8# -> State# d -> State# d
  writeDoubleOffAddr# :: forall d. Addr# -> Int# -> Double# -> State# d -> State# d
  writeDoubleOffAddrAsDoubleX2# :: forall d. Addr# -> Int# -> DoubleX2# -> State# d -> State# d
  writeDoubleOffAddrAsDoubleX4# :: forall d. Addr# -> Int# -> DoubleX4# -> State# d -> State# d
  writeDoubleOffAddrAsDoubleX8# :: forall d. Addr# -> Int# -> DoubleX8# -> State# d -> State# d
  writeDoubleX2Array# :: forall d. MutableByteArray# d -> Int# -> DoubleX2# -> State# d -> State# d
  writeDoubleX2OffAddr# :: forall d. Addr# -> Int# -> DoubleX2# -> State# d -> State# d
  writeDoubleX4Array# :: forall d. MutableByteArray# d -> Int# -> DoubleX4# -> State# d -> State# d
  writeDoubleX4OffAddr# :: forall d. Addr# -> Int# -> DoubleX4# -> State# d -> State# d
  writeDoubleX8Array# :: forall d. MutableByteArray# d -> Int# -> DoubleX8# -> State# d -> State# d
  writeDoubleX8OffAddr# :: forall d. Addr# -> Int# -> DoubleX8# -> State# d -> State# d
  writeFloatArray# :: forall d. MutableByteArray# d -> Int# -> Float# -> State# d -> State# d
  writeFloatArrayAsFloatX16# :: forall d. MutableByteArray# d -> Int# -> FloatX16# -> State# d -> State# d
  writeFloatArrayAsFloatX4# :: forall d. MutableByteArray# d -> Int# -> FloatX4# -> State# d -> State# d
  writeFloatArrayAsFloatX8# :: forall d. MutableByteArray# d -> Int# -> FloatX8# -> State# d -> State# d
  writeFloatOffAddr# :: forall d. Addr# -> Int# -> Float# -> State# d -> State# d
  writeFloatOffAddrAsFloatX16# :: forall d. Addr# -> Int# -> FloatX16# -> State# d -> State# d
  writeFloatOffAddrAsFloatX4# :: forall d. Addr# -> Int# -> FloatX4# -> State# d -> State# d
  writeFloatOffAddrAsFloatX8# :: forall d. Addr# -> Int# -> FloatX8# -> State# d -> State# d
  writeFloatX16Array# :: forall d. MutableByteArray# d -> Int# -> FloatX16# -> State# d -> State# d
  writeFloatX16OffAddr# :: forall d. Addr# -> Int# -> FloatX16# -> State# d -> State# d
  writeFloatX4Array# :: forall d. MutableByteArray# d -> Int# -> FloatX4# -> State# d -> State# d
  writeFloatX4OffAddr# :: forall d. Addr# -> Int# -> FloatX4# -> State# d -> State# d
  writeFloatX8Array# :: forall d. MutableByteArray# d -> Int# -> FloatX8# -> State# d -> State# d
  writeFloatX8OffAddr# :: forall d. Addr# -> Int# -> FloatX8# -> State# d -> State# d
  writeIOPort# :: forall {l :: Levity} d (a :: TYPE (BoxedRep l)). IOPort# d a -> a -> State# d -> (# State# d, Int# #)
  writeInt16Array# :: forall d. MutableByteArray# d -> Int# -> Int16# -> State# d -> State# d
  writeInt16ArrayAsInt16X16# :: forall d. MutableByteArray# d -> Int# -> Int16X16# -> State# d -> State# d
  writeInt16ArrayAsInt16X32# :: forall d. MutableByteArray# d -> Int# -> Int16X32# -> State# d -> State# d
  writeInt16ArrayAsInt16X8# :: forall d. MutableByteArray# d -> Int# -> Int16X8# -> State# d -> State# d
  writeInt16OffAddr# :: forall d. Addr# -> Int# -> Int16# -> State# d -> State# d
  writeInt16OffAddrAsInt16X16# :: forall d. Addr# -> Int# -> Int16X16# -> State# d -> State# d
  writeInt16OffAddrAsInt16X32# :: forall d. Addr# -> Int# -> Int16X32# -> State# d -> State# d
  writeInt16OffAddrAsInt16X8# :: forall d. Addr# -> Int# -> Int16X8# -> State# d -> State# d
  writeInt16X16Array# :: forall d. MutableByteArray# d -> Int# -> Int16X16# -> State# d -> State# d
  writeInt16X16OffAddr# :: forall d. Addr# -> Int# -> Int16X16# -> State# d -> State# d
  writeInt16X32Array# :: forall d. MutableByteArray# d -> Int# -> Int16X32# -> State# d -> State# d
  writeInt16X32OffAddr# :: forall d. Addr# -> Int# -> Int16X32# -> State# d -> State# d
  writeInt16X8Array# :: forall d. MutableByteArray# d -> Int# -> Int16X8# -> State# d -> State# d
  writeInt16X8OffAddr# :: forall d. Addr# -> Int# -> Int16X8# -> State# d -> State# d
  writeInt32Array# :: forall d. MutableByteArray# d -> Int# -> Int32# -> State# d -> State# d
  writeInt32ArrayAsInt32X16# :: forall d. MutableByteArray# d -> Int# -> Int32X16# -> State# d -> State# d
  writeInt32ArrayAsInt32X4# :: forall d. MutableByteArray# d -> Int# -> Int32X4# -> State# d -> State# d
  writeInt32ArrayAsInt32X8# :: forall d. MutableByteArray# d -> Int# -> Int32X8# -> State# d -> State# d
  writeInt32OffAddr# :: forall d. Addr# -> Int# -> Int32# -> State# d -> State# d
  writeInt32OffAddrAsInt32X16# :: forall d. Addr# -> Int# -> Int32X16# -> State# d -> State# d
  writeInt32OffAddrAsInt32X4# :: forall d. Addr# -> Int# -> Int32X4# -> State# d -> State# d
  writeInt32OffAddrAsInt32X8# :: forall d. Addr# -> Int# -> Int32X8# -> State# d -> State# d
  writeInt32X16Array# :: forall d. MutableByteArray# d -> Int# -> Int32X16# -> State# d -> State# d
  writeInt32X16OffAddr# :: forall d. Addr# -> Int# -> Int32X16# -> State# d -> State# d
  writeInt32X4Array# :: forall d. MutableByteArray# d -> Int# -> Int32X4# -> State# d -> State# d
  writeInt32X4OffAddr# :: forall d. Addr# -> Int# -> Int32X4# -> State# d -> State# d
  writeInt32X8Array# :: forall d. MutableByteArray# d -> Int# -> Int32X8# -> State# d -> State# d
  writeInt32X8OffAddr# :: forall d. Addr# -> Int# -> Int32X8# -> State# d -> State# d
  writeInt64Array# :: forall d. MutableByteArray# d -> Int# -> Int64# -> State# d -> State# d
  writeInt64ArrayAsInt64X2# :: forall d. MutableByteArray# d -> Int# -> Int64X2# -> State# d -> State# d
  writeInt64ArrayAsInt64X4# :: forall d. MutableByteArray# d -> Int# -> Int64X4# -> State# d -> State# d
  writeInt64ArrayAsInt64X8# :: forall d. MutableByteArray# d -> Int# -> Int64X8# -> State# d -> State# d
  writeInt64OffAddr# :: forall d. Addr# -> Int# -> Int64# -> State# d -> State# d
  writeInt64OffAddrAsInt64X2# :: forall d. Addr# -> Int# -> Int64X2# -> State# d -> State# d
  writeInt64OffAddrAsInt64X4# :: forall d. Addr# -> Int# -> Int64X4# -> State# d -> State# d
  writeInt64OffAddrAsInt64X8# :: forall d. Addr# -> Int# -> Int64X8# -> State# d -> State# d
  writeInt64X2Array# :: forall d. MutableByteArray# d -> Int# -> Int64X2# -> State# d -> State# d
  writeInt64X2OffAddr# :: forall d. Addr# -> Int# -> Int64X2# -> State# d -> State# d
  writeInt64X4Array# :: forall d. MutableByteArray# d -> Int# -> Int64X4# -> State# d -> State# d
  writeInt64X4OffAddr# :: forall d. Addr# -> Int# -> Int64X4# -> State# d -> State# d
  writeInt64X8Array# :: forall d. MutableByteArray# d -> Int# -> Int64X8# -> State# d -> State# d
  writeInt64X8OffAddr# :: forall d. Addr# -> Int# -> Int64X8# -> State# d -> State# d
  writeInt8Array# :: forall d. MutableByteArray# d -> Int# -> Int8# -> State# d -> State# d
  writeInt8ArrayAsInt8X16# :: forall d. MutableByteArray# d -> Int# -> Int8X16# -> State# d -> State# d
  writeInt8ArrayAsInt8X32# :: forall d. MutableByteArray# d -> Int# -> Int8X32# -> State# d -> State# d
  writeInt8ArrayAsInt8X64# :: forall d. MutableByteArray# d -> Int# -> Int8X64# -> State# d -> State# d
  writeInt8OffAddr# :: forall d. Addr# -> Int# -> Int8# -> State# d -> State# d
  writeInt8OffAddrAsInt8X16# :: forall d. Addr# -> Int# -> Int8X16# -> State# d -> State# d
  writeInt8OffAddrAsInt8X32# :: forall d. Addr# -> Int# -> Int8X32# -> State# d -> State# d
  writeInt8OffAddrAsInt8X64# :: forall d. Addr# -> Int# -> Int8X64# -> State# d -> State# d
  writeInt8X16Array# :: forall d. MutableByteArray# d -> Int# -> Int8X16# -> State# d -> State# d
  writeInt8X16OffAddr# :: forall d. Addr# -> Int# -> Int8X16# -> State# d -> State# d
  writeInt8X32Array# :: forall d. MutableByteArray# d -> Int# -> Int8X32# -> State# d -> State# d
  writeInt8X32OffAddr# :: forall d. Addr# -> Int# -> Int8X32# -> State# d -> State# d
  writeInt8X64Array# :: forall d. MutableByteArray# d -> Int# -> Int8X64# -> State# d -> State# d
  writeInt8X64OffAddr# :: forall d. Addr# -> Int# -> Int8X64# -> State# d -> State# d
  writeIntArray# :: forall d. MutableByteArray# d -> Int# -> Int# -> State# d -> State# d
  writeIntOffAddr# :: forall d. Addr# -> Int# -> Int# -> State# d -> State# d
  writeMutVar# :: forall {l :: Levity} d (a :: TYPE (BoxedRep l)). MutVar# d a -> a -> State# d -> State# d
  writeMutableArrayArrayArray# :: forall s. MutableArrayArray# s -> Int# -> MutableArrayArray# s -> State# s -> State# s
  writeMutableByteArrayArray# :: forall s. MutableArrayArray# s -> Int# -> MutableByteArray# s -> State# s -> State# s
  writeSmallArray# :: forall {l :: Levity} d (a :: TYPE (BoxedRep l)). SmallMutableArray# d a -> Int# -> a -> State# d -> State# d
  writeStablePtrArray# :: forall d a. MutableByteArray# d -> Int# -> StablePtr# a -> State# d -> State# d
  writeStablePtrOffAddr# :: forall a d. Addr# -> Int# -> StablePtr# a -> State# d -> State# d
  writeTVar# :: forall {l :: Levity} d (a :: TYPE (BoxedRep l)). TVar# d a -> a -> State# d -> State# d
  writeWideCharArray# :: forall d. MutableByteArray# d -> Int# -> Char# -> State# d -> State# d
  writeWideCharOffAddr# :: forall d. Addr# -> Int# -> Char# -> State# d -> State# d
  writeWord16Array# :: forall d. MutableByteArray# d -> Int# -> Word16# -> State# d -> State# d
  writeWord16ArrayAsWord16X16# :: forall d. MutableByteArray# d -> Int# -> Word16X16# -> State# d -> State# d
  writeWord16ArrayAsWord16X32# :: forall d. MutableByteArray# d -> Int# -> Word16X32# -> State# d -> State# d
  writeWord16ArrayAsWord16X8# :: forall d. MutableByteArray# d -> Int# -> Word16X8# -> State# d -> State# d
  writeWord16OffAddr# :: forall d. Addr# -> Int# -> Word16# -> State# d -> State# d
  writeWord16OffAddrAsWord16X16# :: forall d. Addr# -> Int# -> Word16X16# -> State# d -> State# d
  writeWord16OffAddrAsWord16X32# :: forall d. Addr# -> Int# -> Word16X32# -> State# d -> State# d
  writeWord16OffAddrAsWord16X8# :: forall d. Addr# -> Int# -> Word16X8# -> State# d -> State# d
  writeWord16X16Array# :: forall d. MutableByteArray# d -> Int# -> Word16X16# -> State# d -> State# d
  writeWord16X16OffAddr# :: forall d. Addr# -> Int# -> Word16X16# -> State# d -> State# d
  writeWord16X32Array# :: forall d. MutableByteArray# d -> Int# -> Word16X32# -> State# d -> State# d
  writeWord16X32OffAddr# :: forall d. Addr# -> Int# -> Word16X32# -> State# d -> State# d
  writeWord16X8Array# :: forall d. MutableByteArray# d -> Int# -> Word16X8# -> State# d -> State# d
  writeWord16X8OffAddr# :: forall d. Addr# -> Int# -> Word16X8# -> State# d -> State# d
  writeWord32Array# :: forall d. MutableByteArray# d -> Int# -> Word32# -> State# d -> State# d
  writeWord32ArrayAsWord32X16# :: forall d. MutableByteArray# d -> Int# -> Word32X16# -> State# d -> State# d
  writeWord32ArrayAsWord32X4# :: forall d. MutableByteArray# d -> Int# -> Word32X4# -> State# d -> State# d
  writeWord32ArrayAsWord32X8# :: forall d. MutableByteArray# d -> Int# -> Word32X8# -> State# d -> State# d
  writeWord32OffAddr# :: forall d. Addr# -> Int# -> Word32# -> State# d -> State# d
  writeWord32OffAddrAsWord32X16# :: forall d. Addr# -> Int# -> Word32X16# -> State# d -> State# d
  writeWord32OffAddrAsWord32X4# :: forall d. Addr# -> Int# -> Word32X4# -> State# d -> State# d
  writeWord32OffAddrAsWord32X8# :: forall d. Addr# -> Int# -> Word32X8# -> State# d -> State# d
  writeWord32X16Array# :: forall d. MutableByteArray# d -> Int# -> Word32X16# -> State# d -> State# d
  writeWord32X16OffAddr# :: forall d. Addr# -> Int# -> Word32X16# -> State# d -> State# d
  writeWord32X4Array# :: forall d. MutableByteArray# d -> Int# -> Word32X4# -> State# d -> State# d
  writeWord32X4OffAddr# :: forall d. Addr# -> Int# -> Word32X4# -> State# d -> State# d
  writeWord32X8Array# :: forall d. MutableByteArray# d -> Int# -> Word32X8# -> State# d -> State# d
  writeWord32X8OffAddr# :: forall d. Addr# -> Int# -> Word32X8# -> State# d -> State# d
  writeWord64Array# :: forall d. MutableByteArray# d -> Int# -> Word64# -> State# d -> State# d
  writeWord64ArrayAsWord64X2# :: forall d. MutableByteArray# d -> Int# -> Word64X2# -> State# d -> State# d
  writeWord64ArrayAsWord64X4# :: forall d. MutableByteArray# d -> Int# -> Word64X4# -> State# d -> State# d
  writeWord64ArrayAsWord64X8# :: forall d. MutableByteArray# d -> Int# -> Word64X8# -> State# d -> State# d
  writeWord64OffAddr# :: forall d. Addr# -> Int# -> Word64# -> State# d -> State# d
  writeWord64OffAddrAsWord64X2# :: forall d. Addr# -> Int# -> Word64X2# -> State# d -> State# d
  writeWord64OffAddrAsWord64X4# :: forall d. Addr# -> Int# -> Word64X4# -> State# d -> State# d
  writeWord64OffAddrAsWord64X8# :: forall d. Addr# -> Int# -> Word64X8# -> State# d -> State# d
  writeWord64X2Array# :: forall d. MutableByteArray# d -> Int# -> Word64X2# -> State# d -> State# d
  writeWord64X2OffAddr# :: forall d. Addr# -> Int# -> Word64X2# -> State# d -> State# d
  writeWord64X4Array# :: forall d. MutableByteArray# d -> Int# -> Word64X4# -> State# d -> State# d
  writeWord64X4OffAddr# :: forall d. Addr# -> Int# -> Word64X4# -> State# d -> State# d
  writeWord64X8Array# :: forall d. MutableByteArray# d -> Int# -> Word64X8# -> State# d -> State# d
  writeWord64X8OffAddr# :: forall d. Addr# -> Int# -> Word64X8# -> State# d -> State# d
  writeWord8Array# :: forall d. MutableByteArray# d -> Int# -> Word8# -> State# d -> State# d
  writeWord8ArrayAsAddr# :: forall d. MutableByteArray# d -> Int# -> Addr# -> State# d -> State# d
  writeWord8ArrayAsChar# :: forall d. MutableByteArray# d -> Int# -> Char# -> State# d -> State# d
  writeWord8ArrayAsDouble# :: forall d. MutableByteArray# d -> Int# -> Double# -> State# d -> State# d
  writeWord8ArrayAsFloat# :: forall d. MutableByteArray# d -> Int# -> Float# -> State# d -> State# d
  writeWord8ArrayAsInt# :: forall d. MutableByteArray# d -> Int# -> Int# -> State# d -> State# d
  writeWord8ArrayAsInt16# :: forall d. MutableByteArray# d -> Int# -> Int16# -> State# d -> State# d
  writeWord8ArrayAsInt32# :: forall d. MutableByteArray# d -> Int# -> Int32# -> State# d -> State# d
  writeWord8ArrayAsInt64# :: forall d. MutableByteArray# d -> Int# -> Int64# -> State# d -> State# d
  writeWord8ArrayAsStablePtr# :: forall d a. MutableByteArray# d -> Int# -> StablePtr# a -> State# d -> State# d
  writeWord8ArrayAsWideChar# :: forall d. MutableByteArray# d -> Int# -> Char# -> State# d -> State# d
  writeWord8ArrayAsWord# :: forall d. MutableByteArray# d -> Int# -> Word# -> State# d -> State# d
  writeWord8ArrayAsWord16# :: forall d. MutableByteArray# d -> Int# -> Word16# -> State# d -> State# d
  writeWord8ArrayAsWord32# :: forall d. MutableByteArray# d -> Int# -> Word32# -> State# d -> State# d
  writeWord8ArrayAsWord64# :: forall d. MutableByteArray# d -> Int# -> Word64# -> State# d -> State# d
  writeWord8ArrayAsWord8X16# :: forall d. MutableByteArray# d -> Int# -> Word8X16# -> State# d -> State# d
  writeWord8ArrayAsWord8X32# :: forall d. MutableByteArray# d -> Int# -> Word8X32# -> State# d -> State# d
  writeWord8ArrayAsWord8X64# :: forall d. MutableByteArray# d -> Int# -> Word8X64# -> State# d -> State# d
  writeWord8OffAddr# :: forall d. Addr# -> Int# -> Word8# -> State# d -> State# d
  writeWord8OffAddrAsAddr# :: forall d. Addr# -> Int# -> Addr# -> State# d -> State# d
  writeWord8OffAddrAsChar# :: forall d. Addr# -> Int# -> Char# -> State# d -> State# d
  writeWord8OffAddrAsDouble# :: forall d. Addr# -> Int# -> Double# -> State# d -> State# d
  writeWord8OffAddrAsFloat# :: forall d. Addr# -> Int# -> Float# -> State# d -> State# d
  writeWord8OffAddrAsInt# :: forall d. Addr# -> Int# -> Int# -> State# d -> State# d
  writeWord8OffAddrAsInt16# :: forall d. Addr# -> Int# -> Int16# -> State# d -> State# d
  writeWord8OffAddrAsInt32# :: forall d. Addr# -> Int# -> Int32# -> State# d -> State# d
  writeWord8OffAddrAsInt64# :: forall d. Addr# -> Int# -> Int64# -> State# d -> State# d
  writeWord8OffAddrAsStablePtr# :: forall a d. Addr# -> Int# -> StablePtr# a -> State# d -> State# d
  writeWord8OffAddrAsWideChar# :: forall d. Addr# -> Int# -> Char# -> State# d -> State# d
  writeWord8OffAddrAsWord# :: forall d. Addr# -> Int# -> Word# -> State# d -> State# d
  writeWord8OffAddrAsWord16# :: forall d. Addr# -> Int# -> Word16# -> State# d -> State# d
  writeWord8OffAddrAsWord32# :: forall d. Addr# -> Int# -> Word32# -> State# d -> State# d
  writeWord8OffAddrAsWord64# :: forall d. Addr# -> Int# -> Word64# -> State# d -> State# d
  writeWord8OffAddrAsWord8X16# :: forall d. Addr# -> Int# -> Word8X16# -> State# d -> State# d
  writeWord8OffAddrAsWord8X32# :: forall d. Addr# -> Int# -> Word8X32# -> State# d -> State# d
  writeWord8OffAddrAsWord8X64# :: forall d. Addr# -> Int# -> Word8X64# -> State# d -> State# d
  writeWord8X16Array# :: forall d. MutableByteArray# d -> Int# -> Word8X16# -> State# d -> State# d
  writeWord8X16OffAddr# :: forall d. Addr# -> Int# -> Word8X16# -> State# d -> State# d
  writeWord8X32Array# :: forall d. MutableByteArray# d -> Int# -> Word8X32# -> State# d -> State# d
  writeWord8X32OffAddr# :: forall d. Addr# -> Int# -> Word8X32# -> State# d -> State# d
  writeWord8X64Array# :: forall d. MutableByteArray# d -> Int# -> Word8X64# -> State# d -> State# d
  writeWord8X64OffAddr# :: forall d. Addr# -> Int# -> Word8X64# -> State# d -> State# d
  writeWordArray# :: forall d. MutableByteArray# d -> Int# -> Word# -> State# d -> State# d
  writeWordOffAddr# :: forall d. Addr# -> Int# -> Word# -> State# d -> State# d
  xor# :: Word# -> Word# -> Word#
  xor64# :: Word64# -> Word64# -> Word64#
  xorI# :: Int# -> Int# -> Int#
  xorWord16# :: Word16# -> Word16# -> Word16#
  xorWord32# :: Word32# -> Word32# -> Word32#
  xorWord8# :: Word8# -> Word8# -> Word8#
  yield# :: State# RealWorld -> State# RealWorld
  type (~) :: forall k. k -> k -> Constraint
  class (a ~ b) => (~) a b
    {-# MINIMAL #-}
  type (~~) :: forall k0 k1. k0 -> k1 -> Constraint
  class (a ~~ b) => (~~) a b
    {-# MINIMAL #-}

module GHC.Fingerprint where
  -- Safety: Safe
  type Fingerprint :: *
  data Fingerprint = Fingerprint {-# UNPACK #-}GHC.Internal.Word.Word64 {-# UNPACK #-}GHC.Internal.Word.Word64
  fingerprint0 :: Fingerprint
  fingerprintData :: GHC.Internal.Ptr.Ptr GHC.Internal.Word.Word8 -> GHC.Types.Int -> GHC.Types.IO Fingerprint
  fingerprintFingerprints :: [Fingerprint] -> Fingerprint
  fingerprintString :: GHC.Internal.Base.String -> Fingerprint
  getFileHash :: GHC.Internal.IO.FilePath -> GHC.Types.IO Fingerprint

module GHC.Fingerprint.Type where
  -- Safety: Safe
  type Fingerprint :: *
  data Fingerprint = Fingerprint {-# UNPACK #-}GHC.Internal.Word.Word64 {-# UNPACK #-}GHC.Internal.Word.Word64

module GHC.Float where
  -- Safety: Safe
  type Double :: *
  data Double = D# Double#
  type Double# :: TYPE GHC.Types.DoubleRep
  data Double#
  type FFFormat :: *
  data FFFormat = FFExponent | FFFixed | FFGeneric
  type Float :: *
  data Float = F# Float#
  type Float# :: TYPE GHC.Types.FloatRep
  data Float#
  type Floating :: * -> Constraint
  class GHC.Internal.Real.Fractional a => Floating a where
    pi :: a
    exp :: a -> a
    log :: a -> a
    sqrt :: a -> a
    (**) :: a -> a -> a
    logBase :: a -> a -> a
    sin :: a -> a
    cos :: a -> a
    tan :: a -> a
    asin :: a -> a
    acos :: a -> a
    atan :: a -> a
    sinh :: a -> a
    cosh :: a -> a
    tanh :: a -> a
    asinh :: a -> a
    acosh :: a -> a
    atanh :: a -> a
    log1p :: a -> a
    expm1 :: a -> a
    log1pexp :: a -> a
    log1mexp :: a -> a
    {-# MINIMAL pi, exp, log, sin, cos, asin, acos, atan, sinh, cosh, asinh, acosh, atanh #-}
  type RealFloat :: * -> Constraint
  class (GHC.Internal.Real.RealFrac a, Floating a) => RealFloat a where
    floatRadix :: a -> GHC.Num.Integer.Integer
    floatDigits :: a -> GHC.Types.Int
    floatRange :: a -> (GHC.Types.Int, GHC.Types.Int)
    decodeFloat :: a -> (GHC.Num.Integer.Integer, GHC.Types.Int)
    encodeFloat :: GHC.Num.Integer.Integer -> GHC.Types.Int -> a
    exponent :: a -> GHC.Types.Int
    significand :: a -> a
    scaleFloat :: GHC.Types.Int -> a -> a
    isNaN :: a -> GHC.Types.Bool
    isInfinite :: a -> GHC.Types.Bool
    isDenormalized :: a -> GHC.Types.Bool
    isNegativeZero :: a -> GHC.Types.Bool
    isIEEE :: a -> GHC.Types.Bool
    atan2 :: a -> a -> a
    {-# MINIMAL floatRadix, floatDigits, floatRange, decodeFloat, encodeFloat, isNaN, isInfinite, isDenormalized, isNegativeZero, isIEEE #-}
  acosDouble :: Double -> Double
  acosFloat :: Float -> Float
  acoshDouble :: Double -> Double
  acoshFloat :: Float -> Float
  asinDouble :: Double -> Double
  asinFloat :: Float -> Float
  asinhDouble :: Double -> Double
  asinhFloat :: Float -> Float
  atanDouble :: Double -> Double
  atanFloat :: Float -> Float
  atanhDouble :: Double -> Double
  atanhFloat :: Float -> Float
  castDoubleToWord64 :: Double -> GHC.Internal.Word.Word64
  castDoubleToWord64# :: Double# -> GHC.Prim.Word64#
  castFloatToWord32 :: Float -> GHC.Internal.Word.Word32
  castFloatToWord32# :: Float# -> GHC.Prim.Word32#
  castWord32ToFloat :: GHC.Internal.Word.Word32 -> Float
  castWord32ToFloat# :: GHC.Prim.Word32# -> Float#
  castWord64ToDouble :: GHC.Internal.Word.Word64 -> Double
  castWord64ToDouble# :: GHC.Prim.Word64# -> Double#
  ceilingDouble :: forall b. GHC.Internal.Real.Integral b => Double -> b
  ceilingFloat :: forall b. GHC.Internal.Real.Integral b => Float -> b
  clamp :: GHC.Types.Int -> GHC.Types.Int -> GHC.Types.Int
  cosDouble :: Double -> Double
  cosFloat :: Float -> Float
  coshDouble :: Double -> Double
  coshFloat :: Float -> Float
  divideDouble :: Double -> Double -> Double
  divideFloat :: Float -> Float -> Float
  double2Float :: Double -> Float
  double2Int :: Double -> GHC.Types.Int
  eqDouble :: Double -> Double -> GHC.Types.Bool
  eqFloat :: Float -> Float -> GHC.Types.Bool
  expDouble :: Double -> Double
  expFloat :: Float -> Float
  expm1Double :: Double -> Double
  expm1Float :: Float -> Float
  expt :: GHC.Num.Integer.Integer -> GHC.Types.Int -> GHC.Num.Integer.Integer
  expts :: GHC.Internal.Arr.Array GHC.Types.Int GHC.Num.Integer.Integer
  expts10 :: GHC.Internal.Arr.Array GHC.Types.Int GHC.Num.Integer.Integer
  fabsDouble :: Double -> Double
  fabsFloat :: Float -> Float
  float2Double :: Float -> Double
  float2Int :: Float -> GHC.Types.Int
  floatToDigits :: forall a. RealFloat a => GHC.Num.Integer.Integer -> a -> ([GHC.Types.Int], GHC.Types.Int)
  floorDouble :: forall b. GHC.Internal.Real.Integral b => Double -> b
  floorFloat :: forall b. GHC.Internal.Real.Integral b => Float -> b
  formatRealFloat :: forall a. RealFloat a => FFFormat -> GHC.Internal.Maybe.Maybe GHC.Types.Int -> a -> GHC.Internal.Base.String
  formatRealFloatAlt :: forall a. RealFloat a => FFFormat -> GHC.Internal.Maybe.Maybe GHC.Types.Int -> GHC.Types.Bool -> a -> GHC.Internal.Base.String
  fromRat :: forall a. RealFloat a => GHC.Internal.Real.Rational -> a
  fromRat' :: forall a. RealFloat a => GHC.Internal.Real.Rational -> a
  fromRat'' :: forall a. RealFloat a => GHC.Types.Int -> GHC.Types.Int -> GHC.Num.Integer.Integer -> GHC.Num.Integer.Integer -> a
  geDouble :: Double -> Double -> GHC.Types.Bool
  geFloat :: Float -> Float -> GHC.Types.Bool
  gtDouble :: Double -> Double -> GHC.Types.Bool
  gtFloat :: Float -> Float -> GHC.Types.Bool
  int2Double :: GHC.Types.Int -> Double
  int2Float :: GHC.Types.Int -> Float
  integerToBinaryFloat' :: forall a. RealFloat a => GHC.Num.Integer.Integer -> a
  integerToDouble# :: GHC.Num.Integer.Integer -> Double#
  integerToFloat# :: GHC.Num.Integer.Integer -> Float#
  isDoubleDenormalized :: Double -> GHC.Types.Int
  isDoubleFinite :: Double -> GHC.Types.Int
  isDoubleInfinite :: Double -> GHC.Types.Int
  isDoubleNaN :: Double -> GHC.Types.Int
  isDoubleNegativeZero :: Double -> GHC.Types.Int
  isFloatDenormalized :: Float -> GHC.Types.Int
  isFloatFinite :: Float -> GHC.Types.Int
  isFloatInfinite :: Float -> GHC.Types.Int
  isFloatNaN :: Float -> GHC.Types.Int
  isFloatNegativeZero :: Float -> GHC.Types.Int
  leDouble :: Double -> Double -> GHC.Types.Bool
  leFloat :: Float -> Float -> GHC.Types.Bool
  log1mexpOrd :: forall a. (GHC.Classes.Ord a, Floating a) => a -> a
  log1pDouble :: Double -> Double
  log1pFloat :: Float -> Float
  logDouble :: Double -> Double
  logFloat :: Float -> Float
  ltDouble :: Double -> Double -> GHC.Types.Bool
  ltFloat :: Float -> Float -> GHC.Types.Bool
  maxExpt :: GHC.Types.Int
  maxExpt10 :: GHC.Types.Int
  minExpt :: GHC.Types.Int
  minusDouble :: Double -> Double -> Double
  minusFloat :: Float -> Float -> Float
  naturalToDouble# :: GHC.Num.Natural.Natural -> Double#
  naturalToFloat# :: GHC.Num.Natural.Natural -> Float#
  negateDouble :: Double -> Double
  negateFloat :: Float -> Float
  plusDouble :: Double -> Double -> Double
  plusFloat :: Float -> Float -> Float
  powerDouble :: Double -> Double -> Double
  powerFloat :: Float -> Float -> Float
  properFractionDouble :: forall b. GHC.Internal.Real.Integral b => Double -> (b, Double)
  properFractionFloat :: forall b. GHC.Internal.Real.Integral b => Float -> (b, Float)
  rationalToDouble :: GHC.Num.Integer.Integer -> GHC.Num.Integer.Integer -> Double
  rationalToFloat :: GHC.Num.Integer.Integer -> GHC.Num.Integer.Integer -> Float
  roundDouble :: forall b. GHC.Internal.Real.Integral b => Double -> b
  roundFloat :: forall b. GHC.Internal.Real.Integral b => Float -> b
  roundTo :: GHC.Types.Int -> GHC.Types.Int -> [GHC.Types.Int] -> (GHC.Types.Int, [GHC.Types.Int])
  roundingMode# :: GHC.Num.Integer.Integer -> GHC.Prim.Int# -> GHC.Prim.Int#
  showFloat :: forall a. RealFloat a => a -> GHC.Internal.Show.ShowS
  showSignedFloat :: forall a. RealFloat a => (a -> GHC.Internal.Show.ShowS) -> GHC.Types.Int -> a -> GHC.Internal.Show.ShowS
  sinDouble :: Double -> Double
  sinFloat :: Float -> Float
  sinhDouble :: Double -> Double
  sinhFloat :: Float -> Float
  sqrtDouble :: Double -> Double
  sqrtFloat :: Float -> Float
  stgDoubleToWord64 :: Double# -> GHC.Prim.Word64#
  stgFloatToWord32 :: Float# -> GHC.Prim.Word32#
  stgWord32ToFloat :: GHC.Prim.Word32# -> Float#
  stgWord64ToDouble :: GHC.Prim.Word64# -> Double#
  tanDouble :: Double -> Double
  tanFloat :: Float -> Float
  tanhDouble :: Double -> Double
  tanhFloat :: Float -> Float
  timesDouble :: Double -> Double -> Double
  timesFloat :: Float -> Float -> Float
  truncateDouble :: forall b. GHC.Internal.Real.Integral b => Double -> b
  truncateFloat :: forall b. GHC.Internal.Real.Integral b => Float -> b
  word2Double :: GHC.Types.Word -> Double
  word2Float :: GHC.Types.Word -> Float

module GHC.Float.ConversionUtils where
  -- Safety: Safe
  elimZerosInt# :: GHC.Prim.Int# -> GHC.Prim.Int# -> (# GHC.Num.Integer.Integer, GHC.Prim.Int# #)
  elimZerosInteger :: GHC.Num.Integer.Integer -> GHC.Prim.Int# -> (# GHC.Num.Integer.Integer, GHC.Prim.Int# #)

module GHC.Float.RealFracMethods where
  -- Safety: Safe
  ceilingDoubleInt :: GHC.Types.Double -> GHC.Types.Int
  ceilingDoubleInteger :: GHC.Types.Double -> GHC.Num.Integer.Integer
  ceilingFloatInt :: GHC.Types.Float -> GHC.Types.Int
  ceilingFloatInteger :: GHC.Types.Float -> GHC.Num.Integer.Integer
  double2Int :: GHC.Types.Double -> GHC.Types.Int
  float2Int :: GHC.Types.Float -> GHC.Types.Int
  floorDoubleInt :: GHC.Types.Double -> GHC.Types.Int
  floorDoubleInteger :: GHC.Types.Double -> GHC.Num.Integer.Integer
  floorFloatInt :: GHC.Types.Float -> GHC.Types.Int
  floorFloatInteger :: GHC.Types.Float -> GHC.Num.Integer.Integer
  int2Double :: GHC.Types.Int -> GHC.Types.Double
  int2Float :: GHC.Types.Int -> GHC.Types.Float
  properFractionDoubleInt :: GHC.Types.Double -> (GHC.Types.Int, GHC.Types.Double)
  properFractionDoubleInteger :: GHC.Types.Double -> (GHC.Num.Integer.Integer, GHC.Types.Double)
  properFractionFloatInt :: GHC.Types.Float -> (GHC.Types.Int, GHC.Types.Float)
  properFractionFloatInteger :: GHC.Types.Float -> (GHC.Num.Integer.Integer, GHC.Types.Float)
  roundDoubleInt :: GHC.Types.Double -> GHC.Types.Int
  roundDoubleInteger :: GHC.Types.Double -> GHC.Num.Integer.Integer
  roundFloatInt :: GHC.Types.Float -> GHC.Types.Int
  roundFloatInteger :: GHC.Types.Float -> GHC.Num.Integer.Integer
  truncateDoubleInteger :: GHC.Types.Double -> GHC.Num.Integer.Integer
  truncateFloatInteger :: GHC.Types.Float -> GHC.Num.Integer.Integer

module GHC.Foreign where
  -- Safety: Safe
  type CString :: *
  type CString = GHC.Internal.Ptr.Ptr GHC.Internal.Foreign.C.Types.CChar
  type CStringLen :: *
  type CStringLen = (GHC.Internal.Ptr.Ptr GHC.Internal.Foreign.C.Types.CChar, GHC.Types.Int)
  charIsRepresentable :: GHC.Internal.IO.Encoding.Types.TextEncoding -> GHC.Types.Char -> GHC.Types.IO GHC.Types.Bool
  newCString :: GHC.Internal.IO.Encoding.Types.TextEncoding -> GHC.Internal.Base.String -> GHC.Types.IO CString
  newCStringLen :: GHC.Internal.IO.Encoding.Types.TextEncoding -> GHC.Internal.Base.String -> GHC.Types.IO CStringLen
  newCStringLen0 :: GHC.Internal.IO.Encoding.Types.TextEncoding -> GHC.Internal.Base.String -> GHC.Types.IO CStringLen
  peekCString :: GHC.Internal.IO.Encoding.Types.TextEncoding -> CString -> GHC.Types.IO GHC.Internal.Base.String
  peekCStringLen :: GHC.Internal.IO.Encoding.Types.TextEncoding -> CStringLen -> GHC.Types.IO GHC.Internal.Base.String
  withCString :: forall a. GHC.Internal.IO.Encoding.Types.TextEncoding -> GHC.Internal.Base.String -> (CString -> GHC.Types.IO a) -> GHC.Types.IO a
  withCStringLen :: forall a. GHC.Internal.IO.Encoding.Types.TextEncoding -> GHC.Internal.Base.String -> (CStringLen -> GHC.Types.IO a) -> GHC.Types.IO a
  withCStringLen0 :: forall a. GHC.Internal.IO.Encoding.Types.TextEncoding -> GHC.Internal.Base.String -> (CStringLen -> GHC.Types.IO a) -> GHC.Types.IO a
  withCStringsLen :: forall a. GHC.Internal.IO.Encoding.Types.TextEncoding -> [GHC.Internal.Base.String] -> (GHC.Types.Int -> GHC.Internal.Ptr.Ptr CString -> GHC.Types.IO a) -> GHC.Types.IO a

module GHC.ForeignPtr where
  -- Safety: None
  type FinalizerEnvPtr :: * -> * -> *
  type FinalizerEnvPtr env a = GHC.Internal.Ptr.FunPtr (GHC.Internal.Ptr.Ptr env -> GHC.Internal.Ptr.Ptr a -> GHC.Types.IO ())
  type FinalizerPtr :: * -> *
  type FinalizerPtr a = GHC.Internal.Ptr.FunPtr (GHC.Internal.Ptr.Ptr a -> GHC.Types.IO ())
  type Finalizers :: *
  data Finalizers = NoFinalizers | CFinalizers (GHC.Prim.Weak# ()) | HaskellFinalizers [GHC.Types.IO ()]
  type role ForeignPtr phantom
  type ForeignPtr :: * -> *
  data ForeignPtr a = ForeignPtr GHC.Prim.Addr# ForeignPtrContents
  type ForeignPtrContents :: *
  data ForeignPtrContents = PlainForeignPtr ! {-# UNPACK #-}(GHC.Internal.IORef.N:IORef[0] <Finalizers>_N)(GHC.Internal.IORef.IORef Finalizers) | FinalPtr | MallocPtr (GHC.Prim.MutableByteArray# GHC.Prim.RealWorld) ! {-# UNPACK #-}(GHC.Internal.IORef.N:IORef[0] <Finalizers>_N)(GHC.Internal.IORef.IORef Finalizers) | PlainPtr (GHC.Prim.MutableByteArray# GHC.Prim.RealWorld)
  addForeignPtrConcFinalizer :: forall a. ForeignPtr a -> GHC.Types.IO () -> GHC.Types.IO ()
  addForeignPtrFinalizer :: forall a. FinalizerPtr a -> ForeignPtr a -> GHC.Types.IO ()
  addForeignPtrFinalizerEnv :: forall env a. FinalizerEnvPtr env a -> GHC.Internal.Ptr.Ptr env -> ForeignPtr a -> GHC.Types.IO ()
  castForeignPtr :: forall a b. ForeignPtr a -> ForeignPtr b
  finalizeForeignPtr :: forall a. ForeignPtr a -> GHC.Types.IO ()
  mallocForeignPtr :: forall a. GHC.Internal.Foreign.Storable.Storable a => GHC.Types.IO (ForeignPtr a)
  mallocForeignPtrAlignedBytes :: forall a. GHC.Types.Int -> GHC.Types.Int -> GHC.Types.IO (ForeignPtr a)
  mallocForeignPtrBytes :: forall a. GHC.Types.Int -> GHC.Types.IO (ForeignPtr a)
  mallocPlainForeignPtr :: forall a. GHC.Internal.Foreign.Storable.Storable a => GHC.Types.IO (ForeignPtr a)
  mallocPlainForeignPtrAlignedBytes :: forall a. GHC.Types.Int -> GHC.Types.Int -> GHC.Types.IO (ForeignPtr a)
  mallocPlainForeignPtrBytes :: forall a. GHC.Types.Int -> GHC.Types.IO (ForeignPtr a)
  newConcForeignPtr :: forall a. GHC.Internal.Ptr.Ptr a -> GHC.Types.IO () -> GHC.Types.IO (ForeignPtr a)
  newForeignPtr_ :: forall a. GHC.Internal.Ptr.Ptr a -> GHC.Types.IO (ForeignPtr a)
  plusForeignPtr :: forall a b. ForeignPtr a -> GHC.Types.Int -> ForeignPtr b
  touchForeignPtr :: forall a. ForeignPtr a -> GHC.Types.IO ()
  unsafeForeignPtrToPtr :: forall a. ForeignPtr a -> GHC.Internal.Ptr.Ptr a
  unsafeWithForeignPtr :: forall a b. ForeignPtr a -> (GHC.Internal.Ptr.Ptr a -> GHC.Types.IO b) -> GHC.Types.IO b
  withForeignPtr :: forall a b. ForeignPtr a -> (GHC.Internal.Ptr.Ptr a -> GHC.Types.IO b) -> GHC.Types.IO b

module GHC.GHCi where
  -- Safety: None
  type GHCiSandboxIO :: (* -> *) -> Constraint
  class GHC.Internal.Base.Monad m => GHCiSandboxIO m where
    ghciStepIO :: forall a. m a -> GHC.Types.IO a
    {-# MINIMAL ghciStepIO #-}
  type NoIO :: * -> *
  newtype NoIO a = ...

module GHC.GHCi.Helpers where
  -- Safety: Safe
  disableBuffering :: GHC.Types.IO ()
  evalWrapper :: forall a. GHC.Internal.Base.String -> [GHC.Internal.Base.String] -> GHC.Types.IO a -> GHC.Types.IO a
  flushAll :: GHC.Types.IO ()

module GHC.Generics where
  -- Safety: Safe
  type role (:*:) representational representational nominal
  type (:*:) :: forall k. (k -> *) -> (k -> *) -> k -> *
  data (:*:) f g p = (f p) :*: (g p)
  type role (:+:) representational representational nominal
  type (:+:) :: forall k. (k -> *) -> (k -> *) -> k -> *
  data (:+:) f g p = L1 (f p) | R1 (g p)
  type role (:.:) representational nominal nominal
  type (:.:) :: forall k2 k1. (k2 -> *) -> (k1 -> k2) -> k1 -> *
  newtype (:.:) f g p = Comp1 {unComp1 :: f (g p)}
  type Associativity :: *
  data Associativity = LeftAssociative | RightAssociative | NotAssociative
  type C :: *
  data C
  type C1 :: forall {k}. Meta -> (k -> *) -> k -> *
  type C1 = M1 C :: Meta -> (k -> *) -> k -> *
  type Constructor :: forall {k}. k -> Constraint
  class Constructor c where
    conName :: forall k1 (t :: k -> (k1 -> *) -> k1 -> *) (f :: k1 -> *) (a :: k1). t c f a -> [GHC.Types.Char]
    conFixity :: forall k1 (t :: k -> (k1 -> *) -> k1 -> *) (f :: k1 -> *) (a :: k1). t c f a -> Fixity
    conIsRecord :: forall k1 (t :: k -> (k1 -> *) -> k1 -> *) (f :: k1 -> *) (a :: k1). t c f a -> GHC.Types.Bool
    {-# MINIMAL conName #-}
  type D :: *
  data D
  type D1 :: forall {k}. Meta -> (k -> *) -> k -> *
  type D1 = M1 D :: Meta -> (k -> *) -> k -> *
  type Datatype :: forall {k}. k -> Constraint
  class Datatype d where
    datatypeName :: forall k1 (t :: k -> (k1 -> *) -> k1 -> *) (f :: k1 -> *) (a :: k1). t d f a -> [GHC.Types.Char]
    moduleName :: forall k1 (t :: k -> (k1 -> *) -> k1 -> *) (f :: k1 -> *) (a :: k1). t d f a -> [GHC.Types.Char]
    packageName :: forall k1 (t :: k -> (k1 -> *) -> k1 -> *) (f :: k1 -> *) (a :: k1). t d f a -> [GHC.Types.Char]
    isNewtype :: forall k1 (t :: k -> (k1 -> *) -> k1 -> *) (f :: k1 -> *) (a :: k1). t d f a -> GHC.Types.Bool
    {-# MINIMAL datatypeName, moduleName, packageName #-}
  type DecidedStrictness :: *
  data DecidedStrictness = DecidedLazy | DecidedStrict | DecidedUnpack
  type Fixity :: *
  data Fixity = Prefix | Infix Associativity GHC.Types.Int
  type FixityI :: *
  data FixityI = PrefixI | InfixI Associativity GHC.Internal.TypeNats.Nat
  type Generic :: * -> Constraint
  class Generic a where
    type Rep :: * -> * -> *
    type family Rep a
    from :: forall x. a -> Rep a x
    to :: forall x. Rep a x -> a
    {-# MINIMAL from, to #-}
  type Generic1 :: forall k. (k -> *) -> Constraint
  class Generic1 f where
    type Rep1 :: forall k. (k -> *) -> k -> *
    type family Rep1 f
    from1 :: forall (a :: k). f a -> Rep1 f a
    to1 :: forall (a :: k). Rep1 f a -> f a
    {-# MINIMAL from1, to1 #-}
  type Generically :: * -> *
  newtype Generically a = Generically a
  type role Generically1 representational nominal
  type Generically1 :: forall k. (k -> *) -> k -> *
  newtype Generically1 f a where
    Generically1 :: forall {k} (f :: k -> *) (a :: k). f a -> Generically1 f a
  type role K1 phantom representational phantom
  type K1 :: forall k. * -> * -> k -> *
  newtype K1 i c p = K1 {unK1 :: c}
  type role M1 phantom phantom representational nominal
  type M1 :: forall k. * -> Meta -> (k -> *) -> k -> *
  newtype M1 i c f p = M1 {unM1 :: f p}
  type Meta :: *
  data Meta = MetaData GHC.Types.Symbol GHC.Types.Symbol GHC.Types.Symbol GHC.Types.Bool | MetaCons GHC.Types.Symbol FixityI GHC.Types.Bool | MetaSel (GHC.Internal.Maybe.Maybe GHC.Types.Symbol) SourceUnpackedness SourceStrictness DecidedStrictness
  type Par1 :: * -> *
  newtype Par1 p = Par1 {unPar1 :: p}
  type R :: *
  data R
  type Rec0 :: forall {k}. * -> k -> *
  type Rec0 = K1 R :: * -> k -> *
  type role Rec1 representational nominal
  type Rec1 :: forall k. (k -> *) -> k -> *
  newtype Rec1 f p = Rec1 {unRec1 :: f p}
  type S :: *
  data S
  type S1 :: forall {k}. Meta -> (k -> *) -> k -> *
  type S1 = M1 S :: Meta -> (k -> *) -> k -> *
  type Selector :: forall {k}. k -> Constraint
  class Selector s where
    selName :: forall k1 (t :: k -> (k1 -> *) -> k1 -> *) (f :: k1 -> *) (a :: k1). t s f a -> [GHC.Types.Char]
    selSourceUnpackedness :: forall k1 (t :: k -> (k1 -> *) -> k1 -> *) (f :: k1 -> *) (a :: k1). t s f a -> SourceUnpackedness
    selSourceStrictness :: forall k1 (t :: k -> (k1 -> *) -> k1 -> *) (f :: k1 -> *) (a :: k1). t s f a -> SourceStrictness
    selDecidedStrictness :: forall k1 (t :: k -> (k1 -> *) -> k1 -> *) (f :: k1 -> *) (a :: k1). t s f a -> DecidedStrictness
    {-# MINIMAL selName, selSourceUnpackedness, selSourceStrictness, selDecidedStrictness #-}
  type SourceStrictness :: *
  data SourceStrictness = NoSourceStrictness | SourceLazy | SourceStrict
  type SourceUnpackedness :: *
  data SourceUnpackedness = NoSourceUnpackedness | SourceNoUnpack | SourceUnpack
  type role U1 phantom
  type U1 :: forall k. k -> *
  data U1 p = U1
  UAddr :: forall k (p :: k). GHC.Prim.Addr# -> URec (GHC.Internal.Ptr.Ptr ()) p
  type UAddr :: forall {k}. k -> *
  type UAddr = URec (GHC.Internal.Ptr.Ptr ()) :: k -> *
  UChar :: forall k (p :: k). GHC.Prim.Char# -> URec GHC.Types.Char p
  type UChar :: forall {k}. k -> *
  type UChar = URec GHC.Types.Char :: k -> *
  UDouble :: forall k (p :: k). GHC.Prim.Double# -> URec GHC.Types.Double p
  type UDouble :: forall {k}. k -> *
  type UDouble = URec GHC.Types.Double :: k -> *
  UFloat :: forall k (p :: k). GHC.Prim.Float# -> URec GHC.Types.Float p
  type UFloat :: forall {k}. k -> *
  type UFloat = URec GHC.Types.Float :: k -> *
  UInt :: forall k (p :: k). GHC.Prim.Int# -> URec GHC.Types.Int p
  type UInt :: forall {k}. k -> *
  type UInt = URec GHC.Types.Int :: k -> *
  type URec :: forall k. * -> k -> *
  data family URec a p
  UWord :: forall k (p :: k). GHC.Prim.Word# -> URec GHC.Types.Word p
  type UWord :: forall {k}. k -> *
  type UWord = URec GHC.Types.Word :: k -> *
  type role V1 phantom
  type V1 :: forall k. k -> *
  data V1 p
  prec :: Fixity -> GHC.Types.Int
  uAddr# :: forall k (p :: k). URec (GHC.Internal.Ptr.Ptr ()) p -> GHC.Prim.Addr#
  uChar# :: forall k (p :: k). URec GHC.Types.Char p -> GHC.Prim.Char#
  uDouble# :: forall k (p :: k). URec GHC.Types.Double p -> GHC.Prim.Double#
  uFloat# :: forall k (p :: k). URec GHC.Types.Float p -> GHC.Prim.Float#
  uInt# :: forall k (p :: k). URec GHC.Types.Int p -> GHC.Prim.Int#
  uWord# :: forall k (p :: k). URec GHC.Types.Word p -> GHC.Prim.Word#

module GHC.IO where
  -- Safety: None
  type FilePath :: *
  type FilePath = GHC.Internal.Base.String
  type IO :: * -> *
  newtype IO a = IO (GHC.Prim.State# GHC.Prim.RealWorld -> (# GHC.Prim.State# GHC.Prim.RealWorld, a #))
  type MaskingState :: *
  data MaskingState = Unmasked | MaskedInterruptible | MaskedUninterruptible
  bracket :: forall a b c. IO a -> (a -> IO b) -> (a -> IO c) -> IO c
  catch :: forall e a. GHC.Internal.Exception.Type.Exception e => IO a -> (e -> IO a) -> IO a
  catchAny :: forall a. IO a -> (forall e. GHC.Internal.Exception.Type.Exception e => e -> IO a) -> IO a
  catchException :: forall e a. GHC.Internal.Exception.Type.Exception e => IO a -> (e -> IO a) -> IO a
  evaluate :: forall a. a -> IO a
  finally :: forall a b. IO a -> IO b -> IO a
  getMaskingState :: IO MaskingState
  interruptible :: forall a. IO a -> IO a
  ioToST :: forall a. IO a -> GHC.Internal.ST.ST GHC.Prim.RealWorld a
  liftIO :: forall a. IO a -> GHC.Prim.State# GHC.Prim.RealWorld -> GHC.Internal.ST.STret GHC.Prim.RealWorld a
  mask :: forall b. ((forall a. IO a -> IO a) -> IO b) -> IO b
  mask_ :: forall a. IO a -> IO a
  mkUserError :: [GHC.Types.Char] -> GHC.Internal.Exception.Type.SomeException
  mplusIO :: forall a. IO a -> IO a -> IO a
  noDuplicate :: IO ()
  onException :: forall a b. IO a -> IO b -> IO a
  stToIO :: forall a. GHC.Internal.ST.ST GHC.Prim.RealWorld a -> IO a
  throwIO :: forall e a. (GHC.Internal.Stack.Types.HasCallStack, GHC.Internal.Exception.Type.Exception e) => e -> IO a
  unIO :: forall a. IO a -> GHC.Prim.State# GHC.Prim.RealWorld -> (# GHC.Prim.State# GHC.Prim.RealWorld, a #)
  uninterruptibleMask :: forall b. ((forall a. IO a -> IO a) -> IO b) -> IO b
  uninterruptibleMask_ :: forall a. IO a -> IO a
  unsafeDupableInterleaveIO :: forall a. IO a -> IO a
  unsafeDupablePerformIO :: forall a. IO a -> a
  unsafeIOToST :: forall a s. IO a -> GHC.Internal.ST.ST s a
  unsafeInterleaveIO :: forall a. IO a -> IO a
  unsafePerformIO :: forall a. IO a -> a
  unsafeSTToIO :: forall s a. GHC.Internal.ST.ST s a -> IO a
  unsafeUnmask :: forall a. IO a -> IO a

module GHC.IO.Buffer where
  -- Safety: Safe
  type role Buffer phantom
  type Buffer :: * -> *
  data Buffer e = Buffer {bufRaw :: {-# UNPACK #-}(RawBuffer e), bufState :: BufferState, bufSize :: {-# UNPACK #-}GHC.Types.Int, bufOffset :: {-# UNPACK #-}GHC.Internal.Word.Word64, bufL :: {-# UNPACK #-}GHC.Types.Int, bufR :: {-# UNPACK #-}GHC.Types.Int}
  type BufferState :: *
  data BufferState = ReadBuffer | WriteBuffer
  type CharBufElem :: *
  type CharBufElem = GHC.Types.Char
  type CharBuffer :: *
  type CharBuffer = Buffer GHC.Types.Char
  type RawBuffer :: * -> *
  type RawBuffer e = GHC.Internal.ForeignPtr.ForeignPtr e
  type RawCharBuffer :: *
  type RawCharBuffer = RawBuffer CharBufElem
  bufferAdd :: forall e. GHC.Types.Int -> Buffer e -> Buffer e
  bufferAddOffset :: forall e. GHC.Types.Int -> Buffer e -> Buffer e
  bufferAdjustL :: forall e. GHC.Types.Int -> Buffer e -> Buffer e
  bufferAdjustOffset :: forall e. GHC.Internal.Word.Word64 -> Buffer e -> Buffer e
  bufferAvailable :: forall e. Buffer e -> GHC.Types.Int
  bufferElems :: forall e. Buffer e -> GHC.Types.Int
  bufferOffset :: forall e. Buffer e -> GHC.Internal.Word.Word64
  bufferRemove :: forall e. GHC.Types.Int -> Buffer e -> Buffer e
  charSize :: GHC.Types.Int
  checkBuffer :: forall a. Buffer a -> GHC.Types.IO ()
  emptyBuffer :: forall e. RawBuffer e -> GHC.Types.Int -> BufferState -> Buffer e
  isEmptyBuffer :: forall e. Buffer e -> GHC.Types.Bool
  isFullBuffer :: forall e. Buffer e -> GHC.Types.Bool
  isFullCharBuffer :: forall e. Buffer e -> GHC.Types.Bool
  isWriteBuffer :: forall e. Buffer e -> GHC.Types.Bool
  newBuffer :: forall e. GHC.Types.Int -> GHC.Types.Int -> BufferState -> GHC.Types.IO (Buffer e)
  newByteBuffer :: GHC.Types.Int -> BufferState -> GHC.Types.IO (Buffer GHC.Internal.Word.Word8)
  newCharBuffer :: GHC.Types.Int -> BufferState -> GHC.Types.IO CharBuffer
  peekCharBuf :: RawCharBuffer -> GHC.Types.Int -> GHC.Types.IO GHC.Types.Char
  readCharBuf :: RawCharBuffer -> GHC.Types.Int -> GHC.Types.IO (GHC.Types.Char, GHC.Types.Int)
  readCharBufPtr :: GHC.Internal.Ptr.Ptr CharBufElem -> GHC.Types.Int -> GHC.Types.IO (GHC.Types.Char, GHC.Types.Int)
  readWord8Buf :: RawBuffer GHC.Internal.Word.Word8 -> GHC.Types.Int -> GHC.Types.IO GHC.Internal.Word.Word8
  slideContents :: Buffer GHC.Internal.Word.Word8 -> GHC.Types.IO (Buffer GHC.Internal.Word.Word8)
  summaryBuffer :: forall a. Buffer a -> GHC.Internal.Base.String
  withBuffer :: forall e a. Buffer e -> (GHC.Internal.Ptr.Ptr e -> GHC.Types.IO a) -> GHC.Types.IO a
  withRawBuffer :: forall e a. RawBuffer e -> (GHC.Internal.Ptr.Ptr e -> GHC.Types.IO a) -> GHC.Types.IO a
  writeCharBuf :: RawCharBuffer -> GHC.Types.Int -> GHC.Types.Char -> GHC.Types.IO GHC.Types.Int
  writeCharBufPtr :: GHC.Internal.Ptr.Ptr CharBufElem -> GHC.Types.Int -> GHC.Types.Char -> GHC.Types.IO GHC.Types.Int
  writeWord8Buf :: RawBuffer GHC.Internal.Word.Word8 -> GHC.Types.Int -> GHC.Internal.Word.Word8 -> GHC.Types.IO ()

module GHC.IO.BufferedIO where
  -- Safety: Safe
  type BufferedIO :: * -> Constraint
  class BufferedIO dev where
    newBuffer :: dev -> GHC.Internal.IO.Buffer.BufferState -> GHC.Types.IO (GHC.Internal.IO.Buffer.Buffer GHC.Internal.Word.Word8)
    fillReadBuffer :: dev -> GHC.Internal.IO.Buffer.Buffer GHC.Internal.Word.Word8 -> GHC.Types.IO (GHC.Types.Int, GHC.Internal.IO.Buffer.Buffer GHC.Internal.Word.Word8)
    fillReadBuffer0 :: dev -> GHC.Internal.IO.Buffer.Buffer GHC.Internal.Word.Word8 -> GHC.Types.IO (GHC.Internal.Maybe.Maybe GHC.Types.Int, GHC.Internal.IO.Buffer.Buffer GHC.Internal.Word.Word8)
    emptyWriteBuffer :: dev -> GHC.Internal.IO.Buffer.Buffer GHC.Internal.Word.Word8 -> GHC.Types.IO (GHC.Internal.IO.Buffer.Buffer GHC.Internal.Word.Word8)
    flushWriteBuffer :: dev -> GHC.Internal.IO.Buffer.Buffer GHC.Internal.Word.Word8 -> GHC.Types.IO (GHC.Internal.IO.Buffer.Buffer GHC.Internal.Word.Word8)
    flushWriteBuffer0 :: dev -> GHC.Internal.IO.Buffer.Buffer GHC.Internal.Word.Word8 -> GHC.Types.IO (GHC.Types.Int, GHC.Internal.IO.Buffer.Buffer GHC.Internal.Word.Word8)
    {-# MINIMAL newBuffer, fillReadBuffer, fillReadBuffer0, flushWriteBuffer, flushWriteBuffer0 #-}
  readBuf :: forall dev. GHC.Internal.IO.Device.RawIO dev => dev -> GHC.Internal.IO.Buffer.Buffer GHC.Internal.Word.Word8 -> GHC.Types.IO (GHC.Types.Int, GHC.Internal.IO.Buffer.Buffer GHC.Internal.Word.Word8)
  readBufNonBlocking :: forall dev. GHC.Internal.IO.Device.RawIO dev => dev -> GHC.Internal.IO.Buffer.Buffer GHC.Internal.Word.Word8 -> GHC.Types.IO (GHC.Internal.Maybe.Maybe GHC.Types.Int, GHC.Internal.IO.Buffer.Buffer GHC.Internal.Word.Word8)
  writeBuf :: forall dev. GHC.Internal.IO.Device.RawIO dev => dev -> GHC.Internal.IO.Buffer.Buffer GHC.Internal.Word.Word8 -> GHC.Types.IO (GHC.Internal.IO.Buffer.Buffer GHC.Internal.Word.Word8)
  writeBufNonBlocking :: forall dev. GHC.Internal.IO.Device.RawIO dev => dev -> GHC.Internal.IO.Buffer.Buffer GHC.Internal.Word.Word8 -> GHC.Types.IO (GHC.Types.Int, GHC.Internal.IO.Buffer.Buffer GHC.Internal.Word.Word8)

module GHC.IO.Device where
  -- Safety: Safe
  type IODevice :: * -> Constraint
  class IODevice a where
    ready :: a -> GHC.Types.Bool -> GHC.Types.Int -> GHC.Types.IO GHC.Types.Bool
    close :: a -> GHC.Types.IO ()
    isTerminal :: a -> GHC.Types.IO GHC.Types.Bool
    isSeekable :: a -> GHC.Types.IO GHC.Types.Bool
    seek :: a -> SeekMode -> GHC.Num.Integer.Integer -> GHC.Types.IO GHC.Num.Integer.Integer
    tell :: a -> GHC.Types.IO GHC.Num.Integer.Integer
    getSize :: a -> GHC.Types.IO GHC.Num.Integer.Integer
    setSize :: a -> GHC.Num.Integer.Integer -> GHC.Types.IO ()
    setEcho :: a -> GHC.Types.Bool -> GHC.Types.IO ()
    getEcho :: a -> GHC.Types.IO GHC.Types.Bool
    setRaw :: a -> GHC.Types.Bool -> GHC.Types.IO ()
    devType :: a -> GHC.Types.IO IODeviceType
    dup :: a -> GHC.Types.IO a
    dup2 :: a -> a -> GHC.Types.IO a
    {-# MINIMAL ready, close, devType #-}
  type IODeviceType :: *
  data IODeviceType = Directory | Stream | RegularFile | RawDevice
  type RawIO :: * -> Constraint
  class RawIO a where
    read :: a -> GHC.Internal.Ptr.Ptr GHC.Internal.Word.Word8 -> GHC.Internal.Word.Word64 -> GHC.Types.Int -> GHC.Types.IO GHC.Types.Int
    readNonBlocking :: a -> GHC.Internal.Ptr.Ptr GHC.Internal.Word.Word8 -> GHC.Internal.Word.Word64 -> GHC.Types.Int -> GHC.Types.IO (GHC.Internal.Maybe.Maybe GHC.Types.Int)
    write :: a -> GHC.Internal.Ptr.Ptr GHC.Internal.Word.Word8 -> GHC.Internal.Word.Word64 -> GHC.Types.Int -> GHC.Types.IO ()
    writeNonBlocking :: a -> GHC.Internal.Ptr.Ptr GHC.Internal.Word.Word8 -> GHC.Internal.Word.Word64 -> GHC.Types.Int -> GHC.Types.IO GHC.Types.Int
    {-# MINIMAL read, readNonBlocking, write, writeNonBlocking #-}
  type SeekMode :: *
  data SeekMode = AbsoluteSeek | RelativeSeek | SeekFromEnd

module GHC.IO.Encoding where
  -- Safety: Safe
  pattern BufferCodec :: forall from to state. GHC.Internal.IO.Encoding.Types.CodeBuffer from to -> (GHC.Internal.IO.Buffer.Buffer from -> GHC.Internal.IO.Buffer.Buffer to -> GHC.Types.IO (GHC.Internal.IO.Buffer.Buffer from, GHC.Internal.IO.Buffer.Buffer to)) -> GHC.Types.IO () -> GHC.Types.IO state -> (state -> GHC.Types.IO ()) -> BufferCodec from to state
  pattern BufferCodec {encode, recover, close, getState, setState}
  type role BufferCodec phantom phantom representational
  type BufferCodec :: * -> * -> * -> *
  data BufferCodec from to state = BufferCodec# {encode# :: GHC.Internal.IO.Encoding.Types.CodeBuffer# from to, recover# :: GHC.Internal.IO.Buffer.Buffer from -> GHC.Internal.IO.Buffer.Buffer to -> GHC.Prim.State# GHC.Prim.RealWorld -> (# GHC.Prim.State# GHC.Prim.RealWorld, GHC.Internal.IO.Buffer.Buffer from, GHC.Internal.IO.Buffer.Buffer to #), close# :: GHC.Types.IO (), getState# :: GHC.Types.IO state, setState# :: state -> GHC.Types.IO ()}
  type CodingProgress :: *
  data CodingProgress = InputUnderflow | OutputUnderflow | InvalidSequence
  type TextDecoder :: * -> *
  type TextDecoder state = BufferCodec GHC.Internal.Word.Word8 GHC.Internal.IO.Buffer.CharBufElem state
  type TextEncoder :: * -> *
  type TextEncoder state = BufferCodec GHC.Internal.IO.Buffer.CharBufElem GHC.Internal.Word.Word8 state
  type TextEncoding :: *
  data TextEncoding = forall dstate estate. TextEncoding {textEncodingName :: GHC.Internal.Base.String, mkTextDecoder :: GHC.Types.IO (TextDecoder dstate), mkTextEncoder :: GHC.Types.IO (TextEncoder estate)}
  argvEncoding :: GHC.Types.IO TextEncoding
  char8 :: TextEncoding
  getFileSystemEncoding :: GHC.Types.IO TextEncoding
  getForeignEncoding :: GHC.Types.IO TextEncoding
  getLocaleEncoding :: GHC.Types.IO TextEncoding
  initLocaleEncoding :: TextEncoding
  latin1 :: TextEncoding
  latin1_decode :: GHC.Internal.IO.Buffer.Buffer GHC.Internal.Word.Word8 -> GHC.Internal.IO.Buffer.CharBuffer -> GHC.Types.IO (GHC.Internal.IO.Buffer.Buffer GHC.Internal.Word.Word8, GHC.Internal.IO.Buffer.CharBuffer)
  latin1_encode :: GHC.Internal.IO.Buffer.CharBuffer -> GHC.Internal.IO.Buffer.Buffer GHC.Internal.Word.Word8 -> GHC.Types.IO (GHC.Internal.IO.Buffer.CharBuffer, GHC.Internal.IO.Buffer.Buffer GHC.Internal.Word.Word8)
  mkTextEncoding :: GHC.Internal.Base.String -> GHC.Types.IO TextEncoding
  setFileSystemEncoding :: TextEncoding -> GHC.Types.IO ()
  setForeignEncoding :: TextEncoding -> GHC.Types.IO ()
  setLocaleEncoding :: TextEncoding -> GHC.Types.IO ()
  utf16 :: TextEncoding
  utf16be :: TextEncoding
  utf16le :: TextEncoding
  utf32 :: TextEncoding
  utf32be :: TextEncoding
  utf32le :: TextEncoding
  utf8 :: TextEncoding
  utf8_bom :: TextEncoding

module GHC.IO.Encoding.CodePage where
  -- Safety: Safe

module GHC.IO.Encoding.Failure where
  -- Safety: Safe
  type CodingFailureMode :: *
  data CodingFailureMode = ErrorOnCodingFailure | IgnoreCodingFailure | TransliterateCodingFailure | RoundtripFailure
  codingFailureModeSuffix :: CodingFailureMode -> GHC.Internal.Base.String
  isSurrogate :: GHC.Types.Char -> GHC.Types.Bool
  recoverDecode :: CodingFailureMode -> GHC.Internal.IO.Buffer.Buffer GHC.Internal.Word.Word8 -> GHC.Internal.IO.Buffer.Buffer GHC.Types.Char -> GHC.Types.IO (GHC.Internal.IO.Buffer.Buffer GHC.Internal.Word.Word8, GHC.Internal.IO.Buffer.Buffer GHC.Types.Char)
  recoverDecode# :: CodingFailureMode -> GHC.Internal.IO.Buffer.Buffer GHC.Internal.Word.Word8 -> GHC.Internal.IO.Buffer.Buffer GHC.Types.Char -> GHC.Prim.State# GHC.Prim.RealWorld -> (# GHC.Prim.State# GHC.Prim.RealWorld, GHC.Internal.IO.Buffer.Buffer GHC.Internal.Word.Word8, GHC.Internal.IO.Buffer.Buffer GHC.Types.Char #)
  recoverEncode :: CodingFailureMode -> GHC.Internal.IO.Buffer.Buffer GHC.Types.Char -> GHC.Internal.IO.Buffer.Buffer GHC.Internal.Word.Word8 -> GHC.Types.IO (GHC.Internal.IO.Buffer.Buffer GHC.Types.Char, GHC.Internal.IO.Buffer.Buffer GHC.Internal.Word.Word8)
  recoverEncode# :: CodingFailureMode -> GHC.Internal.IO.Buffer.Buffer GHC.Types.Char -> GHC.Internal.IO.Buffer.Buffer GHC.Internal.Word.Word8 -> GHC.Prim.State# GHC.Prim.RealWorld -> (# GHC.Prim.State# GHC.Prim.RealWorld, GHC.Internal.IO.Buffer.Buffer GHC.Types.Char, GHC.Internal.IO.Buffer.Buffer GHC.Internal.Word.Word8 #)

module GHC.IO.Encoding.Iconv where
  -- Safety: Safe
  iconvEncoding :: GHC.Internal.Base.String -> GHC.Types.IO (GHC.Internal.Maybe.Maybe GHC.Internal.IO.Encoding.Types.TextEncoding)
  localeEncodingName :: GHC.Internal.Base.String
  mkIconvEncoding :: GHC.Internal.IO.Encoding.Failure.CodingFailureMode -> GHC.Internal.Base.String -> GHC.Types.IO (GHC.Internal.Maybe.Maybe GHC.Internal.IO.Encoding.Types.TextEncoding)

module GHC.IO.Encoding.Latin1 where
  -- Safety: Safe
  ascii :: GHC.Internal.IO.Encoding.Types.TextEncoding
  ascii_decode :: GHC.Internal.IO.Encoding.Types.DecodeBuffer#
  ascii_encode :: GHC.Internal.IO.Encoding.Types.EncodeBuffer#
  latin1 :: GHC.Internal.IO.Encoding.Types.TextEncoding
  latin1_checked :: GHC.Internal.IO.Encoding.Types.TextEncoding
  latin1_checked_encode :: GHC.Internal.IO.Encoding.Types.EncodeBuffer#
  latin1_decode :: GHC.Internal.IO.Encoding.Types.DecodeBuffer#
  latin1_encode :: GHC.Internal.IO.Encoding.Types.EncodeBuffer#
  mkAscii :: GHC.Internal.IO.Encoding.Failure.CodingFailureMode -> GHC.Internal.IO.Encoding.Types.TextEncoding
  mkLatin1 :: GHC.Internal.IO.Encoding.Failure.CodingFailureMode -> GHC.Internal.IO.Encoding.Types.TextEncoding
  mkLatin1_checked :: GHC.Internal.IO.Encoding.Failure.CodingFailureMode -> GHC.Internal.IO.Encoding.Types.TextEncoding

module GHC.IO.Encoding.Types where
  -- Safety: Safe
  pattern BufferCodec :: forall from to state. CodeBuffer from to -> (GHC.Internal.IO.Buffer.Buffer from -> GHC.Internal.IO.Buffer.Buffer to -> GHC.Types.IO (GHC.Internal.IO.Buffer.Buffer from, GHC.Internal.IO.Buffer.Buffer to)) -> GHC.Types.IO () -> GHC.Types.IO state -> (state -> GHC.Types.IO ()) -> BufferCodec from to state
  pattern BufferCodec {encode, recover, close, getState, setState}
  type role BufferCodec phantom phantom representational
  type BufferCodec :: * -> * -> * -> *
  data BufferCodec from to state = BufferCodec# {encode# :: GHC.Internal.IO.Encoding.Types.CodeBuffer# from to, recover# :: GHC.Internal.IO.Buffer.Buffer from -> GHC.Internal.IO.Buffer.Buffer to -> GHC.Prim.State# GHC.Prim.RealWorld -> (# GHC.Prim.State# GHC.Prim.RealWorld, GHC.Internal.IO.Buffer.Buffer from, GHC.Internal.IO.Buffer.Buffer to #), close# :: GHC.Types.IO (), getState# :: GHC.Types.IO state, setState# :: state -> GHC.Types.IO ()}
  type CodeBuffer :: * -> * -> *
  type CodeBuffer from to = GHC.Internal.IO.Buffer.Buffer from -> GHC.Internal.IO.Buffer.Buffer to -> GHC.Types.IO (CodingProgress, GHC.Internal.IO.Buffer.Buffer from, GHC.Internal.IO.Buffer.Buffer to)
  type CodingProgress :: *
  data CodingProgress = InputUnderflow | OutputUnderflow | InvalidSequence
  type DecodeBuffer :: *
  type DecodeBuffer = CodeBuffer GHC.Internal.Word.Word8 GHC.Types.Char
  type DecodeBuffer# :: *
  type DecodeBuffer# = GHC.Internal.IO.Encoding.Types.CodeBuffer# GHC.Internal.Word.Word8 GHC.Types.Char
  type DecodingBuffer# :: *
  type DecodingBuffer# = GHC.Internal.IO.Encoding.Types.CodingBuffer# GHC.Internal.Word.Word8 GHC.Types.Char
  type EncodeBuffer :: *
  type EncodeBuffer = CodeBuffer GHC.Types.Char GHC.Internal.Word.Word8
  type EncodeBuffer# :: *
  type EncodeBuffer# = GHC.Internal.IO.Encoding.Types.CodeBuffer# GHC.Types.Char GHC.Internal.Word.Word8
  type EncodingBuffer# :: *
  type EncodingBuffer# = GHC.Internal.IO.Encoding.Types.CodingBuffer# GHC.Types.Char GHC.Internal.Word.Word8
  type TextDecoder :: * -> *
  type TextDecoder state = BufferCodec GHC.Internal.Word.Word8 GHC.Internal.IO.Buffer.CharBufElem state
  type TextEncoder :: * -> *
  type TextEncoder state = BufferCodec GHC.Internal.IO.Buffer.CharBufElem GHC.Internal.Word.Word8 state
  type TextEncoding :: *
  data TextEncoding = forall dstate estate. TextEncoding {textEncodingName :: GHC.Internal.Base.String, mkTextDecoder :: GHC.Types.IO (TextDecoder dstate), mkTextEncoder :: GHC.Types.IO (TextEncoder estate)}

module GHC.IO.Encoding.UTF16 where
  -- Safety: Safe
  mkUTF16 :: GHC.Internal.IO.Encoding.Failure.CodingFailureMode -> GHC.Internal.IO.Encoding.Types.TextEncoding
  mkUTF16be :: GHC.Internal.IO.Encoding.Failure.CodingFailureMode -> GHC.Internal.IO.Encoding.Types.TextEncoding
  mkUTF16le :: GHC.Internal.IO.Encoding.Failure.CodingFailureMode -> GHC.Internal.IO.Encoding.Types.TextEncoding
  utf16 :: GHC.Internal.IO.Encoding.Types.TextEncoding
  utf16_decode :: GHC.Internal.IORef.IORef (GHC.Internal.Maybe.Maybe GHC.Internal.IO.Encoding.Types.DecodeBuffer#) -> GHC.Internal.IO.Encoding.Types.DecodeBuffer#
  utf16_encode :: GHC.Internal.IORef.IORef GHC.Types.Bool -> GHC.Internal.IO.Encoding.Types.EncodeBuffer#
  utf16be :: GHC.Internal.IO.Encoding.Types.TextEncoding
  utf16be_decode :: GHC.Internal.IO.Encoding.Types.DecodeBuffer#
  utf16be_encode :: GHC.Internal.IO.Encoding.Types.EncodeBuffer#
  utf16le :: GHC.Internal.IO.Encoding.Types.TextEncoding
  utf16le_decode :: GHC.Internal.IO.Encoding.Types.DecodeBuffer#
  utf16le_encode :: GHC.Internal.IO.Encoding.Types.EncodeBuffer#

module GHC.IO.Encoding.UTF32 where
  -- Safety: Safe
  mkUTF32 :: GHC.Internal.IO.Encoding.Failure.CodingFailureMode -> GHC.Internal.IO.Encoding.Types.TextEncoding
  mkUTF32be :: GHC.Internal.IO.Encoding.Failure.CodingFailureMode -> GHC.Internal.IO.Encoding.Types.TextEncoding
  mkUTF32le :: GHC.Internal.IO.Encoding.Failure.CodingFailureMode -> GHC.Internal.IO.Encoding.Types.TextEncoding
  utf32 :: GHC.Internal.IO.Encoding.Types.TextEncoding
  utf32_decode :: GHC.Internal.IORef.IORef (GHC.Internal.Maybe.Maybe GHC.Internal.IO.Encoding.Types.DecodeBuffer#) -> GHC.Internal.IO.Encoding.Types.DecodeBuffer#
  utf32_encode :: GHC.Internal.IORef.IORef GHC.Types.Bool -> GHC.Internal.IO.Encoding.Types.EncodeBuffer#
  utf32be :: GHC.Internal.IO.Encoding.Types.TextEncoding
  utf32be_decode :: GHC.Internal.IO.Encoding.Types.DecodeBuffer#
  utf32be_encode :: GHC.Internal.IO.Encoding.Types.EncodeBuffer#
  utf32le :: GHC.Internal.IO.Encoding.Types.TextEncoding
  utf32le_decode :: GHC.Internal.IO.Encoding.Types.DecodeBuffer#
  utf32le_encode :: GHC.Internal.IO.Encoding.Types.EncodeBuffer#

module GHC.IO.Encoding.UTF8 where
  -- Safety: Safe
  mkUTF8 :: GHC.Internal.IO.Encoding.Failure.CodingFailureMode -> GHC.Internal.IO.Encoding.Types.TextEncoding
  mkUTF8_bom :: GHC.Internal.IO.Encoding.Failure.CodingFailureMode -> GHC.Internal.IO.Encoding.Types.TextEncoding
  utf8 :: GHC.Internal.IO.Encoding.Types.TextEncoding
  utf8_bom :: GHC.Internal.IO.Encoding.Types.TextEncoding

module GHC.IO.Exception where
  -- Safety: Safe
  type AllocationLimitExceeded :: *
  data AllocationLimitExceeded = AllocationLimitExceeded
  type ArrayException :: *
  data ArrayException = IndexOutOfBounds GHC.Internal.Base.String | UndefinedElement GHC.Internal.Base.String
  type AssertionFailed :: *
  newtype AssertionFailed = AssertionFailed GHC.Internal.Base.String
  type AsyncException :: *
  data AsyncException = StackOverflow | HeapOverflow | ThreadKilled | UserInterrupt
  type BlockedIndefinitelyOnMVar :: *
  data BlockedIndefinitelyOnMVar = BlockedIndefinitelyOnMVar
  type BlockedIndefinitelyOnSTM :: *
  data BlockedIndefinitelyOnSTM = BlockedIndefinitelyOnSTM
  type CompactionFailed :: *
  newtype CompactionFailed = CompactionFailed GHC.Internal.Base.String
  type Deadlock :: *
  data Deadlock = Deadlock
  type ExitCode :: *
  data ExitCode = ExitSuccess | ExitFailure GHC.Types.Int
  type FixIOException :: *
  data FixIOException = FixIOException
  type IOError :: *
  type IOError = IOException
  type IOErrorType :: *
  data IOErrorType = AlreadyExists | NoSuchThing | ResourceBusy | ResourceExhausted | EOF | IllegalOperation | PermissionDenied | UserError | UnsatisfiedConstraints | SystemError | ProtocolError | OtherError | InvalidArgument | InappropriateType | HardwareFault | UnsupportedOperation | TimeExpired | ResourceVanished | Interrupted
  type IOException :: *
  data IOException = IOError {ioe_handle :: GHC.Internal.Maybe.Maybe GHC.Internal.IO.Handle.Types.Handle, ioe_type :: IOErrorType, ioe_location :: GHC.Internal.Base.String, ioe_description :: GHC.Internal.Base.String, ioe_errno :: GHC.Internal.Maybe.Maybe GHC.Internal.Foreign.C.Types.CInt, ioe_filename :: GHC.Internal.Maybe.Maybe GHC.Internal.IO.FilePath}
  type SomeAsyncException :: *
  data SomeAsyncException = forall e. GHC.Internal.Exception.Type.Exception e => SomeAsyncException e
  allocationLimitExceeded :: GHC.Internal.Exception.Type.SomeException
  assertError :: forall a. (?callStack::GHC.Internal.Stack.Types.CallStack) => GHC.Types.Bool -> a -> a
  asyncExceptionFromException :: forall e. GHC.Internal.Exception.Type.Exception e => GHC.Internal.Exception.Type.SomeException -> GHC.Internal.Maybe.Maybe e
  asyncExceptionToException :: forall e. GHC.Internal.Exception.Type.Exception e => e -> GHC.Internal.Exception.Type.SomeException
  blockedIndefinitelyOnMVar :: GHC.Internal.Exception.Type.SomeException
  blockedIndefinitelyOnSTM :: GHC.Internal.Exception.Type.SomeException
  cannotCompactFunction :: GHC.Internal.Exception.Type.SomeException
  cannotCompactMutable :: GHC.Internal.Exception.Type.SomeException
  cannotCompactPinned :: GHC.Internal.Exception.Type.SomeException
  heapOverflow :: GHC.Internal.Exception.Type.SomeException
  ioError :: forall a. IOError -> GHC.Types.IO a
  ioException :: forall a. GHC.Internal.Stack.Types.HasCallStack => IOException -> GHC.Types.IO a
  stackOverflow :: GHC.Internal.Exception.Type.SomeException
  unsupportedOperation :: IOError
  untangle :: GHC.Prim.Addr# -> GHC.Internal.Base.String -> GHC.Internal.Base.String
  userError :: GHC.Internal.Base.String -> IOError

module GHC.IO.FD where
  -- Safety: Safe
  type FD :: *
  data FD = FD {fdFD :: ! {-# UNPACK #-}(GHC.Internal.Foreign.C.Types.N:CInt[0])GHC.Internal.Foreign.C.Types.CInt, fdIsNonBlocking :: {-# UNPACK #-}GHC.Types.Int}
  mkFD :: GHC.Internal.Foreign.C.Types.CInt -> GHC.Internal.IO.IOMode.IOMode -> GHC.Internal.Maybe.Maybe (GHC.Internal.IO.Device.IODeviceType, GHC.Internal.System.Posix.Types.CDev, GHC.Internal.System.Posix.Types.CIno) -> GHC.Types.Bool -> GHC.Types.Bool -> GHC.Types.IO (FD, GHC.Internal.IO.Device.IODeviceType)
  openFile :: GHC.Internal.IO.FilePath -> GHC.Internal.IO.IOMode.IOMode -> GHC.Types.Bool -> GHC.Types.IO (FD, GHC.Internal.IO.Device.IODeviceType)
  openFileWith :: forall r s. GHC.Internal.IO.FilePath -> GHC.Internal.IO.IOMode.IOMode -> GHC.Types.Bool -> (FD -> GHC.Internal.IO.Device.IODeviceType -> GHC.Types.IO r) -> ((forall x. GHC.Types.IO x -> GHC.Types.IO x) -> r -> GHC.Types.IO s) -> GHC.Types.IO s
  readRawBufferPtr :: GHC.Internal.Base.String -> FD -> GHC.Internal.Ptr.Ptr GHC.Internal.Word.Word8 -> GHC.Types.Int -> GHC.Internal.Foreign.C.Types.CSize -> GHC.Types.IO GHC.Types.Int
  readRawBufferPtrNoBlock :: GHC.Internal.Base.String -> FD -> GHC.Internal.Ptr.Ptr GHC.Internal.Word.Word8 -> GHC.Types.Int -> GHC.Internal.Foreign.C.Types.CSize -> GHC.Types.IO GHC.Types.Int
  release :: FD -> GHC.Types.IO ()
  setNonBlockingMode :: FD -> GHC.Types.Bool -> GHC.Types.IO FD
  stderr :: FD
  stdin :: FD
  stdout :: FD
  writeRawBufferPtr :: GHC.Internal.Base.String -> FD -> GHC.Internal.Ptr.Ptr GHC.Internal.Word.Word8 -> GHC.Types.Int -> GHC.Internal.Foreign.C.Types.CSize -> GHC.Types.IO GHC.Internal.Foreign.C.Types.CInt

module GHC.IO.Handle where
  -- Safety: Safe
  type BufferMode :: *
  data BufferMode = NoBuffering | LineBuffering | BlockBuffering (GHC.Internal.Maybe.Maybe GHC.Types.Int)
  type Handle :: *
  data Handle = ...
  type HandlePosition :: *
  type HandlePosition = GHC.Num.Integer.Integer
  type HandlePosn :: *
  data HandlePosn = HandlePosn Handle HandlePosition
  type LockMode :: *
  data LockMode = SharedLock | ExclusiveLock
  type Newline :: *
  data Newline = LF | CRLF
  type NewlineMode :: *
  data NewlineMode = NewlineMode {inputNL :: Newline, outputNL :: Newline}
  type SeekMode :: *
  data SeekMode = AbsoluteSeek | RelativeSeek | SeekFromEnd
  hClose :: Handle -> GHC.Types.IO ()
  hClose_help :: GHC.Internal.IO.Handle.Types.Handle__ -> GHC.Types.IO (GHC.Internal.IO.Handle.Types.Handle__, GHC.Internal.Maybe.Maybe GHC.Internal.Exception.Type.SomeException)
  hDuplicate :: Handle -> GHC.Types.IO Handle
  hDuplicateTo :: Handle -> Handle -> GHC.Types.IO ()
  hFileSize :: Handle -> GHC.Types.IO GHC.Num.Integer.Integer
  hFlush :: Handle -> GHC.Types.IO ()
  hFlushAll :: Handle -> GHC.Types.IO ()
  hGetBuf :: forall a. Handle -> GHC.Internal.Ptr.Ptr a -> GHC.Types.Int -> GHC.Types.IO GHC.Types.Int
  hGetBufNonBlocking :: forall a. Handle -> GHC.Internal.Ptr.Ptr a -> GHC.Types.Int -> GHC.Types.IO GHC.Types.Int
  hGetBuffering :: Handle -> GHC.Types.IO BufferMode
  hGetChar :: Handle -> GHC.Types.IO GHC.Types.Char
  hGetContents :: Handle -> GHC.Types.IO GHC.Internal.Base.String
  hGetContents' :: Handle -> GHC.Types.IO GHC.Internal.Base.String
  hGetEcho :: Handle -> GHC.Types.IO GHC.Types.Bool
  hGetEncoding :: Handle -> GHC.Types.IO (GHC.Internal.Maybe.Maybe GHC.Internal.IO.Encoding.Types.TextEncoding)
  hGetLine :: Handle -> GHC.Types.IO GHC.Internal.Base.String
  hGetPosn :: Handle -> GHC.Types.IO HandlePosn
  hIsClosed :: Handle -> GHC.Types.IO GHC.Types.Bool
  hIsEOF :: Handle -> GHC.Types.IO GHC.Types.Bool
  hIsOpen :: Handle -> GHC.Types.IO GHC.Types.Bool
  hIsReadable :: Handle -> GHC.Types.IO GHC.Types.Bool
  hIsSeekable :: Handle -> GHC.Types.IO GHC.Types.Bool
  hIsTerminalDevice :: Handle -> GHC.Types.IO GHC.Types.Bool
  hIsWritable :: Handle -> GHC.Types.IO GHC.Types.Bool
  hLock :: Handle -> LockMode -> GHC.Types.IO ()
  hLookAhead :: Handle -> GHC.Types.IO GHC.Types.Char
  hPutBuf :: forall a. Handle -> GHC.Internal.Ptr.Ptr a -> GHC.Types.Int -> GHC.Types.IO ()
  hPutBufNonBlocking :: forall a. Handle -> GHC.Internal.Ptr.Ptr a -> GHC.Types.Int -> GHC.Types.IO GHC.Types.Int
  hPutChar :: Handle -> GHC.Types.Char -> GHC.Types.IO ()
  hPutStr :: Handle -> GHC.Internal.Base.String -> GHC.Types.IO ()
  hSeek :: Handle -> SeekMode -> GHC.Num.Integer.Integer -> GHC.Types.IO ()
  hSetBinaryMode :: Handle -> GHC.Types.Bool -> GHC.Types.IO ()
  hSetBuffering :: Handle -> BufferMode -> GHC.Types.IO ()
  hSetEcho :: Handle -> GHC.Types.Bool -> GHC.Types.IO ()
  hSetEncoding :: Handle -> GHC.Internal.IO.Encoding.Types.TextEncoding -> GHC.Types.IO ()
  hSetFileSize :: Handle -> GHC.Num.Integer.Integer -> GHC.Types.IO ()
  hSetNewlineMode :: Handle -> NewlineMode -> GHC.Types.IO ()
  hSetPosn :: HandlePosn -> GHC.Types.IO ()
  hShow :: Handle -> GHC.Types.IO GHC.Internal.Base.String
  hTell :: Handle -> GHC.Types.IO GHC.Num.Integer.Integer
  hTryLock :: Handle -> LockMode -> GHC.Types.IO GHC.Types.Bool
  hWaitForInput :: Handle -> GHC.Types.Int -> GHC.Types.IO GHC.Types.Bool
  isEOF :: GHC.Types.IO GHC.Types.Bool
  mkDuplexHandle :: forall dev. (GHC.Internal.IO.Device.RawIO dev, GHC.Internal.IO.Device.IODevice dev, GHC.Internal.IO.BufferedIO.BufferedIO dev, ghc-internal-0.1.0.0:GHC.Internal.Data.Typeable.Internal.Typeable dev) => dev -> GHC.Internal.IO.FilePath -> GHC.Internal.Maybe.Maybe GHC.Internal.IO.Encoding.Types.TextEncoding -> NewlineMode -> GHC.Types.IO Handle
  mkFileHandle :: forall dev. (GHC.Internal.IO.Device.RawIO dev, GHC.Internal.IO.Device.IODevice dev, GHC.Internal.IO.BufferedIO.BufferedIO dev, ghc-internal-0.1.0.0:GHC.Internal.Data.Typeable.Internal.Typeable dev) => dev -> GHC.Internal.IO.FilePath -> GHC.Internal.IO.IOMode.IOMode -> GHC.Internal.Maybe.Maybe GHC.Internal.IO.Encoding.Types.TextEncoding -> NewlineMode -> GHC.Types.IO Handle
  nativeNewline :: Newline
  nativeNewlineMode :: NewlineMode
  noNewlineTranslation :: NewlineMode
  universalNewlineMode :: NewlineMode

module GHC.IO.Handle.FD where
  -- Safety: Safe
  fdToHandle :: GHC.Internal.System.Posix.Internals.FD -> GHC.Types.IO GHC.Internal.IO.Handle.Types.Handle
  fdToHandle' :: GHC.Internal.Foreign.C.Types.CInt -> GHC.Internal.Maybe.Maybe GHC.Internal.IO.Device.IODeviceType -> GHC.Types.Bool -> GHC.Internal.IO.FilePath -> GHC.Internal.IO.IOMode.IOMode -> GHC.Types.Bool -> GHC.Types.IO GHC.Internal.IO.Handle.Types.Handle
  handleToFd :: GHC.Internal.IO.Handle.Types.Handle -> GHC.Types.IO GHC.Internal.IO.FD.FD
  mkHandleFromFD :: GHC.Internal.IO.FD.FD -> GHC.Internal.IO.Device.IODeviceType -> GHC.Internal.IO.FilePath -> GHC.Internal.IO.IOMode.IOMode -> GHC.Types.Bool -> GHC.Internal.Maybe.Maybe GHC.Internal.IO.Encoding.Types.TextEncoding -> GHC.Types.IO GHC.Internal.IO.Handle.Types.Handle
  openBinaryFile :: GHC.Internal.IO.FilePath -> GHC.Internal.IO.IOMode.IOMode -> GHC.Types.IO GHC.Internal.IO.Handle.Types.Handle
  openFile :: GHC.Internal.IO.FilePath -> GHC.Internal.IO.IOMode.IOMode -> GHC.Types.IO GHC.Internal.IO.Handle.Types.Handle
  openFileBlocking :: GHC.Internal.IO.FilePath -> GHC.Internal.IO.IOMode.IOMode -> GHC.Types.IO GHC.Internal.IO.Handle.Types.Handle
  stderr :: GHC.Internal.IO.Handle.Types.Handle
  stdin :: GHC.Internal.IO.Handle.Types.Handle
  stdout :: GHC.Internal.IO.Handle.Types.Handle
  withBinaryFile :: forall r. GHC.Internal.IO.FilePath -> GHC.Internal.IO.IOMode.IOMode -> (GHC.Internal.IO.Handle.Types.Handle -> GHC.Types.IO r) -> GHC.Types.IO r
  withFile :: forall r. GHC.Internal.IO.FilePath -> GHC.Internal.IO.IOMode.IOMode -> (GHC.Internal.IO.Handle.Types.Handle -> GHC.Types.IO r) -> GHC.Types.IO r
  withFileBlocking :: forall r. GHC.Internal.IO.FilePath -> GHC.Internal.IO.IOMode.IOMode -> (GHC.Internal.IO.Handle.Types.Handle -> GHC.Types.IO r) -> GHC.Types.IO r

module GHC.IO.Handle.Internals where
  -- Safety: Safe
  type HandleFinalizer :: *
  type HandleFinalizer = GHC.Internal.IO.FilePath -> GHC.Internal.MVar.MVar GHC.Internal.IO.Handle.Types.Handle__ -> GHC.Types.IO ()
  addHandleFinalizer :: GHC.Internal.IO.Handle.Types.Handle -> HandleFinalizer -> GHC.Types.IO ()
  augmentIOError :: GHC.Internal.IO.Exception.IOException -> GHC.Internal.Base.String -> GHC.Internal.IO.Handle.Types.Handle -> GHC.Internal.IO.Exception.IOException
  closeTextCodecs :: GHC.Internal.IO.Handle.Types.Handle__ -> GHC.Types.IO ()
  dEFAULT_CHAR_BUFFER_SIZE :: GHC.Types.Int
  debugIO :: GHC.Internal.Base.String -> GHC.Types.IO ()
  decodeByteBuf :: GHC.Internal.IO.Handle.Types.Handle__ -> GHC.Internal.IO.Buffer.CharBuffer -> GHC.Types.IO GHC.Internal.IO.Buffer.CharBuffer
  flushBuffer :: GHC.Internal.IO.Handle.Types.Handle__ -> GHC.Types.IO ()
  flushByteReadBuffer :: GHC.Internal.IO.Handle.Types.Handle__ -> GHC.Types.IO ()
  flushByteWriteBuffer :: GHC.Internal.IO.Handle.Types.Handle__ -> GHC.Types.IO ()
  flushCharBuffer :: GHC.Internal.IO.Handle.Types.Handle__ -> GHC.Types.IO ()
  flushCharReadBuffer :: GHC.Internal.IO.Handle.Types.Handle__ -> GHC.Types.IO ()
  flushWriteBuffer :: GHC.Internal.IO.Handle.Types.Handle__ -> GHC.Types.IO ()
  hClose_help :: GHC.Internal.IO.Handle.Types.Handle__ -> GHC.Types.IO (GHC.Internal.IO.Handle.Types.Handle__, GHC.Internal.Maybe.Maybe GHC.Internal.Exception.Type.SomeException)
  hClose_impl :: GHC.Internal.IO.Handle.Types.Handle -> GHC.Types.IO ()
  hLookAhead_ :: GHC.Internal.IO.Handle.Types.Handle__ -> GHC.Types.IO GHC.Types.Char
  handleFinalizer :: GHC.Internal.IO.FilePath -> GHC.Internal.MVar.MVar GHC.Internal.IO.Handle.Types.Handle__ -> GHC.Types.IO ()
  initBufferState :: GHC.Internal.IO.Handle.Types.HandleType -> GHC.Internal.IO.Buffer.BufferState
  ioe_EOF :: forall a. GHC.Types.IO a
  ioe_bufsiz :: forall a. GHC.Types.Int -> GHC.Types.IO a
  ioe_closedHandle :: forall a. GHC.Types.IO a
  ioe_finalizedHandle :: GHC.Internal.IO.FilePath -> GHC.Internal.IO.Handle.Types.Handle__
  ioe_notReadable :: forall a. GHC.Types.IO a
  ioe_notWritable :: forall a. GHC.Types.IO a
  ioe_semiclosedHandle :: forall a. GHC.Types.IO a
  mkDuplexHandle :: forall dev. (GHC.Internal.IO.Device.RawIO dev, GHC.Internal.IO.Device.IODevice dev, GHC.Internal.IO.BufferedIO.BufferedIO dev, ghc-internal-0.1.0.0:GHC.Internal.Data.Typeable.Internal.Typeable dev) => dev -> GHC.Internal.IO.FilePath -> GHC.Internal.Maybe.Maybe GHC.Internal.IO.Encoding.Types.TextEncoding -> GHC.Internal.IO.Handle.Types.NewlineMode -> GHC.Types.IO GHC.Internal.IO.Handle.Types.Handle
  mkDuplexHandleNoFinalizer :: forall dev. (GHC.Internal.IO.Device.RawIO dev, GHC.Internal.IO.Device.IODevice dev, GHC.Internal.IO.BufferedIO.BufferedIO dev, ghc-internal-0.1.0.0:GHC.Internal.Data.Typeable.Internal.Typeable dev) => dev -> GHC.Internal.IO.FilePath -> GHC.Internal.Maybe.Maybe GHC.Internal.IO.Encoding.Types.TextEncoding -> GHC.Internal.IO.Handle.Types.NewlineMode -> GHC.Types.IO GHC.Internal.IO.Handle.Types.Handle
  mkFileHandle :: forall dev. (GHC.Internal.IO.Device.RawIO dev, GHC.Internal.IO.Device.IODevice dev, GHC.Internal.IO.BufferedIO.BufferedIO dev, ghc-internal-0.1.0.0:GHC.Internal.Data.Typeable.Internal.Typeable dev) => dev -> GHC.Internal.IO.FilePath -> GHC.Internal.IO.IOMode.IOMode -> GHC.Internal.Maybe.Maybe GHC.Internal.IO.Encoding.Types.TextEncoding -> GHC.Internal.IO.Handle.Types.NewlineMode -> GHC.Types.IO GHC.Internal.IO.Handle.Types.Handle
  mkFileHandleNoFinalizer :: forall dev. (GHC.Internal.IO.Device.RawIO dev, GHC.Internal.IO.Device.IODevice dev, GHC.Internal.IO.BufferedIO.BufferedIO dev, ghc-internal-0.1.0.0:GHC.Internal.Data.Typeable.Internal.Typeable dev) => dev -> GHC.Internal.IO.FilePath -> GHC.Internal.IO.IOMode.IOMode -> GHC.Internal.Maybe.Maybe GHC.Internal.IO.Encoding.Types.TextEncoding -> GHC.Internal.IO.Handle.Types.NewlineMode -> GHC.Types.IO GHC.Internal.IO.Handle.Types.Handle
  mkHandle :: forall dev. (GHC.Internal.IO.Device.RawIO dev, GHC.Internal.IO.Device.IODevice dev, GHC.Internal.IO.BufferedIO.BufferedIO dev, ghc-internal-0.1.0.0:GHC.Internal.Data.Typeable.Internal.Typeable dev) => dev -> GHC.Internal.IO.FilePath -> GHC.Internal.IO.Handle.Types.HandleType -> GHC.Types.Bool -> GHC.Internal.Maybe.Maybe GHC.Internal.IO.Encoding.Types.TextEncoding -> GHC.Internal.IO.Handle.Types.NewlineMode -> GHC.Internal.Maybe.Maybe HandleFinalizer -> GHC.Internal.Maybe.Maybe (GHC.Internal.MVar.MVar GHC.Internal.IO.Handle.Types.Handle__) -> GHC.Types.IO GHC.Internal.IO.Handle.Types.Handle
  openTextEncoding :: forall a. GHC.Internal.Maybe.Maybe GHC.Internal.IO.Encoding.Types.TextEncoding -> GHC.Internal.IO.Handle.Types.HandleType -> (forall es ds. GHC.Internal.Maybe.Maybe (GHC.Internal.IO.Encoding.Types.TextEncoder es) -> GHC.Internal.Maybe.Maybe (GHC.Internal.IO.Encoding.Types.TextDecoder ds) -> GHC.Types.IO a) -> GHC.Types.IO a
  readTextDevice :: GHC.Internal.IO.Handle.Types.Handle__ -> GHC.Internal.IO.Buffer.CharBuffer -> GHC.Types.IO GHC.Internal.IO.Buffer.CharBuffer
  readTextDeviceNonBlocking :: GHC.Internal.IO.Handle.Types.Handle__ -> GHC.Internal.IO.Buffer.CharBuffer -> GHC.Types.IO GHC.Internal.IO.Buffer.CharBuffer
  traceIO :: GHC.Internal.Base.String -> GHC.Types.IO ()
  wantReadableHandle :: forall a. GHC.Internal.Base.String -> GHC.Internal.IO.Handle.Types.Handle -> (GHC.Internal.IO.Handle.Types.Handle__ -> GHC.Types.IO (GHC.Internal.IO.Handle.Types.Handle__, a)) -> GHC.Types.IO a
  wantReadableHandle_ :: forall a. GHC.Internal.Base.String -> GHC.Internal.IO.Handle.Types.Handle -> (GHC.Internal.IO.Handle.Types.Handle__ -> GHC.Types.IO a) -> GHC.Types.IO a
  wantSeekableHandle :: forall a. GHC.Internal.Base.String -> GHC.Internal.IO.Handle.Types.Handle -> (GHC.Internal.IO.Handle.Types.Handle__ -> GHC.Types.IO a) -> GHC.Types.IO a
  wantWritableHandle :: forall a. GHC.Internal.Base.String -> GHC.Internal.IO.Handle.Types.Handle -> (GHC.Internal.IO.Handle.Types.Handle__ -> GHC.Types.IO a) -> GHC.Types.IO a
  withAllHandles__ :: GHC.Internal.Base.String -> GHC.Internal.IO.Handle.Types.Handle -> (GHC.Internal.IO.Handle.Types.Handle__ -> GHC.Types.IO GHC.Internal.IO.Handle.Types.Handle__) -> GHC.Types.IO ()
  withHandle :: forall a. GHC.Internal.Base.String -> GHC.Internal.IO.Handle.Types.Handle -> (GHC.Internal.IO.Handle.Types.Handle__ -> GHC.Types.IO (GHC.Internal.IO.Handle.Types.Handle__, a)) -> GHC.Types.IO a
  withHandle' :: forall a. GHC.Internal.Base.String -> GHC.Internal.IO.Handle.Types.Handle -> GHC.Internal.MVar.MVar GHC.Internal.IO.Handle.Types.Handle__ -> (GHC.Internal.IO.Handle.Types.Handle__ -> GHC.Types.IO (GHC.Internal.IO.Handle.Types.Handle__, a)) -> GHC.Types.IO a
  withHandle_ :: forall a. GHC.Internal.Base.String -> GHC.Internal.IO.Handle.Types.Handle -> (GHC.Internal.IO.Handle.Types.Handle__ -> GHC.Types.IO a) -> GHC.Types.IO a
  withHandle_' :: forall a. GHC.Internal.Base.String -> GHC.Internal.IO.Handle.Types.Handle -> GHC.Internal.MVar.MVar GHC.Internal.IO.Handle.Types.Handle__ -> (GHC.Internal.IO.Handle.Types.Handle__ -> GHC.Types.IO a) -> GHC.Types.IO a
  withHandle__' :: GHC.Internal.Base.String -> GHC.Internal.IO.Handle.Types.Handle -> GHC.Internal.MVar.MVar GHC.Internal.IO.Handle.Types.Handle__ -> (GHC.Internal.IO.Handle.Types.Handle__ -> GHC.Types.IO GHC.Internal.IO.Handle.Types.Handle__) -> GHC.Types.IO ()
  writeCharBuffer :: GHC.Internal.IO.Handle.Types.Handle__ -> GHC.Internal.IO.Buffer.CharBuffer -> GHC.Types.IO ()

module GHC.IO.Handle.Lock where
  -- Safety: None
  type FileLockingNotSupported :: *
  data FileLockingNotSupported = FileLockingNotSupported
  type LockMode :: *
  data LockMode = SharedLock | ExclusiveLock
  hLock :: GHC.Internal.IO.Handle.Types.Handle -> LockMode -> GHC.Types.IO ()
  hTryLock :: GHC.Internal.IO.Handle.Types.Handle -> LockMode -> GHC.Types.IO GHC.Types.Bool
  hUnlock :: GHC.Internal.IO.Handle.Types.Handle -> GHC.Types.IO ()

module GHC.IO.Handle.Text where
  -- Safety: Safe
  commitBuffer' :: GHC.Internal.IO.Buffer.RawCharBuffer -> GHC.Types.Int -> GHC.Types.Int -> GHC.Types.Bool -> GHC.Types.Bool -> GHC.Internal.IO.Handle.Types.Handle__ -> GHC.Types.IO GHC.Internal.IO.Buffer.CharBuffer
  hGetBuf :: forall a. GHC.Internal.IO.Handle.Types.Handle -> GHC.Internal.Ptr.Ptr a -> GHC.Types.Int -> GHC.Types.IO GHC.Types.Int
  hGetBufNonBlocking :: forall a. GHC.Internal.IO.Handle.Types.Handle -> GHC.Internal.Ptr.Ptr a -> GHC.Types.Int -> GHC.Types.IO GHC.Types.Int
  hGetBufSome :: forall a. GHC.Internal.IO.Handle.Types.Handle -> GHC.Internal.Ptr.Ptr a -> GHC.Types.Int -> GHC.Types.IO GHC.Types.Int
  hGetChar :: GHC.Internal.IO.Handle.Types.Handle -> GHC.Types.IO GHC.Types.Char
  hGetContents :: GHC.Internal.IO.Handle.Types.Handle -> GHC.Types.IO GHC.Internal.Base.String
  hGetContents' :: GHC.Internal.IO.Handle.Types.Handle -> GHC.Types.IO GHC.Internal.Base.String
  hGetLine :: GHC.Internal.IO.Handle.Types.Handle -> GHC.Types.IO GHC.Internal.Base.String
  hPutBuf :: forall a. GHC.Internal.IO.Handle.Types.Handle -> GHC.Internal.Ptr.Ptr a -> GHC.Types.Int -> GHC.Types.IO ()
  hPutBufNonBlocking :: forall a. GHC.Internal.IO.Handle.Types.Handle -> GHC.Internal.Ptr.Ptr a -> GHC.Types.Int -> GHC.Types.IO GHC.Types.Int
  hPutChar :: GHC.Internal.IO.Handle.Types.Handle -> GHC.Types.Char -> GHC.Types.IO ()
  hPutStr :: GHC.Internal.IO.Handle.Types.Handle -> GHC.Internal.Base.String -> GHC.Types.IO ()
  hPutStrLn :: GHC.Internal.IO.Handle.Types.Handle -> GHC.Internal.Base.String -> GHC.Types.IO ()
  hWaitForInput :: GHC.Internal.IO.Handle.Types.Handle -> GHC.Types.Int -> GHC.Types.IO GHC.Types.Bool
  memcpy :: forall a. GHC.Internal.Ptr.Ptr a -> GHC.Internal.Ptr.Ptr a -> GHC.Internal.Foreign.C.Types.CSize -> GHC.Types.IO (GHC.Internal.Ptr.Ptr ())

module GHC.IO.Handle.Types where
  -- Safety: Safe
  pattern BufferCodec :: forall from to state. GHC.Internal.IO.Encoding.Types.CodeBuffer from to -> (GHC.Internal.IO.Buffer.Buffer from -> GHC.Internal.IO.Buffer.Buffer to -> GHC.Types.IO (GHC.Internal.IO.Buffer.Buffer from, GHC.Internal.IO.Buffer.Buffer to)) -> GHC.Types.IO () -> GHC.Types.IO state -> (state -> GHC.Types.IO ()) -> BufferCodec from to state
  pattern BufferCodec {encode, recover, close, getState, setState}
  type role BufferCodec phantom phantom representational
  type BufferCodec :: * -> * -> * -> *
  data BufferCodec from to state = BufferCodec# {encode# :: GHC.Internal.IO.Encoding.Types.CodeBuffer# from to, recover# :: GHC.Internal.IO.Buffer.Buffer from -> GHC.Internal.IO.Buffer.Buffer to -> GHC.Prim.State# GHC.Prim.RealWorld -> (# GHC.Prim.State# GHC.Prim.RealWorld, GHC.Internal.IO.Buffer.Buffer from, GHC.Internal.IO.Buffer.Buffer to #), close# :: GHC.Types.IO (), getState# :: GHC.Types.IO state, setState# :: state -> GHC.Types.IO ()}
  type role BufferList phantom
  type BufferList :: * -> *
  data BufferList e = BufferListNil | BufferListCons (GHC.Internal.IO.Buffer.RawBuffer e) (BufferList e)
  type BufferMode :: *
  data BufferMode = NoBuffering | LineBuffering | BlockBuffering (GHC.Internal.Maybe.Maybe GHC.Types.Int)
  type Handle :: *
  data Handle = FileHandle GHC.Internal.IO.FilePath {-# UNPACK #-}(GHC.Internal.MVar.MVar Handle__) | DuplexHandle GHC.Internal.IO.FilePath {-# UNPACK #-}(GHC.Internal.MVar.MVar Handle__) {-# UNPACK #-}(GHC.Internal.MVar.MVar Handle__)
  type HandleType :: *
  data HandleType = ClosedHandle | SemiClosedHandle | ReadHandle | WriteHandle | AppendHandle | ReadWriteHandle
  type Handle__ :: *
  data Handle__
    = forall dev enc_state dec_state.
      (GHC.Internal.IO.Device.RawIO dev, GHC.Internal.IO.Device.IODevice dev, GHC.Internal.IO.BufferedIO.BufferedIO dev, ghc-internal-0.1.0.0:GHC.Internal.Data.Typeable.Internal.Typeable dev) =>
      Handle__ {haDevice :: !dev,
                haType :: HandleType,
                haByteBuffer :: ! {-# UNPACK #-}(GHC.Internal.IORef.N:IORef[0] <GHC.Internal.IO.Buffer.Buffer GHC.Internal.Word.Word8>_N)(GHC.Internal.IORef.IORef (GHC.Internal.IO.Buffer.Buffer GHC.Internal.Word.Word8)),
                haBufferMode :: BufferMode,
                haLastDecode :: ! {-# UNPACK #-}(GHC.Internal.IORef.N:IORef[0] <(dec_state, GHC.Internal.IO.Buffer.Buffer GHC.Internal.Word.Word8)>_N)(GHC.Internal.IORef.IORef (dec_state, GHC.Internal.IO.Buffer.Buffer GHC.Internal.Word.Word8)),
                haCharBuffer :: ! {-# UNPACK #-}(GHC.Internal.IORef.N:IORef[0] <GHC.Internal.IO.Buffer.Buffer GHC.Internal.IO.Buffer.CharBufElem>_N)(GHC.Internal.IORef.IORef (GHC.Internal.IO.Buffer.Buffer GHC.Internal.IO.Buffer.CharBufElem)),
                haBuffers :: ! {-# UNPACK #-}(GHC.Internal.IORef.N:IORef[0] <BufferList GHC.Internal.IO.Buffer.CharBufElem>_N)(GHC.Internal.IORef.IORef (BufferList GHC.Internal.IO.Buffer.CharBufElem)),
                haEncoder :: GHC.Internal.Maybe.Maybe (GHC.Internal.IO.Encoding.Types.TextEncoder enc_state),
                haDecoder :: GHC.Internal.Maybe.Maybe (GHC.Internal.IO.Encoding.Types.TextDecoder dec_state),
                haCodec :: GHC.Internal.Maybe.Maybe GHC.Internal.IO.Encoding.Types.TextEncoding,
                haInputNL :: Newline,
                haOutputNL :: Newline,
                haOtherSide :: GHC.Internal.Maybe.Maybe (GHC.Internal.MVar.MVar Handle__)}
  type Newline :: *
  data Newline = LF | CRLF
  type NewlineMode :: *
  data NewlineMode = NewlineMode {inputNL :: Newline, outputNL :: Newline}
  checkHandleInvariants :: Handle__ -> GHC.Types.IO ()
  isAppendHandleType :: HandleType -> GHC.Types.Bool
  isReadWriteHandleType :: HandleType -> GHC.Types.Bool
  isReadableHandleType :: HandleType -> GHC.Types.Bool
  isWritableHandleType :: HandleType -> GHC.Types.Bool
  nativeNewline :: Newline
  nativeNewlineMode :: NewlineMode
  noNewlineTranslation :: NewlineMode
  showHandle :: GHC.Internal.IO.FilePath -> GHC.Internal.Base.String -> GHC.Internal.Base.String
  universalNewlineMode :: NewlineMode

module GHC.IO.IOMode where
  -- Safety: Safe
  type IOMode :: *
  data IOMode = ReadMode | WriteMode | AppendMode | ReadWriteMode

module GHC.IO.StdHandles where
  -- Safety: Safe
  openBinaryFile :: GHC.Internal.IO.FilePath -> GHC.Internal.IO.IOMode.IOMode -> GHC.Types.IO GHC.Internal.IO.Handle.Types.Handle
  openFile :: GHC.Internal.IO.FilePath -> GHC.Internal.IO.IOMode.IOMode -> GHC.Types.IO GHC.Internal.IO.Handle.Types.Handle
  openFileBlocking :: GHC.Internal.IO.FilePath -> GHC.Internal.IO.IOMode.IOMode -> GHC.Types.IO GHC.Internal.IO.Handle.Types.Handle
  stderr :: GHC.Internal.IO.Handle.Types.Handle
  stdin :: GHC.Internal.IO.Handle.Types.Handle
  stdout :: GHC.Internal.IO.Handle.Types.Handle
  withBinaryFile :: forall r. GHC.Internal.IO.FilePath -> GHC.Internal.IO.IOMode.IOMode -> (GHC.Internal.IO.Handle.Types.Handle -> GHC.Types.IO r) -> GHC.Types.IO r
  withFile :: forall r. GHC.Internal.IO.FilePath -> GHC.Internal.IO.IOMode.IOMode -> (GHC.Internal.IO.Handle.Types.Handle -> GHC.Types.IO r) -> GHC.Types.IO r
  withFileBlocking :: forall r. GHC.Internal.IO.FilePath -> GHC.Internal.IO.IOMode.IOMode -> (GHC.Internal.IO.Handle.Types.Handle -> GHC.Types.IO r) -> GHC.Types.IO r

module GHC.IO.SubSystem where
  -- Safety: Safe
  (<!>) :: forall a. a -> a -> a
  type IoSubSystem :: *
  data IoSubSystem = IoPOSIX | IoNative
  conditional :: forall a. a -> a -> a
  ioSubSystem :: IoSubSystem
  isWindowsNativeIO :: GHC.Types.Bool
  whenIoSubSystem :: IoSubSystem -> GHC.Types.IO () -> GHC.Types.IO ()
  withIoSubSystem :: forall a. (IoSubSystem -> GHC.Types.IO a) -> GHC.Types.IO a
  withIoSubSystem' :: forall a. (IoSubSystem -> a) -> a

module GHC.IO.Unsafe where
  -- Safety: None
  noDuplicate :: GHC.Types.IO ()
  unsafeDupableInterleaveIO :: forall a. GHC.Types.IO a -> GHC.Types.IO a
  unsafeDupablePerformIO :: forall a. GHC.Types.IO a -> a
  unsafeInterleaveIO :: forall a. GHC.Types.IO a -> GHC.Types.IO a
  unsafePerformIO :: forall a. GHC.Types.IO a -> a

module GHC.IOArray where
  -- Safety: None
  type role IOArray nominal representational
  type IOArray :: * -> * -> *
  newtype IOArray i e = IOArray (GHC.Internal.Arr.STArray GHC.Prim.RealWorld i e)
  boundsIOArray :: forall i e. IOArray i e -> (i, i)
  newIOArray :: forall i e. GHC.Internal.Ix.Ix i => (i, i) -> e -> GHC.Types.IO (IOArray i e)
  readIOArray :: forall i e. GHC.Internal.Ix.Ix i => IOArray i e -> i -> GHC.Types.IO e
  unsafeReadIOArray :: forall i e. IOArray i e -> GHC.Types.Int -> GHC.Types.IO e
  unsafeWriteIOArray :: forall i e. IOArray i e -> GHC.Types.Int -> e -> GHC.Types.IO ()
  writeIOArray :: forall i e. GHC.Internal.Ix.Ix i => IOArray i e -> i -> e -> GHC.Types.IO ()

module GHC.IOPort where
  -- Safety: None
  type IOPort :: * -> *
  data IOPort a = IOPort (GHC.Prim.IOPort# GHC.Prim.RealWorld a)
  doubleReadException :: GHC.Internal.Exception.Type.SomeException
  newEmptyIOPort :: forall a. GHC.Types.IO (IOPort a)
  newIOPort :: forall a. a -> GHC.Types.IO (IOPort a)
  readIOPort :: forall a. IOPort a -> GHC.Types.IO a
  writeIOPort :: forall a. IOPort a -> a -> GHC.Types.IO GHC.Types.Bool

module GHC.IORef where
  -- Safety: None
  type IORef :: * -> *
  newtype IORef a = IORef (GHC.Internal.STRef.STRef GHC.Prim.RealWorld a)
  atomicModifyIORef' :: forall a b. IORef a -> (a -> (a, b)) -> GHC.Types.IO b
  atomicModifyIORef'_ :: forall a. IORef a -> (a -> a) -> GHC.Types.IO (a, a)
  atomicModifyIORef2 :: forall a b. IORef a -> (a -> (a, b)) -> GHC.Types.IO (a, (a, b))
  atomicModifyIORef2Lazy :: forall a b. IORef a -> (a -> (a, b)) -> GHC.Types.IO (a, (a, b))
  atomicModifyIORefLazy_ :: forall a. IORef a -> (a -> a) -> GHC.Types.IO (a, a)
  atomicModifyIORefP :: forall a b. IORef a -> (a -> (a, b)) -> GHC.Types.IO b
  atomicSwapIORef :: forall a. IORef a -> a -> GHC.Types.IO a
  newIORef :: forall a. a -> GHC.Types.IO (IORef a)
  readIORef :: forall a. IORef a -> GHC.Types.IO a
  writeIORef :: forall a. IORef a -> a -> GHC.Types.IO ()

module GHC.InfoProv where
  -- Safety: Safe
  type InfoProv :: *
  data InfoProv = InfoProv {ipName :: GHC.Internal.Base.String, ipDesc :: GHC.Internal.ClosureTypes.ClosureType, ipTyDesc :: GHC.Internal.Base.String, ipLabel :: GHC.Internal.Base.String, ipMod :: GHC.Internal.Base.String, ipSrcFile :: GHC.Internal.Base.String, ipSrcSpan :: GHC.Internal.Base.String}
  type InfoProvEnt :: *
  data InfoProvEnt
  ipLoc :: InfoProv -> GHC.Internal.Base.String
  ipeProv :: GHC.Internal.Ptr.Ptr InfoProvEnt -> GHC.Internal.Ptr.Ptr InfoProv
  peekInfoProv :: GHC.Internal.Ptr.Ptr InfoProv -> GHC.Types.IO InfoProv
  whereFrom :: forall a. a -> GHC.Types.IO (GHC.Internal.Maybe.Maybe InfoProv)

module GHC.Int where
  -- Safety: Safe
  type Int :: *
  data Int = I# GHC.Prim.Int#
  type Int16 :: *
  data Int16 = I16# GHC.Prim.Int16#
  type Int32 :: *
  data Int32 = I32# GHC.Prim.Int32#
  type Int64 :: *
  data Int64 = I64# GHC.Prim.Int64#
  type Int8 :: *
  data Int8 = I8# GHC.Prim.Int8#
  eqInt :: Int -> Int -> GHC.Types.Bool
  eqInt16 :: Int16 -> Int16 -> GHC.Types.Bool
  eqInt32 :: Int32 -> Int32 -> GHC.Types.Bool
  eqInt64 :: Int64 -> Int64 -> GHC.Types.Bool
  eqInt8 :: Int8 -> Int8 -> GHC.Types.Bool
  geInt :: Int -> Int -> GHC.Types.Bool
  geInt16 :: Int16 -> Int16 -> GHC.Types.Bool
  geInt32 :: Int32 -> Int32 -> GHC.Types.Bool
  geInt64 :: Int64 -> Int64 -> GHC.Types.Bool
  geInt8 :: Int8 -> Int8 -> GHC.Types.Bool
  gtInt :: Int -> Int -> GHC.Types.Bool
  gtInt16 :: Int16 -> Int16 -> GHC.Types.Bool
  gtInt32 :: Int32 -> Int32 -> GHC.Types.Bool
  gtInt64 :: Int64 -> Int64 -> GHC.Types.Bool
  gtInt8 :: Int8 -> Int8 -> GHC.Types.Bool
  leInt :: Int -> Int -> GHC.Types.Bool
  leInt16 :: Int16 -> Int16 -> GHC.Types.Bool
  leInt32 :: Int32 -> Int32 -> GHC.Types.Bool
  leInt64 :: Int64 -> Int64 -> GHC.Types.Bool
  leInt8 :: Int8 -> Int8 -> GHC.Types.Bool
  ltInt :: Int -> Int -> GHC.Types.Bool
  ltInt16 :: Int16 -> Int16 -> GHC.Types.Bool
  ltInt32 :: Int32 -> Int32 -> GHC.Types.Bool
  ltInt64 :: Int64 -> Int64 -> GHC.Types.Bool
  ltInt8 :: Int8 -> Int8 -> GHC.Types.Bool
  neInt :: Int -> Int -> GHC.Types.Bool
  neInt16 :: Int16 -> Int16 -> GHC.Types.Bool
  neInt32 :: Int32 -> Int32 -> GHC.Types.Bool
  neInt64 :: Int64 -> Int64 -> GHC.Types.Bool
  neInt8 :: Int8 -> Int8 -> GHC.Types.Bool
  shiftRLInt16# :: GHC.Prim.Int16# -> GHC.Prim.Int# -> GHC.Prim.Int16#
  shiftRLInt32# :: GHC.Prim.Int32# -> GHC.Prim.Int# -> GHC.Prim.Int32#
  shiftRLInt8# :: GHC.Prim.Int8# -> GHC.Prim.Int# -> GHC.Prim.Int8#
  uncheckedIShiftL64# :: GHC.Prim.Int64# -> GHC.Prim.Int# -> GHC.Prim.Int64#
  uncheckedIShiftRA64# :: GHC.Prim.Int64# -> GHC.Prim.Int# -> GHC.Prim.Int64#

module GHC.Integer where
  -- Safety: None
  type Integer :: *
  data Integer = ...
  absInteger :: Integer -> Integer
  andInteger :: Integer -> Integer -> Integer
  bitInteger :: GHC.Prim.Int# -> Integer
  compareInteger :: Integer -> Integer -> GHC.Types.Ordering
  complementInteger :: Integer -> Integer
  decodeDoubleInteger :: GHC.Prim.Double# -> (# Integer, GHC.Prim.Int# #)
  divInteger :: Integer -> Integer -> Integer
  divModInteger :: Integer -> Integer -> (# Integer, Integer #)
  encodeDoubleInteger :: Integer -> GHC.Prim.Int# -> GHC.Prim.Double#
  encodeFloatInteger :: Integer -> GHC.Prim.Int# -> GHC.Prim.Float#
  eqInteger :: Integer -> Integer -> GHC.Types.Bool
  eqInteger# :: Integer -> Integer -> GHC.Prim.Int#
  geInteger :: Integer -> Integer -> GHC.Types.Bool
  geInteger# :: Integer -> Integer -> GHC.Prim.Int#
  gtInteger :: Integer -> Integer -> GHC.Types.Bool
  gtInteger# :: Integer -> Integer -> GHC.Prim.Int#
  hashInteger :: Integer -> GHC.Prim.Int#
  integerToInt :: Integer -> GHC.Prim.Int#
  integerToWord :: Integer -> GHC.Prim.Word#
  leInteger :: Integer -> Integer -> GHC.Types.Bool
  leInteger# :: Integer -> Integer -> GHC.Prim.Int#
  ltInteger :: Integer -> Integer -> GHC.Types.Bool
  ltInteger# :: Integer -> Integer -> GHC.Prim.Int#
  minusInteger :: Integer -> Integer -> Integer
  modInteger :: Integer -> Integer -> Integer
  negateInteger :: Integer -> Integer
  neqInteger :: Integer -> Integer -> GHC.Types.Bool
  neqInteger# :: Integer -> Integer -> GHC.Prim.Int#
  orInteger :: Integer -> Integer -> Integer
  plusInteger :: Integer -> Integer -> Integer
  popCountInteger :: Integer -> GHC.Prim.Int#
  quotInteger :: Integer -> Integer -> Integer
  quotRemInteger :: Integer -> Integer -> (# Integer, Integer #)
  remInteger :: Integer -> Integer -> Integer
  shiftLInteger :: Integer -> GHC.Prim.Int# -> Integer
  shiftRInteger :: Integer -> GHC.Prim.Int# -> Integer
  signumInteger :: Integer -> Integer
  smallInteger :: GHC.Prim.Int# -> Integer
  testBitInteger :: Integer -> GHC.Prim.Int# -> GHC.Types.Bool
  timesInteger :: Integer -> Integer -> Integer
  wordToInteger :: GHC.Prim.Word# -> Integer
  xorInteger :: Integer -> Integer -> Integer

module GHC.Integer.Logarithms where
  -- Safety: None
  integerLog2# :: GHC.Num.Integer.Integer -> GHC.Prim.Int#
  integerLogBase# :: GHC.Num.Integer.Integer -> GHC.Num.Integer.Integer -> GHC.Prim.Int#
  wordLog2# :: GHC.Prim.Word# -> GHC.Prim.Int#

module GHC.IsList where
  -- Safety: Safe
  type IsList :: * -> Constraint
  class IsList l where
    type Item :: * -> *
    type family Item l
    fromList :: [Item l] -> l
    fromListN :: GHC.Types.Int -> [Item l] -> l
    toList :: l -> [Item l]
    {-# MINIMAL fromList, toList #-}

module GHC.Ix where
  -- Safety: None
  type Ix :: * -> Constraint
  class GHC.Classes.Ord a => Ix a where
    range :: (a, a) -> [a]
    index :: (a, a) -> a -> GHC.Types.Int
    unsafeIndex :: (a, a) -> a -> GHC.Types.Int
    inRange :: (a, a) -> a -> GHC.Types.Bool
    rangeSize :: (a, a) -> GHC.Types.Int
    unsafeRangeSize :: (a, a) -> GHC.Types.Int
    {-# MINIMAL range, (index | unsafeIndex), inRange #-}
  indexError :: forall a b. GHC.Internal.Show.Show a => (a, a) -> a -> GHC.Internal.Base.String -> b

module GHC.List where
  -- Safety: Safe
  (!!) :: forall a. GHC.Internal.Stack.Types.HasCallStack => [a] -> GHC.Types.Int -> a
  (!?) :: forall a. [a] -> GHC.Types.Int -> GHC.Internal.Maybe.Maybe a
  (++) :: forall a. [a] -> [a] -> [a]
  type List :: * -> *
  data List a = ...
  all :: forall a. (a -> GHC.Types.Bool) -> [a] -> GHC.Types.Bool
  and :: [GHC.Types.Bool] -> GHC.Types.Bool
  any :: forall a. (a -> GHC.Types.Bool) -> [a] -> GHC.Types.Bool
  augment :: forall a. (forall b. (a -> b -> b) -> b -> b) -> [a] -> [a]
  break :: forall a. (a -> GHC.Types.Bool) -> [a] -> ([a], [a])
  build :: forall a. (forall b. (a -> b -> b) -> b -> b) -> [a]
  concat :: forall a. [[a]] -> [a]
  concatMap :: forall a b. (a -> [b]) -> [a] -> [b]
  cycle :: forall a. GHC.Internal.Stack.Types.HasCallStack => [a] -> [a]
  drop :: forall a. GHC.Types.Int -> [a] -> [a]
  dropWhile :: forall a. (a -> GHC.Types.Bool) -> [a] -> [a]
  elem :: forall a. GHC.Classes.Eq a => a -> [a] -> GHC.Types.Bool
  errorEmptyList :: forall a. GHC.Internal.Stack.Types.HasCallStack => GHC.Internal.Base.String -> a
  filter :: forall a. (a -> GHC.Types.Bool) -> [a] -> [a]
  foldl :: forall a b. (b -> a -> b) -> b -> [a] -> b
  foldl' :: forall a b. (b -> a -> b) -> b -> [a] -> b
  foldl1 :: forall a. GHC.Internal.Stack.Types.HasCallStack => (a -> a -> a) -> [a] -> a
  foldl1' :: forall a. GHC.Internal.Stack.Types.HasCallStack => (a -> a -> a) -> [a] -> a
  foldr :: forall a b. (a -> b -> b) -> b -> [a] -> b
  foldr' :: forall a b. (a -> b -> b) -> b -> [a] -> b
  foldr1 :: forall a. GHC.Internal.Stack.Types.HasCallStack => (a -> a -> a) -> [a] -> a
  head :: forall a. GHC.Internal.Stack.Types.HasCallStack => [a] -> a
  init :: forall a. GHC.Internal.Stack.Types.HasCallStack => [a] -> [a]
  iterate :: forall a. (a -> a) -> a -> [a]
  iterate' :: forall a. (a -> a) -> a -> [a]
  last :: forall a. GHC.Internal.Stack.Types.HasCallStack => [a] -> a
  length :: forall a. [a] -> GHC.Types.Int
  lookup :: forall a b. GHC.Classes.Eq a => a -> [(a, b)] -> GHC.Internal.Maybe.Maybe b
  map :: forall a b. (a -> b) -> [a] -> [b]
  maximum :: forall a. (GHC.Classes.Ord a, GHC.Internal.Stack.Types.HasCallStack) => [a] -> a
  minimum :: forall a. (GHC.Classes.Ord a, GHC.Internal.Stack.Types.HasCallStack) => [a] -> a
  notElem :: forall a. GHC.Classes.Eq a => a -> [a] -> GHC.Types.Bool
  null :: forall a. [a] -> GHC.Types.Bool
  or :: [GHC.Types.Bool] -> GHC.Types.Bool
  product :: forall a. GHC.Internal.Num.Num a => [a] -> a
  repeat :: forall a. a -> [a]
  replicate :: forall a. GHC.Types.Int -> a -> [a]
  reverse :: forall a. [a] -> [a]
  scanl :: forall b a. (b -> a -> b) -> b -> [a] -> [b]
  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]
  span :: forall a. (a -> GHC.Types.Bool) -> [a] -> ([a], [a])
  splitAt :: forall a. GHC.Types.Int -> [a] -> ([a], [a])
  sum :: forall a. GHC.Internal.Num.Num a => [a] -> a
  tail :: forall a. GHC.Internal.Stack.Types.HasCallStack => [a] -> [a]
  take :: forall a. GHC.Types.Int -> [a] -> [a]
  takeWhile :: forall a. (a -> GHC.Types.Bool) -> [a] -> [a]
  uncons :: forall a. [a] -> GHC.Internal.Maybe.Maybe (a, [a])
  unsnoc :: forall a. [a] -> GHC.Internal.Maybe.Maybe ([a], a)
  unzip :: forall a b. [(a, b)] -> ([a], [b])
  unzip3 :: forall a b c. [(a, b, c)] -> ([a], [b], [c])
  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]

module GHC.MVar where
  -- Safety: None
  type MVar :: * -> *
  data MVar a = MVar (GHC.Prim.MVar# GHC.Prim.RealWorld a)
  addMVarFinalizer :: forall a. MVar a -> GHC.Types.IO () -> GHC.Types.IO ()
  isEmptyMVar :: forall a. MVar a -> GHC.Types.IO GHC.Types.Bool
  newEmptyMVar :: forall a. GHC.Types.IO (MVar a)
  newMVar :: forall a. a -> GHC.Types.IO (MVar a)
  putMVar :: forall a. MVar a -> a -> GHC.Types.IO ()
  readMVar :: forall a. MVar a -> GHC.Types.IO a
  takeMVar :: forall a. MVar a -> GHC.Types.IO a
  tryPutMVar :: forall a. MVar a -> a -> GHC.Types.IO GHC.Types.Bool
  tryReadMVar :: forall a. MVar a -> GHC.Types.IO (GHC.Internal.Maybe.Maybe a)
  tryTakeMVar :: forall a. MVar a -> GHC.Types.IO (GHC.Internal.Maybe.Maybe a)

module GHC.Maybe where
  -- Safety: None
  type Maybe :: * -> *
  data Maybe a = Nothing | Just a

module GHC.Natural where
  -- Safety: Safe
  type BigNat :: *
  data BigNat = BN# {unBigNat :: GHC.Num.BigNat.BigNat#}
  pattern NatJ# :: BigNat -> Natural
  pattern NatS# :: GHC.Prim.Word# -> Natural
  type Natural :: *
  data Natural = ...
  andNatural :: Natural -> Natural -> Natural
  bitNatural :: GHC.Prim.Int# -> Natural
  gcdNatural :: Natural -> Natural -> Natural
  isValidNatural :: Natural -> GHC.Types.Bool
  lcmNatural :: Natural -> Natural -> Natural
  minusNatural :: Natural -> Natural -> Natural
  minusNaturalMaybe :: Natural -> Natural -> GHC.Internal.Maybe.Maybe Natural
  mkNatural :: [GHC.Types.Word] -> Natural
  naturalFromInteger :: GHC.Num.Integer.Integer -> Natural
  naturalToInteger :: Natural -> GHC.Num.Integer.Integer
  naturalToWord :: Natural -> GHC.Types.Word
  naturalToWordMaybe :: Natural -> GHC.Internal.Maybe.Maybe GHC.Types.Word
  negateNatural :: Natural -> Natural
  orNatural :: Natural -> Natural -> Natural
  plusNatural :: Natural -> Natural -> Natural
  popCountNatural :: Natural -> GHC.Types.Int
  powModNatural :: Natural -> Natural -> Natural -> Natural
  quotNatural :: Natural -> Natural -> Natural
  quotRemNatural :: Natural -> Natural -> (Natural, Natural)
  remNatural :: Natural -> Natural -> Natural
  shiftLNatural :: Natural -> GHC.Types.Int -> Natural
  shiftRNatural :: Natural -> GHC.Types.Int -> Natural
  signumNatural :: Natural -> Natural
  testBitNatural :: Natural -> GHC.Types.Int -> GHC.Types.Bool
  timesNatural :: Natural -> Natural -> Natural
  wordToNatural :: GHC.Types.Word -> Natural
  wordToNatural# :: GHC.Types.Word -> Natural
  xorNatural :: Natural -> Natural -> Natural

module GHC.Num where
  -- Safety: None
  type Integer :: *
  data Integer = IS GHC.Prim.Int# | IP GHC.Prim.ByteArray# | IN GHC.Prim.ByteArray#
  type Natural :: *
  data Natural = NS GHC.Prim.Word# | NB GHC.Prim.ByteArray#
  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 | (-)) #-}
  integerAbs :: Integer -> Integer
  integerAdd :: Integer -> Integer -> Integer
  integerAnd :: Integer -> Integer -> Integer
  integerBit :: GHC.Types.Word -> Integer
  integerBit# :: GHC.Prim.Word# -> Integer
  integerCheck :: Integer -> GHC.Types.Bool
  integerCheck# :: Integer -> GHC.Num.Primitives.Bool#
  integerCompare :: Integer -> Integer -> GHC.Types.Ordering
  integerComplement :: Integer -> Integer
  integerDecodeDouble# :: GHC.Prim.Double# -> (# Integer, GHC.Prim.Int# #)
  integerDiv :: Integer -> Integer -> Integer
  integerDivMod :: Integer -> Integer -> (Integer, Integer)
  integerDivMod# :: Integer -> Integer -> (# Integer, Integer #)
  integerEncodeDouble :: Integer -> GHC.Types.Int -> GHC.Types.Double
  integerEncodeDouble# :: Integer -> GHC.Prim.Int# -> GHC.Prim.Double#
  integerEncodeFloat# :: Integer -> GHC.Prim.Int# -> GHC.Prim.Float#
  integerEq :: Integer -> Integer -> GHC.Types.Bool
  integerEq# :: Integer -> Integer -> GHC.Num.Primitives.Bool#
  integerFromAddr :: GHC.Prim.Word# -> GHC.Prim.Addr# -> GHC.Num.Primitives.Bool# -> GHC.Types.IO Integer
  integerFromAddr# :: forall s. GHC.Prim.Word# -> GHC.Prim.Addr# -> GHC.Num.Primitives.Bool# -> GHC.Prim.State# s -> (# GHC.Prim.State# s, Integer #)
  integerFromBigNat# :: GHC.Num.BigNat.BigNat# -> Integer
  integerFromBigNatNeg# :: GHC.Num.BigNat.BigNat# -> Integer
  integerFromBigNatSign# :: GHC.Prim.Int# -> GHC.Num.BigNat.BigNat# -> Integer
  integerFromByteArray :: GHC.Prim.Word# -> GHC.Prim.ByteArray# -> GHC.Prim.Word# -> GHC.Num.Primitives.Bool# -> Integer
  integerFromByteArray# :: forall s. GHC.Prim.Word# -> GHC.Prim.ByteArray# -> GHC.Prim.Word# -> GHC.Num.Primitives.Bool# -> GHC.Prim.State# s -> (# GHC.Prim.State# s, Integer #)
  integerFromInt :: GHC.Types.Int -> Integer
  integerFromInt# :: GHC.Prim.Int# -> Integer
  integerFromInt64# :: GHC.Prim.Int64# -> Integer
  integerFromNatural :: Natural -> Integer
  integerFromWord :: GHC.Types.Word -> Integer
  integerFromWord# :: GHC.Prim.Word# -> Integer
  integerFromWord64# :: GHC.Prim.Word64# -> Integer
  integerFromWordList :: GHC.Types.Bool -> [GHC.Types.Word] -> Integer
  integerFromWordNeg# :: GHC.Prim.Word# -> Integer
  integerFromWordSign# :: GHC.Prim.Int# -> GHC.Prim.Word# -> Integer
  integerGcd :: Integer -> Integer -> Integer
  integerGcde :: Integer -> Integer -> (Integer, Integer, Integer)
  integerGcde# :: Integer -> Integer -> (# Integer, Integer, Integer #)
  integerGe :: Integer -> Integer -> GHC.Types.Bool
  integerGe# :: Integer -> Integer -> GHC.Num.Primitives.Bool#
  integerGt :: Integer -> Integer -> GHC.Types.Bool
  integerGt# :: Integer -> Integer -> GHC.Num.Primitives.Bool#
  integerIsNegative :: Integer -> GHC.Types.Bool
  integerIsNegative# :: Integer -> GHC.Num.Primitives.Bool#
  integerIsOne :: Integer -> GHC.Types.Bool
  integerIsPowerOf2# :: Integer -> (# (# #) | GHC.Prim.Word# #)
  integerIsZero :: Integer -> GHC.Types.Bool
  integerLcm :: Integer -> Integer -> Integer
  integerLe :: Integer -> Integer -> GHC.Types.Bool
  integerLe# :: Integer -> Integer -> GHC.Num.Primitives.Bool#
  integerLog2 :: Integer -> GHC.Types.Word
  integerLog2# :: Integer -> GHC.Prim.Word#
  integerLogBase :: Integer -> Integer -> GHC.Types.Word
  integerLogBase# :: Integer -> Integer -> GHC.Prim.Word#
  integerLogBaseWord :: GHC.Types.Word -> Integer -> GHC.Types.Word
  integerLogBaseWord# :: GHC.Prim.Word# -> Integer -> GHC.Prim.Word#
  integerLt :: Integer -> Integer -> GHC.Types.Bool
  integerLt# :: Integer -> Integer -> GHC.Num.Primitives.Bool#
  integerMod :: Integer -> Integer -> Integer
  integerMul :: Integer -> Integer -> Integer
  integerNe :: Integer -> Integer -> GHC.Types.Bool
  integerNe# :: Integer -> Integer -> GHC.Num.Primitives.Bool#
  integerNegate :: Integer -> Integer
  integerOne :: Integer
  integerOr :: Integer -> Integer -> Integer
  integerPopCount# :: Integer -> GHC.Prim.Int#
  integerPowMod# :: Integer -> Integer -> Natural -> (# Natural | () #)
  integerQuot :: Integer -> Integer -> Integer
  integerQuotRem :: Integer -> Integer -> (Integer, Integer)
  integerQuotRem# :: Integer -> Integer -> (# Integer, Integer #)
  integerRecipMod# :: Integer -> Natural -> (# Natural | () #)
  integerRem :: Integer -> Integer -> Integer
  integerShiftL :: Integer -> GHC.Types.Word -> Integer
  integerShiftL# :: Integer -> GHC.Prim.Word# -> Integer
  integerShiftR :: Integer -> GHC.Types.Word -> Integer
  integerShiftR# :: Integer -> GHC.Prim.Word# -> Integer
  integerSignum :: Integer -> Integer
  integerSignum# :: Integer -> GHC.Prim.Int#
  integerSizeInBase# :: GHC.Prim.Word# -> Integer -> GHC.Prim.Word#
  integerSqr :: Integer -> Integer
  integerSub :: Integer -> Integer -> Integer
  integerTestBit :: Integer -> GHC.Types.Word -> GHC.Types.Bool
  integerTestBit# :: Integer -> GHC.Prim.Word# -> GHC.Num.Primitives.Bool#
  integerToAddr :: Integer -> GHC.Prim.Addr# -> GHC.Num.Primitives.Bool# -> GHC.Types.IO GHC.Types.Word
  integerToAddr# :: forall s. Integer -> GHC.Prim.Addr# -> GHC.Num.Primitives.Bool# -> GHC.Prim.State# s -> (# GHC.Prim.State# s, GHC.Prim.Word# #)
  integerToBigNatClamp# :: Integer -> GHC.Num.BigNat.BigNat#
  integerToBigNatSign# :: Integer -> (# GHC.Prim.Int#, GHC.Num.BigNat.BigNat# #)
  integerToInt :: Integer -> GHC.Types.Int
  integerToInt# :: Integer -> GHC.Prim.Int#
  integerToInt64# :: Integer -> GHC.Prim.Int64#
  integerToMutableByteArray :: Integer -> GHC.Prim.MutableByteArray# GHC.Prim.RealWorld -> GHC.Prim.Word# -> GHC.Num.Primitives.Bool# -> GHC.Types.IO GHC.Types.Word
  integerToMutableByteArray# :: forall s. Integer -> GHC.Prim.MutableByteArray# s -> GHC.Prim.Word# -> GHC.Num.Primitives.Bool# -> GHC.Prim.State# s -> (# GHC.Prim.State# s, GHC.Prim.Word# #)
  integerToNatural :: Integer -> Natural
  integerToNaturalClamp :: Integer -> Natural
  integerToNaturalThrow :: Integer -> Natural
  integerToWord :: Integer -> GHC.Types.Word
  integerToWord# :: Integer -> GHC.Prim.Word#
  integerToWord64# :: Integer -> GHC.Prim.Word64#
  integerXor :: Integer -> Integer -> Integer
  integerZero :: Integer
  naturalAdd :: Natural -> Natural -> Natural
  naturalAnd :: Natural -> Natural -> Natural
  naturalAndNot :: Natural -> Natural -> Natural
  naturalBit :: GHC.Types.Word -> Natural
  naturalBit# :: GHC.Prim.Word# -> Natural
  naturalCheck :: Natural -> GHC.Types.Bool
  naturalCheck# :: Natural -> GHC.Num.Primitives.Bool#
  naturalClearBit :: Natural -> GHC.Types.Word -> Natural
  naturalClearBit# :: Natural -> GHC.Prim.Word# -> Natural
  naturalCompare :: Natural -> Natural -> GHC.Types.Ordering
  naturalComplementBit :: Natural -> GHC.Types.Word -> Natural
  naturalComplementBit# :: Natural -> GHC.Prim.Word# -> Natural
  naturalEncodeDouble# :: Natural -> GHC.Prim.Int# -> GHC.Prim.Double#
  naturalEncodeFloat# :: Natural -> GHC.Prim.Int# -> GHC.Prim.Float#
  naturalEq :: Natural -> Natural -> GHC.Types.Bool
  naturalEq# :: Natural -> Natural -> GHC.Num.Primitives.Bool#
  naturalFromAddr :: GHC.Prim.Word# -> GHC.Prim.Addr# -> GHC.Num.Primitives.Bool# -> GHC.Types.IO Natural
  naturalFromAddr# :: forall s. GHC.Prim.Word# -> GHC.Prim.Addr# -> GHC.Num.Primitives.Bool# -> GHC.Prim.State# s -> (# GHC.Prim.State# s, Natural #)
  naturalFromBigNat# :: GHC.Num.BigNat.BigNat# -> Natural
  naturalFromByteArray# :: forall s. GHC.Prim.Word# -> GHC.Prim.ByteArray# -> GHC.Prim.Word# -> GHC.Num.Primitives.Bool# -> GHC.Prim.State# s -> (# GHC.Prim.State# s, Natural #)
  naturalFromWord :: GHC.Types.Word -> Natural
  naturalFromWord# :: GHC.Prim.Word# -> Natural
  naturalFromWord2# :: GHC.Prim.Word# -> GHC.Prim.Word# -> Natural
  naturalFromWordList :: [GHC.Types.Word] -> Natural
  naturalGcd :: Natural -> Natural -> Natural
  naturalGe :: Natural -> Natural -> GHC.Types.Bool
  naturalGe# :: Natural -> Natural -> GHC.Num.Primitives.Bool#
  naturalGt :: Natural -> Natural -> GHC.Types.Bool
  naturalGt# :: Natural -> Natural -> GHC.Num.Primitives.Bool#
  naturalIsOne :: Natural -> GHC.Types.Bool
  naturalIsPowerOf2# :: Natural -> (# (# #) | GHC.Prim.Word# #)
  naturalIsZero :: Natural -> GHC.Types.Bool
  naturalLcm :: Natural -> Natural -> Natural
  naturalLe :: Natural -> Natural -> GHC.Types.Bool
  naturalLe# :: Natural -> Natural -> GHC.Num.Primitives.Bool#
  naturalLog2 :: Natural -> GHC.Types.Word
  naturalLog2# :: Natural -> GHC.Prim.Word#
  naturalLogBase :: Natural -> Natural -> GHC.Types.Word
  naturalLogBase# :: Natural -> Natural -> GHC.Prim.Word#
  naturalLogBaseWord :: GHC.Types.Word -> Natural -> GHC.Types.Word
  naturalLogBaseWord# :: GHC.Prim.Word# -> Natural -> GHC.Prim.Word#
  naturalLt :: Natural -> Natural -> GHC.Types.Bool
  naturalLt# :: Natural -> Natural -> GHC.Num.Primitives.Bool#
  naturalMul :: Natural -> Natural -> Natural
  naturalNe :: Natural -> Natural -> GHC.Types.Bool
  naturalNe# :: Natural -> Natural -> GHC.Num.Primitives.Bool#
  naturalNegate :: Natural -> Natural
  naturalOne :: Natural
  naturalOr :: Natural -> Natural -> Natural
  naturalPopCount :: Natural -> GHC.Types.Word
  naturalPopCount# :: Natural -> GHC.Prim.Word#
  naturalPowMod :: Natural -> Natural -> Natural -> Natural
  naturalQuot :: Natural -> Natural -> Natural
  naturalQuotRem :: Natural -> Natural -> (Natural, Natural)
  naturalQuotRem# :: Natural -> Natural -> (# Natural, Natural #)
  naturalRem :: Natural -> Natural -> Natural
  naturalSetBit :: Natural -> GHC.Types.Word -> Natural
  naturalSetBit# :: Natural -> GHC.Prim.Word# -> Natural
  naturalShiftL :: Natural -> GHC.Types.Word -> Natural
  naturalShiftL# :: Natural -> GHC.Prim.Word# -> Natural
  naturalShiftR :: Natural -> GHC.Types.Word -> Natural
  naturalShiftR# :: Natural -> GHC.Prim.Word# -> Natural
  naturalSignum :: Natural -> Natural
  naturalSizeInBase# :: GHC.Prim.Word# -> Natural -> GHC.Prim.Word#
  naturalSqr :: Natural -> Natural
  naturalSub :: Natural -> Natural -> (# (# #) | Natural #)
  naturalSubThrow :: Natural -> Natural -> Natural
  naturalSubUnsafe :: Natural -> Natural -> Natural
  naturalTestBit :: Natural -> GHC.Types.Word -> GHC.Types.Bool
  naturalTestBit# :: Natural -> GHC.Prim.Word# -> GHC.Num.Primitives.Bool#
  naturalToAddr :: Natural -> GHC.Prim.Addr# -> GHC.Num.Primitives.Bool# -> GHC.Types.IO GHC.Types.Word
  naturalToAddr# :: forall s. Natural -> GHC.Prim.Addr# -> GHC.Num.Primitives.Bool# -> GHC.Prim.State# s -> (# GHC.Prim.State# s, GHC.Prim.Word# #)
  naturalToBigNat# :: Natural -> GHC.Num.BigNat.BigNat#
  naturalToMutableByteArray# :: forall s. Natural -> GHC.Prim.MutableByteArray# s -> GHC.Prim.Word# -> GHC.Num.Primitives.Bool# -> GHC.Prim.State# s -> (# GHC.Prim.State# s, GHC.Prim.Word# #)
  naturalToWord :: Natural -> GHC.Types.Word
  naturalToWord# :: Natural -> GHC.Prim.Word#
  naturalToWordClamp :: Natural -> GHC.Types.Word
  naturalToWordClamp# :: Natural -> GHC.Prim.Word#
  naturalToWordMaybe# :: Natural -> (# (# #) | GHC.Prim.Word# #)
  naturalXor :: Natural -> Natural -> Natural
  naturalZero :: Natural
  quotRemInteger :: Integer -> Integer -> (# Integer, Integer #)
  subtract :: forall a. Num a => a -> a -> a

module GHC.Num.BigNat where
  -- Safety: None
  type BigNat :: *
  data BigNat = BN# {unBigNat :: BigNat#}
  type BigNat# :: GHC.Types.UnliftedType
  type BigNat# = GHC.Num.WordArray.WordArray# :: GHC.Types.UnliftedType
  bigNatAdd :: BigNat# -> BigNat# -> BigNat#
  bigNatAddWord :: BigNat# -> GHC.Types.Word -> BigNat#
  bigNatAddWord# :: BigNat# -> GHC.Prim.Word# -> BigNat#
  bigNatAnd :: BigNat# -> BigNat# -> BigNat#
  bigNatAndInt# :: BigNat# -> GHC.Prim.Int# -> BigNat#
  bigNatAndNot :: BigNat# -> BigNat# -> BigNat#
  bigNatAndNotWord# :: BigNat# -> GHC.Prim.Word# -> BigNat#
  bigNatAndWord# :: BigNat# -> GHC.Prim.Word# -> BigNat#
  bigNatBit :: GHC.Types.Word -> BigNat#
  bigNatBit# :: GHC.Prim.Word# -> BigNat#
  bigNatCheck :: BigNat# -> GHC.Types.Bool
  bigNatCheck# :: BigNat# -> GHC.Num.Primitives.Bool#
  bigNatClearBit# :: BigNat# -> GHC.Prim.Word# -> BigNat#
  bigNatCompare :: BigNat# -> BigNat# -> GHC.Types.Ordering
  bigNatCompareWord :: BigNat# -> GHC.Types.Word -> GHC.Types.Ordering
  bigNatCompareWord# :: BigNat# -> GHC.Prim.Word# -> GHC.Types.Ordering
  bigNatComplementBit# :: BigNat# -> GHC.Prim.Word# -> BigNat#
  bigNatCtz :: BigNat# -> GHC.Types.Word
  bigNatCtz# :: BigNat# -> GHC.Prim.Word#
  bigNatCtzWord :: BigNat# -> GHC.Types.Word
  bigNatCtzWord# :: BigNat# -> GHC.Prim.Word#
  bigNatEncodeDouble# :: BigNat# -> GHC.Prim.Int# -> GHC.Prim.Double#
  bigNatEq :: BigNat# -> BigNat# -> GHC.Types.Bool
  bigNatEq# :: BigNat# -> BigNat# -> GHC.Num.Primitives.Bool#
  bigNatEqWord# :: BigNat# -> GHC.Prim.Word# -> GHC.Num.Primitives.Bool#
  bigNatFromAbsInt# :: GHC.Prim.Int# -> BigNat#
  bigNatFromAddr# :: forall s. GHC.Prim.Word# -> GHC.Prim.Addr# -> GHC.Num.Primitives.Bool# -> GHC.Prim.State# s -> (# GHC.Prim.State# s, BigNat# #)
  bigNatFromAddrBE# :: forall s. GHC.Prim.Word# -> GHC.Prim.Addr# -> GHC.Prim.State# s -> (# GHC.Prim.State# s, BigNat# #)
  bigNatFromAddrLE# :: forall s. GHC.Prim.Word# -> GHC.Prim.Addr# -> GHC.Prim.State# s -> (# GHC.Prim.State# s, BigNat# #)
  bigNatFromByteArray# :: forall s. GHC.Prim.Word# -> GHC.Prim.ByteArray# -> GHC.Prim.Word# -> GHC.Num.Primitives.Bool# -> GHC.Prim.State# s -> (# GHC.Prim.State# s, BigNat# #)
  bigNatFromByteArrayBE# :: forall s. GHC.Prim.Word# -> GHC.Prim.ByteArray# -> GHC.Prim.Word# -> GHC.Prim.State# s -> (# GHC.Prim.State# s, BigNat# #)
  bigNatFromByteArrayLE# :: forall s. GHC.Prim.Word# -> GHC.Prim.ByteArray# -> GHC.Prim.Word# -> GHC.Prim.State# s -> (# GHC.Prim.State# s, BigNat# #)
  bigNatFromWord :: GHC.Types.Word -> BigNat#
  bigNatFromWord# :: GHC.Prim.Word# -> BigNat#
  bigNatFromWord2# :: GHC.Prim.Word# -> GHC.Prim.Word# -> BigNat#
  bigNatFromWord64# :: GHC.Prim.Word64# -> BigNat#
  bigNatFromWordArray :: GHC.Num.WordArray.WordArray# -> GHC.Prim.Word# -> BigNat
  bigNatFromWordArray# :: GHC.Num.WordArray.WordArray# -> GHC.Prim.Word# -> BigNat#
  bigNatFromWordList :: [GHC.Types.Word] -> BigNat#
  bigNatFromWordList# :: [GHC.Types.Word] -> GHC.Num.WordArray.WordArray#
  bigNatFromWordListUnsafe :: [GHC.Types.Word] -> BigNat#
  bigNatGcd :: BigNat# -> BigNat# -> BigNat#
  bigNatGcdWord# :: BigNat# -> GHC.Prim.Word# -> GHC.Prim.Word#
  bigNatGe :: BigNat# -> BigNat# -> GHC.Types.Bool
  bigNatGe# :: BigNat# -> BigNat# -> GHC.Num.Primitives.Bool#
  bigNatGt :: BigNat# -> BigNat# -> GHC.Types.Bool
  bigNatGt# :: BigNat# -> BigNat# -> GHC.Num.Primitives.Bool#
  bigNatGtWord :: BigNat# -> GHC.Types.Word -> GHC.Types.Bool
  bigNatGtWord# :: BigNat# -> GHC.Prim.Word# -> GHC.Num.Primitives.Bool#
  bigNatIndex :: BigNat# -> GHC.Prim.Int# -> GHC.Types.Word
  bigNatIndex# :: BigNat# -> GHC.Prim.Int# -> GHC.Prim.Word#
  bigNatIsOne :: BigNat# -> GHC.Types.Bool
  bigNatIsOne# :: BigNat# -> GHC.Num.Primitives.Bool#
  bigNatIsPowerOf2# :: BigNat# -> (# (# #) | GHC.Prim.Word# #)
  bigNatIsTwo :: BigNat# -> GHC.Types.Bool
  bigNatIsTwo# :: BigNat# -> GHC.Num.Primitives.Bool#
  bigNatIsZero :: BigNat# -> GHC.Types.Bool
  bigNatIsZero# :: BigNat# -> GHC.Num.Primitives.Bool#
  bigNatLcm :: BigNat# -> BigNat# -> BigNat#
  bigNatLcmWord# :: BigNat# -> GHC.Prim.Word# -> BigNat#
  bigNatLcmWordWord# :: GHC.Prim.Word# -> GHC.Prim.Word# -> BigNat#
  bigNatLe :: BigNat# -> BigNat# -> GHC.Types.Bool
  bigNatLe# :: BigNat# -> BigNat# -> GHC.Num.Primitives.Bool#
  bigNatLeWord :: BigNat# -> GHC.Types.Word -> GHC.Types.Bool
  bigNatLeWord# :: BigNat# -> GHC.Prim.Word# -> GHC.Num.Primitives.Bool#
  bigNatLog2 :: BigNat# -> GHC.Types.Word
  bigNatLog2# :: BigNat# -> GHC.Prim.Word#
  bigNatLogBase :: BigNat# -> BigNat# -> GHC.Types.Word
  bigNatLogBase# :: BigNat# -> BigNat# -> GHC.Prim.Word#
  bigNatLogBaseWord :: GHC.Types.Word -> BigNat# -> GHC.Types.Word
  bigNatLogBaseWord# :: GHC.Prim.Word# -> BigNat# -> GHC.Prim.Word#
  bigNatLt :: BigNat# -> BigNat# -> GHC.Types.Bool
  bigNatLt# :: BigNat# -> BigNat# -> GHC.Num.Primitives.Bool#
  bigNatMul :: BigNat# -> BigNat# -> BigNat#
  bigNatMulWord :: BigNat# -> GHC.Types.Word -> BigNat#
  bigNatMulWord# :: BigNat# -> GHC.Prim.Word# -> BigNat#
  bigNatNe :: BigNat# -> BigNat# -> GHC.Types.Bool
  bigNatNe# :: BigNat# -> BigNat# -> GHC.Num.Primitives.Bool#
  bigNatOne :: BigNat
  bigNatOne# :: (# #) -> BigNat#
  bigNatOr :: BigNat# -> BigNat# -> BigNat#
  bigNatOrWord# :: BigNat# -> GHC.Prim.Word# -> BigNat#
  bigNatPopCount :: BigNat# -> GHC.Types.Word
  bigNatPopCount# :: BigNat# -> GHC.Prim.Word#
  bigNatPowMod :: BigNat# -> BigNat# -> BigNat# -> BigNat#
  bigNatPowModWord# :: BigNat# -> BigNat# -> GHC.Prim.Word# -> GHC.Prim.Word#
  bigNatQuot :: BigNat# -> BigNat# -> BigNat#
  bigNatQuotRem# :: BigNat# -> BigNat# -> (# BigNat#, BigNat# #)
  bigNatQuotRemWord# :: BigNat# -> GHC.Prim.Word# -> (# BigNat#, GHC.Prim.Word# #)
  bigNatQuotWord :: BigNat# -> GHC.Types.Word -> BigNat#
  bigNatQuotWord# :: BigNat# -> GHC.Prim.Word# -> BigNat#
  bigNatRem :: BigNat# -> BigNat# -> BigNat#
  bigNatRemWord :: BigNat# -> GHC.Types.Word -> GHC.Types.Word
  bigNatRemWord# :: BigNat# -> GHC.Prim.Word# -> GHC.Prim.Word#
  bigNatSetBit# :: BigNat# -> GHC.Prim.Word# -> BigNat#
  bigNatShiftL :: BigNat# -> GHC.Types.Word -> BigNat#
  bigNatShiftL# :: BigNat# -> GHC.Prim.Word# -> BigNat#
  bigNatShiftR :: BigNat# -> GHC.Types.Word -> BigNat#
  bigNatShiftR# :: BigNat# -> GHC.Prim.Word# -> BigNat#
  bigNatShiftRNeg# :: BigNat# -> GHC.Prim.Word# -> BigNat#
  bigNatSize :: BigNat# -> GHC.Types.Word
  bigNatSize# :: BigNat# -> GHC.Prim.Int#
  bigNatSizeInBase :: GHC.Types.Word -> BigNat# -> GHC.Types.Word
  bigNatSizeInBase# :: GHC.Prim.Word# -> BigNat# -> GHC.Prim.Word#
  bigNatSqr :: BigNat# -> BigNat#
  bigNatSub :: BigNat# -> BigNat# -> (# (# #) | BigNat# #)
  bigNatSubUnsafe :: BigNat# -> BigNat# -> BigNat#
  bigNatSubWord# :: BigNat# -> GHC.Prim.Word# -> (# (# #) | BigNat# #)
  bigNatSubWordUnsafe :: BigNat# -> GHC.Types.Word -> BigNat#
  bigNatSubWordUnsafe# :: BigNat# -> GHC.Prim.Word# -> BigNat#
  bigNatTestBit :: BigNat# -> GHC.Types.Word -> GHC.Types.Bool
  bigNatTestBit# :: BigNat# -> GHC.Prim.Word# -> GHC.Num.Primitives.Bool#
  bigNatToAddr :: BigNat# -> GHC.Prim.Addr# -> GHC.Num.Primitives.Bool# -> GHC.Types.IO GHC.Types.Word
  bigNatToAddr# :: forall s. BigNat# -> GHC.Prim.Addr# -> GHC.Num.Primitives.Bool# -> GHC.Prim.State# s -> (# GHC.Prim.State# s, GHC.Prim.Word# #)
  bigNatToAddrBE# :: forall s. BigNat# -> GHC.Prim.Addr# -> GHC.Prim.State# s -> (# GHC.Prim.State# s, GHC.Prim.Word# #)
  bigNatToAddrLE# :: forall s. BigNat# -> GHC.Prim.Addr# -> GHC.Prim.State# s -> (# GHC.Prim.State# s, GHC.Prim.Word# #)
  bigNatToInt :: BigNat# -> GHC.Types.Int
  bigNatToInt# :: BigNat# -> GHC.Prim.Int#
  bigNatToMutableByteArray# :: forall s. BigNat# -> GHC.Prim.MutableByteArray# s -> GHC.Prim.Word# -> GHC.Num.Primitives.Bool# -> GHC.Prim.State# s -> (# GHC.Prim.State# s, GHC.Prim.Word# #)
  bigNatToMutableByteArrayBE# :: forall s. BigNat# -> GHC.Prim.MutableByteArray# s -> GHC.Prim.Word# -> GHC.Prim.State# s -> (# GHC.Prim.State# s, GHC.Prim.Word# #)
  bigNatToMutableByteArrayLE# :: forall s. BigNat# -> GHC.Prim.MutableByteArray# s -> GHC.Prim.Word# -> GHC.Prim.State# s -> (# GHC.Prim.State# s, GHC.Prim.Word# #)
  bigNatToWord :: BigNat# -> GHC.Types.Word
  bigNatToWord# :: BigNat# -> GHC.Prim.Word#
  bigNatToWord64# :: BigNat# -> GHC.Prim.Word64#
  bigNatToWordList :: BigNat# -> [GHC.Types.Word]
  bigNatToWordMaybe# :: BigNat# -> (# (# #) | GHC.Prim.Word# #)
  bigNatXor :: BigNat# -> BigNat# -> BigNat#
  bigNatXorWord# :: BigNat# -> GHC.Prim.Word# -> BigNat#
  bigNatZero :: BigNat
  bigNatZero# :: (# #) -> BigNat#
  gcdInt :: GHC.Types.Int -> GHC.Types.Int -> GHC.Types.Int
  gcdInt# :: GHC.Prim.Int# -> GHC.Prim.Int# -> GHC.Prim.Int#
  gcdWord :: GHC.Types.Word -> GHC.Types.Word -> GHC.Types.Word
  gcdWord# :: GHC.Prim.Word# -> GHC.Prim.Word# -> GHC.Prim.Word#
  powModWord# :: GHC.Prim.Word# -> GHC.Prim.Word# -> GHC.Prim.Word# -> GHC.Prim.Word#
  raiseDivZero_BigNat :: (# #) -> BigNat#

module GHC.Num.Integer where
  -- Safety: None
  type Integer :: *
  data Integer = IS GHC.Prim.Int# | IP GHC.Prim.ByteArray# | IN GHC.Prim.ByteArray#
  integerAbs :: Integer -> Integer
  integerAdd :: Integer -> Integer -> Integer
  integerAnd :: Integer -> Integer -> Integer
  integerBit :: GHC.Types.Word -> Integer
  integerBit# :: GHC.Prim.Word# -> Integer
  integerCheck :: Integer -> GHC.Types.Bool
  integerCheck# :: Integer -> GHC.Num.Primitives.Bool#
  integerCompare :: Integer -> Integer -> GHC.Types.Ordering
  integerComplement :: Integer -> Integer
  integerDecodeDouble# :: GHC.Prim.Double# -> (# Integer, GHC.Prim.Int# #)
  integerDiv :: Integer -> Integer -> Integer
  integerDivMod :: Integer -> Integer -> (Integer, Integer)
  integerDivMod# :: Integer -> Integer -> (# Integer, Integer #)
  integerEncodeDouble :: Integer -> GHC.Types.Int -> GHC.Types.Double
  integerEncodeDouble# :: Integer -> GHC.Prim.Int# -> GHC.Prim.Double#
  integerEncodeFloat# :: Integer -> GHC.Prim.Int# -> GHC.Prim.Float#
  integerEq :: Integer -> Integer -> GHC.Types.Bool
  integerEq# :: Integer -> Integer -> GHC.Num.Primitives.Bool#
  integerFromAddr :: GHC.Prim.Word# -> GHC.Prim.Addr# -> GHC.Num.Primitives.Bool# -> GHC.Types.IO Integer
  integerFromAddr# :: forall s. GHC.Prim.Word# -> GHC.Prim.Addr# -> GHC.Num.Primitives.Bool# -> GHC.Prim.State# s -> (# GHC.Prim.State# s, Integer #)
  integerFromBigNat# :: GHC.Num.BigNat.BigNat# -> Integer
  integerFromBigNatNeg# :: GHC.Num.BigNat.BigNat# -> Integer
  integerFromBigNatSign# :: GHC.Prim.Int# -> GHC.Num.BigNat.BigNat# -> Integer
  integerFromByteArray :: GHC.Prim.Word# -> GHC.Prim.ByteArray# -> GHC.Prim.Word# -> GHC.Num.Primitives.Bool# -> Integer
  integerFromByteArray# :: forall s. GHC.Prim.Word# -> GHC.Prim.ByteArray# -> GHC.Prim.Word# -> GHC.Num.Primitives.Bool# -> GHC.Prim.State# s -> (# GHC.Prim.State# s, Integer #)
  integerFromInt :: GHC.Types.Int -> Integer
  integerFromInt# :: GHC.Prim.Int# -> Integer
  integerFromInt64# :: GHC.Prim.Int64# -> Integer
  integerFromNatural :: GHC.Num.Natural.Natural -> Integer
  integerFromWord :: GHC.Types.Word -> Integer
  integerFromWord# :: GHC.Prim.Word# -> Integer
  integerFromWord64# :: GHC.Prim.Word64# -> Integer
  integerFromWordList :: GHC.Types.Bool -> [GHC.Types.Word] -> Integer
  integerFromWordNeg# :: GHC.Prim.Word# -> Integer
  integerFromWordSign# :: GHC.Prim.Int# -> GHC.Prim.Word# -> Integer
  integerGcd :: Integer -> Integer -> Integer
  integerGcde :: Integer -> Integer -> (Integer, Integer, Integer)
  integerGcde# :: Integer -> Integer -> (# Integer, Integer, Integer #)
  integerGe :: Integer -> Integer -> GHC.Types.Bool
  integerGe# :: Integer -> Integer -> GHC.Num.Primitives.Bool#
  integerGt :: Integer -> Integer -> GHC.Types.Bool
  integerGt# :: Integer -> Integer -> GHC.Num.Primitives.Bool#
  integerIsNegative :: Integer -> GHC.Types.Bool
  integerIsNegative# :: Integer -> GHC.Num.Primitives.Bool#
  integerIsOne :: Integer -> GHC.Types.Bool
  integerIsPowerOf2# :: Integer -> (# (# #) | GHC.Prim.Word# #)
  integerIsZero :: Integer -> GHC.Types.Bool
  integerLcm :: Integer -> Integer -> Integer
  integerLe :: Integer -> Integer -> GHC.Types.Bool
  integerLe# :: Integer -> Integer -> GHC.Num.Primitives.Bool#
  integerLog2 :: Integer -> GHC.Types.Word
  integerLog2# :: Integer -> GHC.Prim.Word#
  integerLogBase :: Integer -> Integer -> GHC.Types.Word
  integerLogBase# :: Integer -> Integer -> GHC.Prim.Word#
  integerLogBaseWord :: GHC.Types.Word -> Integer -> GHC.Types.Word
  integerLogBaseWord# :: GHC.Prim.Word# -> Integer -> GHC.Prim.Word#
  integerLt :: Integer -> Integer -> GHC.Types.Bool
  integerLt# :: Integer -> Integer -> GHC.Num.Primitives.Bool#
  integerMod :: Integer -> Integer -> Integer
  integerMul :: Integer -> Integer -> Integer
  integerNe :: Integer -> Integer -> GHC.Types.Bool
  integerNe# :: Integer -> Integer -> GHC.Num.Primitives.Bool#
  integerNegate :: Integer -> Integer
  integerOne :: Integer
  integerOr :: Integer -> Integer -> Integer
  integerPopCount# :: Integer -> GHC.Prim.Int#
  integerPowMod# :: Integer -> Integer -> GHC.Num.Natural.Natural -> (# GHC.Num.Natural.Natural | () #)
  integerQuot :: Integer -> Integer -> Integer
  integerQuotRem :: Integer -> Integer -> (Integer, Integer)
  integerQuotRem# :: Integer -> Integer -> (# Integer, Integer #)
  integerRecipMod# :: Integer -> GHC.Num.Natural.Natural -> (# GHC.Num.Natural.Natural | () #)
  integerRem :: Integer -> Integer -> Integer
  integerShiftL :: Integer -> GHC.Types.Word -> Integer
  integerShiftL# :: Integer -> GHC.Prim.Word# -> Integer
  integerShiftR :: Integer -> GHC.Types.Word -> Integer
  integerShiftR# :: Integer -> GHC.Prim.Word# -> Integer
  integerSignum :: Integer -> Integer
  integerSignum# :: Integer -> GHC.Prim.Int#
  integerSizeInBase# :: GHC.Prim.Word# -> Integer -> GHC.Prim.Word#
  integerSqr :: Integer -> Integer
  integerSub :: Integer -> Integer -> Integer
  integerTestBit :: Integer -> GHC.Types.Word -> GHC.Types.Bool
  integerTestBit# :: Integer -> GHC.Prim.Word# -> GHC.Num.Primitives.Bool#
  integerToAddr :: Integer -> GHC.Prim.Addr# -> GHC.Num.Primitives.Bool# -> GHC.Types.IO GHC.Types.Word
  integerToAddr# :: forall s. Integer -> GHC.Prim.Addr# -> GHC.Num.Primitives.Bool# -> GHC.Prim.State# s -> (# GHC.Prim.State# s, GHC.Prim.Word# #)
  integerToBigNatClamp# :: Integer -> GHC.Num.BigNat.BigNat#
  integerToBigNatSign# :: Integer -> (# GHC.Prim.Int#, GHC.Num.BigNat.BigNat# #)
  integerToInt :: Integer -> GHC.Types.Int
  integerToInt# :: Integer -> GHC.Prim.Int#
  integerToInt64# :: Integer -> GHC.Prim.Int64#
  integerToMutableByteArray :: Integer -> GHC.Prim.MutableByteArray# GHC.Prim.RealWorld -> GHC.Prim.Word# -> GHC.Num.Primitives.Bool# -> GHC.Types.IO GHC.Types.Word
  integerToMutableByteArray# :: forall s. Integer -> GHC.Prim.MutableByteArray# s -> GHC.Prim.Word# -> GHC.Num.Primitives.Bool# -> GHC.Prim.State# s -> (# GHC.Prim.State# s, GHC.Prim.Word# #)
  integerToNatural :: Integer -> GHC.Num.Natural.Natural
  integerToNaturalClamp :: Integer -> GHC.Num.Natural.Natural
  integerToNaturalThrow :: Integer -> GHC.Num.Natural.Natural
  integerToWord :: Integer -> GHC.Types.Word
  integerToWord# :: Integer -> GHC.Prim.Word#
  integerToWord64# :: Integer -> GHC.Prim.Word64#
  integerXor :: Integer -> Integer -> Integer
  integerZero :: Integer

module GHC.Num.Natural where
  -- Safety: None
  type Natural :: *
  data Natural = NS GHC.Prim.Word# | NB GHC.Prim.ByteArray#
  naturalAdd :: Natural -> Natural -> Natural
  naturalAnd :: Natural -> Natural -> Natural
  naturalAndNot :: Natural -> Natural -> Natural
  naturalBit :: GHC.Types.Word -> Natural
  naturalBit# :: GHC.Prim.Word# -> Natural
  naturalCheck :: Natural -> GHC.Types.Bool
  naturalCheck# :: Natural -> GHC.Num.Primitives.Bool#
  naturalClearBit :: Natural -> GHC.Types.Word -> Natural
  naturalClearBit# :: Natural -> GHC.Prim.Word# -> Natural
  naturalCompare :: Natural -> Natural -> GHC.Types.Ordering
  naturalComplementBit :: Natural -> GHC.Types.Word -> Natural
  naturalComplementBit# :: Natural -> GHC.Prim.Word# -> Natural
  naturalEncodeDouble# :: Natural -> GHC.Prim.Int# -> GHC.Prim.Double#
  naturalEncodeFloat# :: Natural -> GHC.Prim.Int# -> GHC.Prim.Float#
  naturalEq :: Natural -> Natural -> GHC.Types.Bool
  naturalEq# :: Natural -> Natural -> GHC.Num.Primitives.Bool#
  naturalFromAddr :: GHC.Prim.Word# -> GHC.Prim.Addr# -> GHC.Num.Primitives.Bool# -> GHC.Types.IO Natural
  naturalFromAddr# :: forall s. GHC.Prim.Word# -> GHC.Prim.Addr# -> GHC.Num.Primitives.Bool# -> GHC.Prim.State# s -> (# GHC.Prim.State# s, Natural #)
  naturalFromBigNat# :: GHC.Num.BigNat.BigNat# -> Natural
  naturalFromByteArray# :: forall s. GHC.Prim.Word# -> GHC.Prim.ByteArray# -> GHC.Prim.Word# -> GHC.Num.Primitives.Bool# -> GHC.Prim.State# s -> (# GHC.Prim.State# s, Natural #)
  naturalFromWord :: GHC.Types.Word -> Natural
  naturalFromWord# :: GHC.Prim.Word# -> Natural
  naturalFromWord2# :: GHC.Prim.Word# -> GHC.Prim.Word# -> Natural
  naturalFromWordList :: [GHC.Types.Word] -> Natural
  naturalGcd :: Natural -> Natural -> Natural
  naturalGe :: Natural -> Natural -> GHC.Types.Bool
  naturalGe# :: Natural -> Natural -> GHC.Num.Primitives.Bool#
  naturalGt :: Natural -> Natural -> GHC.Types.Bool
  naturalGt# :: Natural -> Natural -> GHC.Num.Primitives.Bool#
  naturalIsOne :: Natural -> GHC.Types.Bool
  naturalIsPowerOf2# :: Natural -> (# (# #) | GHC.Prim.Word# #)
  naturalIsZero :: Natural -> GHC.Types.Bool
  naturalLcm :: Natural -> Natural -> Natural
  naturalLe :: Natural -> Natural -> GHC.Types.Bool
  naturalLe# :: Natural -> Natural -> GHC.Num.Primitives.Bool#
  naturalLog2 :: Natural -> GHC.Types.Word
  naturalLog2# :: Natural -> GHC.Prim.Word#
  naturalLogBase :: Natural -> Natural -> GHC.Types.Word
  naturalLogBase# :: Natural -> Natural -> GHC.Prim.Word#
  naturalLogBaseWord :: GHC.Types.Word -> Natural -> GHC.Types.Word
  naturalLogBaseWord# :: GHC.Prim.Word# -> Natural -> GHC.Prim.Word#
  naturalLt :: Natural -> Natural -> GHC.Types.Bool
  naturalLt# :: Natural -> Natural -> GHC.Num.Primitives.Bool#
  naturalMul :: Natural -> Natural -> Natural
  naturalNe :: Natural -> Natural -> GHC.Types.Bool
  naturalNe# :: Natural -> Natural -> GHC.Num.Primitives.Bool#
  naturalNegate :: Natural -> Natural
  naturalOne :: Natural
  naturalOr :: Natural -> Natural -> Natural
  naturalPopCount :: Natural -> GHC.Types.Word
  naturalPopCount# :: Natural -> GHC.Prim.Word#
  naturalPowMod :: Natural -> Natural -> Natural -> Natural
  naturalQuot :: Natural -> Natural -> Natural
  naturalQuotRem :: Natural -> Natural -> (Natural, Natural)
  naturalQuotRem# :: Natural -> Natural -> (# Natural, Natural #)
  naturalRem :: Natural -> Natural -> Natural
  naturalSetBit :: Natural -> GHC.Types.Word -> Natural
  naturalSetBit# :: Natural -> GHC.Prim.Word# -> Natural
  naturalShiftL :: Natural -> GHC.Types.Word -> Natural
  naturalShiftL# :: Natural -> GHC.Prim.Word# -> Natural
  naturalShiftR :: Natural -> GHC.Types.Word -> Natural
  naturalShiftR# :: Natural -> GHC.Prim.Word# -> Natural
  naturalSignum :: Natural -> Natural
  naturalSizeInBase# :: GHC.Prim.Word# -> Natural -> GHC.Prim.Word#
  naturalSqr :: Natural -> Natural
  naturalSub :: Natural -> Natural -> (# (# #) | Natural #)
  naturalSubThrow :: Natural -> Natural -> Natural
  naturalSubUnsafe :: Natural -> Natural -> Natural
  naturalTestBit :: Natural -> GHC.Types.Word -> GHC.Types.Bool
  naturalTestBit# :: Natural -> GHC.Prim.Word# -> GHC.Num.Primitives.Bool#
  naturalToAddr :: Natural -> GHC.Prim.Addr# -> GHC.Num.Primitives.Bool# -> GHC.Types.IO GHC.Types.Word
  naturalToAddr# :: forall s. Natural -> GHC.Prim.Addr# -> GHC.Num.Primitives.Bool# -> GHC.Prim.State# s -> (# GHC.Prim.State# s, GHC.Prim.Word# #)
  naturalToBigNat# :: Natural -> GHC.Num.BigNat.BigNat#
  naturalToMutableByteArray# :: forall s. Natural -> GHC.Prim.MutableByteArray# s -> GHC.Prim.Word# -> GHC.Num.Primitives.Bool# -> GHC.Prim.State# s -> (# GHC.Prim.State# s, GHC.Prim.Word# #)
  naturalToWord :: Natural -> GHC.Types.Word
  naturalToWord# :: Natural -> GHC.Prim.Word#
  naturalToWordClamp :: Natural -> GHC.Types.Word
  naturalToWordClamp# :: Natural -> GHC.Prim.Word#
  naturalToWordMaybe# :: Natural -> (# (# #) | GHC.Prim.Word# #)
  naturalXor :: Natural -> Natural -> Natural
  naturalZero :: Natural

module GHC.OldList where
  -- Safety: Safe
  (!!) :: forall a. GHC.Internal.Stack.Types.HasCallStack => [a] -> GHC.Types.Int -> a
  (!?) :: forall a. [a] -> GHC.Types.Int -> GHC.Internal.Maybe.Maybe a
  (++) :: forall a. [a] -> [a] -> [a]
  (\\) :: forall a. GHC.Classes.Eq a => [a] -> [a] -> [a]
  all :: forall a. (a -> GHC.Types.Bool) -> [a] -> GHC.Types.Bool
  and :: [GHC.Types.Bool] -> GHC.Types.Bool
  any :: forall a. (a -> GHC.Types.Bool) -> [a] -> GHC.Types.Bool
  break :: forall a. (a -> GHC.Types.Bool) -> [a] -> ([a], [a])
  concat :: forall a. [[a]] -> [a]
  concatMap :: forall a b. (a -> [b]) -> [a] -> [b]
  cycle :: forall a. GHC.Internal.Stack.Types.HasCallStack => [a] -> [a]
  delete :: forall a. GHC.Classes.Eq a => a -> [a] -> [a]
  deleteBy :: forall a. (a -> a -> GHC.Types.Bool) -> a -> [a] -> [a]
  deleteFirstsBy :: forall a. (a -> a -> GHC.Types.Bool) -> [a] -> [a] -> [a]
  drop :: forall a. GHC.Types.Int -> [a] -> [a]
  dropWhile :: forall a. (a -> GHC.Types.Bool) -> [a] -> [a]
  dropWhileEnd :: forall a. (a -> GHC.Types.Bool) -> [a] -> [a]
  elem :: forall a. GHC.Classes.Eq a => a -> [a] -> GHC.Types.Bool
  elemIndex :: forall a. GHC.Classes.Eq a => a -> [a] -> GHC.Internal.Maybe.Maybe GHC.Types.Int
  elemIndices :: forall a. GHC.Classes.Eq a => a -> [a] -> [GHC.Types.Int]
  filter :: forall a. (a -> GHC.Types.Bool) -> [a] -> [a]
  find :: forall a. (a -> GHC.Types.Bool) -> [a] -> GHC.Internal.Maybe.Maybe a
  findIndex :: forall a. (a -> GHC.Types.Bool) -> [a] -> GHC.Internal.Maybe.Maybe GHC.Types.Int
  findIndices :: forall a. (a -> GHC.Types.Bool) -> [a] -> [GHC.Types.Int]
  foldl :: forall a b. (b -> a -> b) -> b -> [a] -> b
  foldl' :: forall a b. (b -> a -> b) -> b -> [a] -> b
  foldl1 :: forall a. GHC.Internal.Stack.Types.HasCallStack => (a -> a -> a) -> [a] -> a
  foldl1' :: forall a. GHC.Internal.Stack.Types.HasCallStack => (a -> a -> a) -> [a] -> a
  foldr :: forall a b. (a -> b -> b) -> b -> [a] -> b
  foldr1 :: forall a. GHC.Internal.Stack.Types.HasCallStack => (a -> a -> a) -> [a] -> a
  genericDrop :: forall i a. GHC.Internal.Real.Integral i => i -> [a] -> [a]
  genericIndex :: forall i a. GHC.Internal.Real.Integral i => [a] -> i -> a
  genericLength :: forall i a. GHC.Internal.Num.Num i => [a] -> i
  genericReplicate :: forall i a. GHC.Internal.Real.Integral i => i -> a -> [a]
  genericSplitAt :: forall i a. GHC.Internal.Real.Integral i => i -> [a] -> ([a], [a])
  genericTake :: forall i a. GHC.Internal.Real.Integral i => i -> [a] -> [a]
  group :: forall a. GHC.Classes.Eq a => [a] -> [[a]]
  groupBy :: forall a. (a -> a -> GHC.Types.Bool) -> [a] -> [[a]]
  head :: forall a. GHC.Internal.Stack.Types.HasCallStack => [a] -> a
  init :: forall a. GHC.Internal.Stack.Types.HasCallStack => [a] -> [a]
  inits :: forall a. [a] -> [[a]]
  insert :: forall a. GHC.Classes.Ord a => a -> [a] -> [a]
  insertBy :: forall a. (a -> a -> GHC.Types.Ordering) -> a -> [a] -> [a]
  intercalate :: forall a. [a] -> [[a]] -> [a]
  intersect :: forall a. GHC.Classes.Eq a => [a] -> [a] -> [a]
  intersectBy :: forall a. (a -> a -> GHC.Types.Bool) -> [a] -> [a] -> [a]
  intersperse :: forall a. a -> [a] -> [a]
  isInfixOf :: forall a. GHC.Classes.Eq a => [a] -> [a] -> GHC.Types.Bool
  isPrefixOf :: forall a. GHC.Classes.Eq a => [a] -> [a] -> GHC.Types.Bool
  isSuffixOf :: forall a. GHC.Classes.Eq a => [a] -> [a] -> GHC.Types.Bool
  iterate :: forall a. (a -> a) -> a -> [a]
  iterate' :: forall a. (a -> a) -> a -> [a]
  last :: forall a. GHC.Internal.Stack.Types.HasCallStack => [a] -> a
  length :: forall a. [a] -> GHC.Types.Int
  lines :: GHC.Internal.Base.String -> [GHC.Internal.Base.String]
  lookup :: forall a b. GHC.Classes.Eq a => a -> [(a, b)] -> GHC.Internal.Maybe.Maybe b
  map :: forall a b. (a -> b) -> [a] -> [b]
  mapAccumL :: forall acc x y. (acc -> x -> (acc, y)) -> acc -> [x] -> (acc, [y])
  mapAccumR :: forall acc x y. (acc -> x -> (acc, y)) -> acc -> [x] -> (acc, [y])
  maximum :: forall a. (GHC.Classes.Ord a, GHC.Internal.Stack.Types.HasCallStack) => [a] -> a
  maximumBy :: forall a. (a -> a -> GHC.Types.Ordering) -> [a] -> a
  minimum :: forall a. (GHC.Classes.Ord a, GHC.Internal.Stack.Types.HasCallStack) => [a] -> a
  minimumBy :: forall a. (a -> a -> GHC.Types.Ordering) -> [a] -> a
  notElem :: forall a. GHC.Classes.Eq a => a -> [a] -> GHC.Types.Bool
  nub :: forall a. GHC.Classes.Eq a => [a] -> [a]
  nubBy :: forall a. (a -> a -> GHC.Types.Bool) -> [a] -> [a]
  null :: forall a. [a] -> GHC.Types.Bool
  or :: [GHC.Types.Bool] -> GHC.Types.Bool
  partition :: forall a. (a -> GHC.Types.Bool) -> [a] -> ([a], [a])
  permutations :: forall a. [a] -> [[a]]
  product :: forall a. GHC.Internal.Num.Num a => [a] -> a
  repeat :: forall a. a -> [a]
  replicate :: forall a. GHC.Types.Int -> a -> [a]
  reverse :: forall a. [a] -> [a]
  scanl :: forall b a. (b -> a -> b) -> b -> [a] -> [b]
  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]
  singleton :: forall a. a -> [a]
  sort :: forall a. GHC.Classes.Ord a => [a] -> [a]
  sortBy :: forall a. (a -> a -> GHC.Types.Ordering) -> [a] -> [a]
  sortOn :: forall b a. GHC.Classes.Ord b => (a -> b) -> [a] -> [a]
  span :: forall a. (a -> GHC.Types.Bool) -> [a] -> ([a], [a])
  splitAt :: forall a. GHC.Types.Int -> [a] -> ([a], [a])
  stripPrefix :: forall a. GHC.Classes.Eq a => [a] -> [a] -> GHC.Internal.Maybe.Maybe [a]
  subsequences :: forall a. [a] -> [[a]]
  sum :: forall a. GHC.Internal.Num.Num a => [a] -> a
  tail :: forall a. GHC.Internal.Stack.Types.HasCallStack => [a] -> [a]
  tails :: forall a. [a] -> [[a]]
  take :: forall a. GHC.Types.Int -> [a] -> [a]
  takeWhile :: forall a. (a -> GHC.Types.Bool) -> [a] -> [a]
  transpose :: forall a. [[a]] -> [[a]]
  uncons :: forall a. [a] -> GHC.Internal.Maybe.Maybe (a, [a])
  unfoldr :: forall b a. (b -> GHC.Internal.Maybe.Maybe (a, b)) -> b -> [a]
  union :: forall a. GHC.Classes.Eq a => [a] -> [a] -> [a]
  unionBy :: forall a. (a -> a -> GHC.Types.Bool) -> [a] -> [a] -> [a]
  unlines :: [GHC.Internal.Base.String] -> GHC.Internal.Base.String
  unsnoc :: forall a. [a] -> GHC.Internal.Maybe.Maybe ([a], a)
  unwords :: [GHC.Internal.Base.String] -> GHC.Internal.Base.String
  unzip :: forall a b. [(a, b)] -> ([a], [b])
  unzip3 :: forall a b c. [(a, b, c)] -> ([a], [b], [c])
  unzip4 :: forall a b c d. [(a, b, c, d)] -> ([a], [b], [c], [d])
  unzip5 :: forall a b c d e. [(a, b, c, d, e)] -> ([a], [b], [c], [d], [e])
  unzip6 :: forall a b c d e f. [(a, b, c, d, e, f)] -> ([a], [b], [c], [d], [e], [f])
  unzip7 :: forall a b c d e f g. [(a, b, c, d, e, f, g)] -> ([a], [b], [c], [d], [e], [f], [g])
  words :: GHC.Internal.Base.String -> [GHC.Internal.Base.String]
  zip :: forall a b. [a] -> [b] -> [(a, b)]
  zip3 :: forall a b c. [a] -> [b] -> [c] -> [(a, b, c)]
  zip4 :: forall a b c d. [a] -> [b] -> [c] -> [d] -> [(a, b, c, d)]
  zip5 :: forall a b c d e. [a] -> [b] -> [c] -> [d] -> [e] -> [(a, b, c, d, e)]
  zip6 :: forall a b c d e f. [a] -> [b] -> [c] -> [d] -> [e] -> [f] -> [(a, b, c, d, e, f)]
  zip7 :: forall a b c d e f g. [a] -> [b] -> [c] -> [d] -> [e] -> [f] -> [g] -> [(a, b, c, d, e, f, g)]
  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]
  zipWith4 :: forall a b c d e. (a -> b -> c -> d -> e) -> [a] -> [b] -> [c] -> [d] -> [e]
  zipWith5 :: forall a b c d e f. (a -> b -> c -> d -> e -> f) -> [a] -> [b] -> [c] -> [d] -> [e] -> [f]
  zipWith6 :: forall a b c d e f g. (a -> b -> c -> d -> e -> f -> g) -> [a] -> [b] -> [c] -> [d] -> [e] -> [f] -> [g]
  zipWith7 :: forall a b c d e f g h. (a -> b -> c -> d -> e -> f -> g -> h) -> [a] -> [b] -> [c] -> [d] -> [e] -> [f] -> [g] -> [h]

module GHC.OverloadedLabels where
  -- Safety: None
  type IsLabel :: GHC.Types.Symbol -> * -> Constraint
  class IsLabel x a where
    fromLabel :: a
    {-# MINIMAL fromLabel #-}

module GHC.Pack where
  -- Safety: None
  packCString# :: [GHC.Types.Char] -> GHC.Prim.ByteArray#
  unpackAppendCString# :: GHC.Prim.Addr# -> [GHC.Types.Char] -> [GHC.Types.Char]
  unpackCString :: forall a. GHC.Internal.Ptr.Ptr a -> [GHC.Types.Char]
  unpackCString# :: GHC.Prim.Addr# -> [GHC.Types.Char]
  unpackFoldrCString# :: forall a. GHC.Prim.Addr# -> (GHC.Types.Char -> a -> a) -> a -> a
  unpackNBytes# :: GHC.Prim.Addr# -> GHC.Prim.Int# -> [GHC.Types.Char]

module GHC.Profiling where
  -- Safety: Safe
  requestHeapCensus :: GHC.Types.IO ()
  startHeapProfTimer :: GHC.Types.IO ()
  startProfTimer :: GHC.Types.IO ()
  stopHeapProfTimer :: GHC.Types.IO ()
  stopProfTimer :: GHC.Types.IO ()

module GHC.Ptr where
  -- Safety: None
  type role FunPtr phantom
  type FunPtr :: * -> *
  data FunPtr a = FunPtr GHC.Prim.Addr#
  type role Ptr phantom
  type Ptr :: * -> *
  data Ptr a = Ptr GHC.Prim.Addr#
  alignPtr :: forall a. Ptr a -> GHC.Types.Int -> Ptr a
  castFunPtr :: forall a b. FunPtr a -> FunPtr b
  castFunPtrToPtr :: forall a b. FunPtr a -> Ptr b
  castPtr :: forall a b. Ptr a -> Ptr b
  castPtrToFunPtr :: forall a b. Ptr a -> FunPtr b
  minusPtr :: forall a b. Ptr a -> Ptr b -> GHC.Types.Int
  nullFunPtr :: forall a. FunPtr a
  nullPtr :: forall a. Ptr a
  plusPtr :: forall a b. Ptr a -> GHC.Types.Int -> Ptr b

module GHC.RTS.Flags where
  -- Safety: None
  type CCFlags :: *
  data CCFlags = CCFlags {doCostCentres :: DoCostCentres, profilerTicks :: GHC.Types.Int, msecsPerTick :: GHC.Types.Int}
  type ConcFlags :: *
  data ConcFlags = ConcFlags {ctxtSwitchTime :: RtsTime, ctxtSwitchTicks :: GHC.Types.Int}
  type DebugFlags :: *
  data DebugFlags = DebugFlags {scheduler :: GHC.Types.Bool, interpreter :: GHC.Types.Bool, weak :: GHC.Types.Bool, gccafs :: GHC.Types.Bool, gc :: GHC.Types.Bool, nonmoving_gc :: GHC.Types.Bool, block_alloc :: GHC.Types.Bool, sanity :: GHC.Types.Bool, stable :: GHC.Types.Bool, prof :: GHC.Types.Bool, linker :: GHC.Types.Bool, apply :: GHC.Types.Bool, stm :: GHC.Types.Bool, squeeze :: GHC.Types.Bool, hpc :: GHC.Types.Bool, sparks :: GHC.Types.Bool}
  type DoCostCentres :: *
  data DoCostCentres = CostCentresNone | CostCentresSummary | CostCentresVerbose | CostCentresAll | CostCentresJSON
  type DoHeapProfile :: *
  data DoHeapProfile = NoHeapProfiling | HeapByCCS | HeapByMod | HeapByDescr | HeapByType | HeapByRetainer | HeapByLDV | HeapByClosureType | HeapByInfoTable | HeapByEra
  type DoTrace :: *
  data DoTrace = TraceNone | TraceEventLog | TraceStderr
  type GCFlags :: *
  data GCFlags
    = GCFlags {statsFile :: GHC.Internal.Maybe.Maybe GHC.Internal.IO.FilePath,
               giveStats :: GiveGCStats,
               maxStkSize :: GHC.Internal.Word.Word32,
               initialStkSize :: GHC.Internal.Word.Word32,
               stkChunkSize :: GHC.Internal.Word.Word32,
               stkChunkBufferSize :: GHC.Internal.Word.Word32,
               maxHeapSize :: GHC.Internal.Word.Word32,
               minAllocAreaSize :: GHC.Internal.Word.Word32,
               largeAllocLim :: GHC.Internal.Word.Word32,
               nurseryChunkSize :: GHC.Internal.Word.Word32,
               minOldGenSize :: GHC.Internal.Word.Word32,
               heapSizeSuggestion :: GHC.Internal.Word.Word32,
               heapSizeSuggestionAuto :: GHC.Types.Bool,
               oldGenFactor :: GHC.Types.Double,
               returnDecayFactor :: GHC.Types.Double,
               pcFreeHeap :: GHC.Types.Double,
               generations :: GHC.Internal.Word.Word32,
               squeezeUpdFrames :: GHC.Types.Bool,
               compact :: GHC.Types.Bool,
               compactThreshold :: GHC.Types.Double,
               sweep :: GHC.Types.Bool,
               ringBell :: GHC.Types.Bool,
               idleGCDelayTime :: RtsTime,
               doIdleGC :: GHC.Types.Bool,
               heapBase :: GHC.Types.Word,
               allocLimitGrace :: GHC.Types.Word,
               numa :: GHC.Types.Bool,
               numaMask :: GHC.Types.Word}
  type GiveGCStats :: *
  data GiveGCStats = NoGCStats | CollectGCStats | OneLineGCStats | SummaryGCStats | VerboseGCStats
  type HpcFlags :: *
  data HpcFlags = HpcFlags {writeTixFile :: GHC.Types.Bool}
  type IoSubSystem :: *
  data IoSubSystem = IoPOSIX | IoNative
  type MiscFlags :: *
  data MiscFlags = MiscFlags {tickInterval :: RtsTime, installSignalHandlers :: GHC.Types.Bool, installSEHHandlers :: GHC.Types.Bool, generateCrashDumpFile :: GHC.Types.Bool, generateStackTrace :: GHC.Types.Bool, machineReadable :: GHC.Types.Bool, disableDelayedOsMemoryReturn :: GHC.Types.Bool, internalCounters :: GHC.Types.Bool, linkerAlwaysPic :: GHC.Types.Bool, linkerMemBase :: GHC.Types.Word, ioManager :: IoSubSystem, numIoWorkerThreads :: GHC.Internal.Word.Word32}
  type ParFlags :: *
  data ParFlags = ParFlags {nCapabilities :: GHC.Internal.Word.Word32, migrate :: GHC.Types.Bool, maxLocalSparks :: GHC.Internal.Word.Word32, parGcEnabled :: GHC.Types.Bool, parGcGen :: GHC.Internal.Word.Word32, parGcLoadBalancingEnabled :: GHC.Types.Bool, parGcLoadBalancingGen :: GHC.Internal.Word.Word32, parGcNoSyncWithIdle :: GHC.Internal.Word.Word32, parGcThreads :: GHC.Internal.Word.Word32, setAffinity :: GHC.Types.Bool}
  type ProfFlags :: *
  data ProfFlags
    = ProfFlags {doHeapProfile :: DoHeapProfile,
                 heapProfileInterval :: RtsTime,
                 heapProfileIntervalTicks :: GHC.Types.Word,
                 startHeapProfileAtStartup :: GHC.Types.Bool,
                 startTimeProfileAtStartup :: GHC.Types.Bool,
                 showCCSOnException :: GHC.Types.Bool,
                 automaticEraIncrement :: GHC.Types.Bool,
                 maxRetainerSetSize :: GHC.Types.Word,
                 ccsLength :: GHC.Types.Word,
                 modSelector :: GHC.Internal.Maybe.Maybe GHC.Internal.Base.String,
                 descrSelector :: GHC.Internal.Maybe.Maybe GHC.Internal.Base.String,
                 typeSelector :: GHC.Internal.Maybe.Maybe GHC.Internal.Base.String,
                 ccSelector :: GHC.Internal.Maybe.Maybe GHC.Internal.Base.String,
                 ccsSelector :: GHC.Internal.Maybe.Maybe GHC.Internal.Base.String,
                 retainerSelector :: GHC.Internal.Maybe.Maybe GHC.Internal.Base.String,
                 bioSelector :: GHC.Internal.Maybe.Maybe GHC.Internal.Base.String,
                 eraSelector :: GHC.Types.Word}
  type RTSFlags :: *
  data RTSFlags = RTSFlags {gcFlags :: GCFlags, concurrentFlags :: ConcFlags, miscFlags :: MiscFlags, debugFlags :: DebugFlags, costCentreFlags :: CCFlags, profilingFlags :: ProfFlags, traceFlags :: TraceFlags, tickyFlags :: TickyFlags, parFlags :: ParFlags, hpcFlags :: HpcFlags}
  type RtsTime :: *
  type RtsTime = GHC.Internal.Word.Word64
  type TickyFlags :: *
  data TickyFlags = TickyFlags {showTickyStats :: GHC.Types.Bool, tickyFile :: GHC.Internal.Maybe.Maybe GHC.Internal.IO.FilePath}
  type TraceFlags :: *
  data TraceFlags = TraceFlags {tracing :: DoTrace, timestamp :: GHC.Types.Bool, traceScheduler :: GHC.Types.Bool, traceGc :: GHC.Types.Bool, traceNonmovingGc :: GHC.Types.Bool, sparksSampled :: GHC.Types.Bool, sparksFull :: GHC.Types.Bool, user :: GHC.Types.Bool}
  getCCFlags :: GHC.Types.IO CCFlags
  getConcFlags :: GHC.Types.IO ConcFlags
  getDebugFlags :: GHC.Types.IO DebugFlags
  getGCFlags :: GHC.Types.IO GCFlags
  getHpcFlags :: GHC.Types.IO HpcFlags
  getIoManagerFlag :: GHC.Types.IO IoSubSystem
  getMiscFlags :: GHC.Types.IO MiscFlags
  getParFlags :: GHC.Types.IO ParFlags
  getProfFlags :: GHC.Types.IO ProfFlags
  getRTSFlags :: GHC.Types.IO RTSFlags
  getTickyFlags :: GHC.Types.IO TickyFlags
  getTraceFlags :: GHC.Types.IO TraceFlags

module GHC.Read where
  -- Safety: Safe
  type Read :: * -> Constraint
  class Read a where
    readsPrec :: GHC.Types.Int -> ReadS a
    readList :: ReadS [a]
    readPrec :: GHC.Internal.Text.ParserCombinators.ReadPrec.ReadPrec a
    readListPrec :: GHC.Internal.Text.ParserCombinators.ReadPrec.ReadPrec [a]
    {-# MINIMAL readsPrec | readPrec #-}
  type ReadS :: * -> *
  type ReadS a = GHC.Internal.Base.String -> [(a, GHC.Internal.Base.String)]
  choose :: forall a. [(GHC.Internal.Base.String, GHC.Internal.Text.ParserCombinators.ReadPrec.ReadPrec a)] -> GHC.Internal.Text.ParserCombinators.ReadPrec.ReadPrec a
  expectP :: GHC.Internal.Text.Read.Lex.Lexeme -> GHC.Internal.Text.ParserCombinators.ReadPrec.ReadPrec ()
  lex :: ReadS GHC.Internal.Base.String
  lexDigits :: ReadS GHC.Internal.Base.String
  lexLitChar :: ReadS GHC.Internal.Base.String
  lexP :: GHC.Internal.Text.ParserCombinators.ReadPrec.ReadPrec GHC.Internal.Text.Read.Lex.Lexeme
  list :: forall a. GHC.Internal.Text.ParserCombinators.ReadPrec.ReadPrec a -> GHC.Internal.Text.ParserCombinators.ReadPrec.ReadPrec [a]
  paren :: forall a. GHC.Internal.Text.ParserCombinators.ReadPrec.ReadPrec a -> GHC.Internal.Text.ParserCombinators.ReadPrec.ReadPrec a
  parens :: forall a. GHC.Internal.Text.ParserCombinators.ReadPrec.ReadPrec a -> GHC.Internal.Text.ParserCombinators.ReadPrec.ReadPrec a
  readField :: forall a. GHC.Internal.Base.String -> GHC.Internal.Text.ParserCombinators.ReadPrec.ReadPrec a -> GHC.Internal.Text.ParserCombinators.ReadPrec.ReadPrec a
  readFieldHash :: forall a. GHC.Internal.Base.String -> GHC.Internal.Text.ParserCombinators.ReadPrec.ReadPrec a -> GHC.Internal.Text.ParserCombinators.ReadPrec.ReadPrec a
  readListDefault :: forall a. Read a => ReadS [a]
  readListPrecDefault :: forall a. Read a => GHC.Internal.Text.ParserCombinators.ReadPrec.ReadPrec [a]
  readLitChar :: ReadS GHC.Types.Char
  readNumber :: forall a. GHC.Internal.Num.Num a => (GHC.Internal.Text.Read.Lex.Lexeme -> GHC.Internal.Text.ParserCombinators.ReadPrec.ReadPrec a) -> GHC.Internal.Text.ParserCombinators.ReadPrec.ReadPrec a
  readParen :: forall a. GHC.Types.Bool -> ReadS a -> ReadS a
  readSymField :: forall a. GHC.Internal.Base.String -> GHC.Internal.Text.ParserCombinators.ReadPrec.ReadPrec a -> GHC.Internal.Text.ParserCombinators.ReadPrec.ReadPrec a

module GHC.Real where
  -- Safety: Safe
  (%) :: forall a. Integral a => a -> a -> Ratio a
  type Fractional :: * -> Constraint
  class GHC.Internal.Num.Num a => Fractional a where
    (/) :: a -> a -> a
    recip :: a -> a
    fromRational :: Rational -> a
    {-# MINIMAL fromRational, (recip | (/)) #-}
  type FractionalExponentBase :: *
  data FractionalExponentBase = Base2 | Base10
  type Integral :: * -> Constraint
  class (Real a, GHC.Internal.Enum.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 -> GHC.Num.Integer.Integer
    {-# MINIMAL quotRem, toInteger #-}
  type Ratio :: * -> *
  data Ratio a = !a :% !a
  type Rational :: *
  type Rational = Ratio GHC.Num.Integer.Integer
  type Real :: * -> Constraint
  class (GHC.Internal.Num.Num a, GHC.Classes.Ord a) => Real a where
    toRational :: a -> Rational
    {-# MINIMAL toRational #-}
  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 #-}
  (^) :: forall a b. (GHC.Internal.Num.Num a, Integral b) => a -> b -> a
  (^%^) :: forall a. Integral a => Rational -> a -> Rational
  (^^) :: forall a b. (Fractional a, Integral b) => a -> b -> a
  (^^%^^) :: forall a. Integral a => Rational -> a -> Rational
  denominator :: forall a. Ratio a -> a
  divZeroError :: forall a. a
  even :: forall a. Integral a => a -> GHC.Types.Bool
  fromIntegral :: forall a b. (Integral a, GHC.Internal.Num.Num b) => a -> b
  gcd :: forall a. Integral a => a -> a -> a
  infinity :: Rational
  integralEnumFrom :: forall a. (Integral a, GHC.Internal.Enum.Bounded a) => a -> [a]
  integralEnumFromThen :: forall a. (Integral a, GHC.Internal.Enum.Bounded a) => a -> a -> [a]
  integralEnumFromThenTo :: forall a. Integral a => a -> a -> a -> [a]
  integralEnumFromTo :: forall a. Integral a => a -> a -> [a]
  lcm :: forall a. Integral a => a -> a -> a
  mkRationalBase10 :: Rational -> GHC.Num.Integer.Integer -> Rational
  mkRationalBase2 :: Rational -> GHC.Num.Integer.Integer -> Rational
  mkRationalWithExponentBase :: Rational -> GHC.Num.Integer.Integer -> FractionalExponentBase -> Rational
  notANumber :: Rational
  numerator :: forall a. Ratio a -> a
  numericEnumFrom :: forall a. Fractional a => a -> [a]
  numericEnumFromThen :: forall a. Fractional a => a -> a -> [a]
  numericEnumFromThenTo :: forall a. (GHC.Classes.Ord a, Fractional a) => a -> a -> a -> [a]
  numericEnumFromTo :: forall a. (GHC.Classes.Ord a, Fractional a) => a -> a -> [a]
  odd :: forall a. Integral a => a -> GHC.Types.Bool
  overflowError :: forall a. a
  powImpl :: forall a b. (GHC.Internal.Num.Num a, Integral b) => a -> b -> a
  powImplAcc :: forall a b. (GHC.Internal.Num.Num a, Integral b) => a -> b -> a -> a
  ratioPrec :: GHC.Types.Int
  ratioPrec1 :: GHC.Types.Int
  ratioZeroDenominatorError :: forall a. a
  realToFrac :: forall a b. (Real a, Fractional b) => a -> b
  reduce :: forall a. Integral a => a -> a -> Ratio a
  showSigned :: forall a. Real a => (a -> GHC.Internal.Show.ShowS) -> GHC.Types.Int -> a -> GHC.Internal.Show.ShowS
  underflowError :: forall a. a

module GHC.Records where
  -- Safety: Safe
  type HasField :: forall {k}. k -> * -> * -> Constraint
  class HasField x r a | x r -> a where
    getField :: r -> a
    {-# MINIMAL getField #-}

module GHC.ResponseFile where
  -- Safety: Safe
  escapeArgs :: [GHC.Internal.Base.String] -> GHC.Internal.Base.String
  expandResponse :: [GHC.Internal.Base.String] -> GHC.Types.IO [GHC.Internal.Base.String]
  getArgsWithResponseFiles :: GHC.Types.IO [GHC.Internal.Base.String]
  unescapeArgs :: GHC.Internal.Base.String -> [GHC.Internal.Base.String]

module GHC.ST where
  -- Safety: None
  type role ST nominal representational
  type ST :: * -> * -> *
  newtype ST s a = ST (STRep s a)
  type STRep :: * -> * -> *
  type STRep s a = GHC.Prim.State# s -> (# GHC.Prim.State# s, a #)
  type role STret nominal representational
  type STret :: * -> * -> *
  data STret s a = STret (GHC.Prim.State# s) a
  liftST :: forall s a. ST s a -> GHC.Prim.State# s -> STret s a
  runST :: forall a. (forall s. ST s a) -> a
  unsafeDupableInterleaveST :: forall s a. ST s a -> ST s a
  unsafeInterleaveST :: forall s a. ST s a -> ST s a

module GHC.STRef where
  -- Safety: None
  type role STRef nominal representational
  type STRef :: * -> * -> *
  data STRef s a = STRef (GHC.Prim.MutVar# s a)
  newSTRef :: forall a s. a -> GHC.Internal.ST.ST s (STRef s a)
  readSTRef :: forall s a. STRef s a -> GHC.Internal.ST.ST s a
  writeSTRef :: forall s a. STRef s a -> a -> GHC.Internal.ST.ST s ()

module GHC.Show where
  -- Safety: Safe
  type Show :: * -> Constraint
  class Show a where
    showsPrec :: GHC.Types.Int -> a -> ShowS
    show :: a -> GHC.Internal.Base.String
    showList :: [a] -> ShowS
    {-# MINIMAL showsPrec | show #-}
  type ShowS :: *
  type ShowS = GHC.Internal.Base.String -> GHC.Internal.Base.String
  appPrec :: GHC.Types.Int
  appPrec1 :: GHC.Types.Int
  asciiTab :: [GHC.Internal.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.Internal.Base.String -> ShowS
  showMultiLineString :: GHC.Internal.Base.String -> [GHC.Internal.Base.String]
  showParen :: GHC.Types.Bool -> ShowS -> ShowS
  showSignedInt :: GHC.Types.Int -> GHC.Types.Int -> ShowS
  showSpace :: ShowS
  showString :: GHC.Internal.Base.String -> ShowS
  shows :: forall a. Show a => a -> ShowS

module GHC.Stable where
  -- Safety: None
  type StablePtr :: * -> *
  data StablePtr a = StablePtr (GHC.Prim.StablePtr# a)
  castPtrToStablePtr :: forall a. GHC.Internal.Ptr.Ptr () -> StablePtr a
  castStablePtrToPtr :: forall a. StablePtr a -> GHC.Internal.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: Safe
  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: Safe
  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.Internal.Ptr.Ptr CostCentre -> GHC.Types.IO GHC.Internal.Foreign.C.String.Encoding.CString
  ccModule :: GHC.Internal.Ptr.Ptr CostCentre -> GHC.Types.IO GHC.Internal.Foreign.C.String.Encoding.CString
  ccSrcSpan :: GHC.Internal.Ptr.Ptr CostCentre -> GHC.Types.IO GHC.Internal.Foreign.C.String.Encoding.CString
  ccsCC :: GHC.Internal.Ptr.Ptr CostCentreStack -> GHC.Types.IO (GHC.Internal.Ptr.Ptr CostCentre)
  ccsParent :: GHC.Internal.Ptr.Ptr CostCentreStack -> GHC.Types.IO (GHC.Internal.Ptr.Ptr CostCentreStack)
  ccsToStrings :: GHC.Internal.Ptr.Ptr CostCentreStack -> GHC.Types.IO [GHC.Internal.Base.String]
  clearCCS :: forall a. GHC.Types.IO a -> GHC.Types.IO a
  currentCallStack :: GHC.Types.IO [GHC.Internal.Base.String]
  emptyCallStack :: CallStack
  errorWithStackTrace :: forall a. GHC.Internal.Base.String -> a
  freezeCallStack :: CallStack -> CallStack
  fromCallSiteList :: [([GHC.Types.Char], SrcLoc)] -> CallStack
  getCCSOf :: forall a. a -> GHC.Types.IO (GHC.Internal.Ptr.Ptr CostCentreStack)
  getCallStack :: CallStack -> [([GHC.Types.Char], SrcLoc)]
  getCurrentCCS :: forall dummy. dummy -> GHC.Types.IO (GHC.Internal.Ptr.Ptr CostCentreStack)
  popCallStack :: CallStack -> CallStack
  prettyCallStack :: CallStack -> GHC.Internal.Base.String
  prettySrcLoc :: SrcLoc -> GHC.Internal.Base.String
  pushCallStack :: ([GHC.Types.Char], SrcLoc) -> CallStack -> CallStack
  renderStack :: [GHC.Internal.Base.String] -> GHC.Internal.Base.String
  whoCreated :: forall a. a -> GHC.Types.IO [GHC.Internal.Base.String]
  withFrozenCallStack :: forall a. HasCallStack => (HasCallStack => a) -> a

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

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

module GHC.Stack.Types where
  -- Safety: Safe
  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. ghc-internal-0.1.0.0:GHC.Internal.Data.Typeable.Internal.Typeable a => StaticPtr a -> p a
    {-# MINIMAL fromStaticPtr #-}
  type StaticKey :: *
  type StaticKey = GHC.Internal.Fingerprint.Type.Fingerprint
  type StaticPtr :: * -> *
  data StaticPtr a = ...
  type StaticPtrInfo :: *
  data StaticPtrInfo = StaticPtrInfo {spInfoUnitId :: GHC.Internal.Base.String, spInfoModuleName :: GHC.Internal.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.Internal.Maybe.Maybe (StaticPtr a))

module GHC.Stats where
  -- Safety: Safe
  type GCDetails :: *
  data GCDetails
    = GCDetails {gcdetails_gen :: GHC.Internal.Word.Word32,
                 gcdetails_threads :: GHC.Internal.Word.Word32,
                 gcdetails_allocated_bytes :: GHC.Internal.Word.Word64,
                 gcdetails_live_bytes :: GHC.Internal.Word.Word64,
                 gcdetails_large_objects_bytes :: GHC.Internal.Word.Word64,
                 gcdetails_compact_bytes :: GHC.Internal.Word.Word64,
                 gcdetails_slop_bytes :: GHC.Internal.Word.Word64,
                 gcdetails_mem_in_use_bytes :: GHC.Internal.Word.Word64,
                 gcdetails_copied_bytes :: GHC.Internal.Word.Word64,
                 gcdetails_par_max_copied_bytes :: GHC.Internal.Word.Word64,
                 gcdetails_par_balanced_copied_bytes :: GHC.Internal.Word.Word64,
                 gcdetails_block_fragmentation_bytes :: GHC.Internal.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.Internal.Word.Word32,
                major_gcs :: GHC.Internal.Word.Word32,
                allocated_bytes :: GHC.Internal.Word.Word64,
                max_live_bytes :: GHC.Internal.Word.Word64,
                max_large_objects_bytes :: GHC.Internal.Word.Word64,
                max_compact_bytes :: GHC.Internal.Word.Word64,
                max_slop_bytes :: GHC.Internal.Word.Word64,
                max_mem_in_use_bytes :: GHC.Internal.Word.Word64,
                cumulative_live_bytes :: GHC.Internal.Word.Word64,
                copied_bytes :: GHC.Internal.Word.Word64,
                par_copied_bytes :: GHC.Internal.Word.Word64,
                cumulative_par_max_copied_bytes :: GHC.Internal.Word.Word64,
                cumulative_par_balanced_copied_bytes :: GHC.Internal.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.Internal.Int.Int64
  getRTSStats :: GHC.Types.IO RTSStats
  getRTSStatsEnabled :: GHC.Types.IO GHC.Types.Bool

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

module GHC.TopHandler where
  -- Safety: Safe
  flushStdHandles :: GHC.Types.IO ()
  reportError :: GHC.Internal.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.Internal.Exception.Type.SomeException -> GHC.Types.IO a
  topHandlerFastExit :: forall a. GHC.Internal.Exception.Type.SomeException -> GHC.Types.IO a

module GHC.TypeError where
  -- Safety: Safe
  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.Internal.TypeError.unsatisfiableLifted #-}
  unsatisfiable :: forall {rep :: GHC.Types.RuntimeRep} (msg :: ErrorMessage) (a :: TYPE rep). Unsatisfiable msg => a

module GHC.TypeLits where
  -- Safety: Safe
  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.Internal.TypeError.Assert (x <=? y) (GHC.Internal.Data.Type.Ord.LeErrMsg x y) :: Constraint
  type (<=?) :: forall k. k -> k -> GHC.Types.Bool
  type (<=?) m n = GHC.Internal.Data.Type.Ord.OrdCond (GHC.Internal.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). (GHC.Internal.Data.Type.Ord.Compare a b ~ GHC.Types.LT) => OrderingI a b
    EQI :: forall {k} (a :: k). (GHC.Internal.Data.Type.Ord.Compare a a ~ GHC.Types.EQ) => OrderingI a a
    GTI :: forall {k} (a :: k) (b :: k). (GHC.Internal.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 (GHC.Internal.Data.Proxy.Proxy n)
  type SomeNat :: *
  data SomeNat = forall (n :: Nat). KnownNat n => SomeNat (GHC.Internal.Data.Proxy.Proxy n)
  type SomeSymbol :: *
  data SomeSymbol = forall (n :: Symbol). KnownSymbol n => SomeSymbol (GHC.Internal.Data.Proxy.Proxy n)
  type Symbol :: *
  data Symbol
  type TypeError :: forall b. ErrorMessage -> b
  type family TypeError a where
  type UnconsSymbol :: Symbol -> GHC.Internal.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 -> GHC.Internal.Data.Either.Either ((a GHC.Internal.Data.Type.Equality.:~: b) -> GHC.Internal.Base.Void) (a GHC.Internal.Data.Type.Equality.:~: b)
  decideNat :: forall (a :: Nat) (b :: Nat) (proxy1 :: Nat -> *) (proxy2 :: Nat -> *). (KnownNat a, KnownNat b) => proxy1 a -> proxy2 b -> GHC.Internal.Data.Either.Either ((a GHC.Internal.Data.Type.Equality.:~: b) -> GHC.Internal.Base.Void) (a GHC.Internal.Data.Type.Equality.:~: b)
  decideSymbol :: forall (a :: Symbol) (b :: Symbol) (proxy1 :: Symbol -> *) (proxy2 :: Symbol -> *). (KnownSymbol a, KnownSymbol b) => proxy1 a -> proxy2 b -> GHC.Internal.Data.Either.Either ((a GHC.Internal.Data.Type.Equality.:~: b) -> GHC.Internal.Base.Void) (a GHC.Internal.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.Internal.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.Internal.Maybe.Maybe (a GHC.Internal.Data.Type.Equality.:~: b)
  sameNat :: forall (a :: Nat) (b :: Nat) (proxy1 :: Nat -> *) (proxy2 :: Nat -> *). (KnownNat a, KnownNat b) => proxy1 a -> proxy2 b -> GHC.Internal.Maybe.Maybe (a GHC.Internal.Data.Type.Equality.:~: b)
  sameSymbol :: forall (a :: Symbol) (b :: Symbol) (proxy1 :: Symbol -> *) (proxy2 :: Symbol -> *). (KnownSymbol a, KnownSymbol b) => proxy1 a -> proxy2 b -> GHC.Internal.Maybe.Maybe (a GHC.Internal.Data.Type.Equality.:~: b)
  someCharVal :: GHC.Types.Char -> SomeChar
  someNatVal :: GHC.Num.Integer.Integer -> GHC.Internal.Maybe.Maybe SomeNat
  someSymbolVal :: GHC.Internal.Base.String -> SomeSymbol
  symbolVal :: forall (n :: Symbol) (proxy :: Symbol -> *). KnownSymbol n => proxy n -> GHC.Internal.Base.String
  symbolVal' :: forall (n :: Symbol). KnownSymbol n => GHC.Prim.Proxy# n -> GHC.Internal.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.Internal.Maybe.Maybe (SNat n) -> r) -> r
  withSomeSSymbol :: forall (rep :: GHC.Types.RuntimeRep) (r :: TYPE rep). GHC.Internal.Base.String -> (forall (s :: Symbol). SSymbol s -> r) -> r

module GHC.TypeLits.Internal where
  -- Safety: Safe
  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: Safe
  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.Internal.TypeError.Assert (x <=? y) (GHC.Internal.Data.Type.Ord.LeErrMsg x y) :: Constraint
  type (<=?) :: forall k. k -> k -> GHC.Types.Bool
  type (<=?) m n = GHC.Internal.Data.Type.Ord.OrdCond (GHC.Internal.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 (GHC.Internal.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 -> GHC.Internal.Data.Type.Ord.OrderingI a b
  decideNat :: forall (a :: Nat) (b :: Nat) (proxy1 :: Nat -> *) (proxy2 :: Nat -> *). (KnownNat a, KnownNat b) => proxy1 a -> proxy2 b -> GHC.Internal.Data.Either.Either ((a GHC.Internal.Data.Type.Equality.:~: b) -> GHC.Internal.Base.Void) (a GHC.Internal.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.Internal.Maybe.Maybe (a GHC.Internal.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: Safe
  type CmpNat :: Natural -> Natural -> GHC.Types.Ordering
  type family CmpNat a b
  type Natural :: *
  data Natural = ...

module GHC.Unicode where
  -- Safety: Safe
  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 :: GHC.Internal.Data.Version.Version

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

module GHC.Weak.Finalize where
  -- Safety: None
  getFinalizerExceptionHandler :: GHC.Types.IO (GHC.Internal.Exception.Type.SomeException -> GHC.Types.IO ())
  printToHandleFinalizerExceptionHandler :: GHC.Internal.IO.Handle.Types.Handle -> GHC.Internal.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.Internal.Exception.Type.SomeException -> GHC.Types.IO ()) -> GHC.Types.IO ()

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

module System.Posix.Types where

-- ignored


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

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

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

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

module Text.Read where
  -- Safety: Safe
  (+++) :: forall a. ReadPrec a -> ReadPrec a -> ReadPrec a
  (<++) :: forall a. ReadPrec a -> ReadPrec a -> ReadPrec a
  type Lexeme :: *
  data Lexeme = Char GHC.Types.Char | String GHC.Internal.Base.String | Punc GHC.Internal.Base.String | Ident GHC.Internal.Base.String | Symbol GHC.Internal.Base.String | Number GHC.Internal.Text.Read.Lex.Number | EOF
  type Prec :: *
  type Prec = GHC.Types.Int
  type Read :: * -> Constraint
  class Read a where
    readsPrec :: GHC.Types.Int -> ReadS a
    readList :: ReadS [a]
    readPrec :: ReadPrec a
    readListPrec :: ReadPrec [a]
    {-# MINIMAL readsPrec | readPrec #-}
  type ReadPrec :: * -> *
  newtype ReadPrec a = ...
  type ReadS :: * -> *
  type ReadS a = GHC.Internal.Base.String -> [(a, GHC.Internal.Base.String)]
  choice :: forall a. [ReadPrec a] -> ReadPrec a
  get :: ReadPrec GHC.Types.Char
  lex :: ReadS GHC.Internal.Base.String
  lexP :: ReadPrec Lexeme
  lift :: forall a. GHC.Internal.Text.ParserCombinators.ReadP.ReadP a -> ReadPrec a
  look :: ReadPrec GHC.Internal.Base.String
  minPrec :: Prec
  parens :: forall a. ReadPrec a -> ReadPrec a
  pfail :: forall a. ReadPrec a
  prec :: forall a. Prec -> ReadPrec a -> ReadPrec a
  read :: forall a. Read a => GHC.Internal.Base.String -> a
  readEither :: forall a. Read a => GHC.Internal.Base.String -> GHC.Internal.Data.Either.Either GHC.Internal.Base.String a
  readListDefault :: forall a. Read a => ReadS [a]
  readListPrecDefault :: forall a. Read a => ReadPrec [a]
  readMaybe :: forall a. Read a => GHC.Internal.Base.String -> GHC.Internal.Maybe.Maybe a
  readP_to_Prec :: forall a. (GHC.Types.Int -> GHC.Internal.Text.ParserCombinators.ReadP.ReadP a) -> ReadPrec a
  readParen :: forall a. GHC.Types.Bool -> ReadS a -> ReadS a
  readPrec_to_P :: forall a. ReadPrec a -> GHC.Types.Int -> GHC.Internal.Text.ParserCombinators.ReadP.ReadP a
  readPrec_to_S :: forall a. ReadPrec a -> GHC.Types.Int -> ReadS a
  readS_to_Prec :: forall a. (GHC.Types.Int -> ReadS a) -> ReadPrec a
  reads :: forall a. Read a => ReadS a
  reset :: forall a. ReadPrec a -> ReadPrec a
  step :: forall a. ReadPrec a -> ReadPrec a

module Text.Read.Lex where
  -- Safety: Safe
  type Lexeme :: *
  data Lexeme = Char GHC.Types.Char | String GHC.Internal.Base.String | Punc GHC.Internal.Base.String | Ident GHC.Internal.Base.String | Symbol GHC.Internal.Base.String | Number Number | EOF
  type Number :: *
  data Number = ...
  expect :: Lexeme -> GHC.Internal.Text.ParserCombinators.ReadP.ReadP ()
  hsLex :: GHC.Internal.Text.ParserCombinators.ReadP.ReadP GHC.Internal.Base.String
  isSymbolChar :: GHC.Types.Char -> GHC.Types.Bool
  lex :: GHC.Internal.Text.ParserCombinators.ReadP.ReadP Lexeme
  lexChar :: GHC.Internal.Text.ParserCombinators.ReadP.ReadP GHC.Types.Char
  numberToFixed :: GHC.Num.Integer.Integer -> Number -> GHC.Internal.Maybe.Maybe (GHC.Num.Integer.Integer, GHC.Num.Integer.Integer)
  numberToInteger :: Number -> GHC.Internal.Maybe.Maybe GHC.Num.Integer.Integer
  numberToRangedRational :: (GHC.Types.Int, GHC.Types.Int) -> Number -> GHC.Internal.Maybe.Maybe GHC.Internal.Real.Rational
  numberToRational :: Number -> GHC.Internal.Real.Rational
  readBinP :: forall a. (GHC.Classes.Eq a, GHC.Internal.Num.Num a) => GHC.Internal.Text.ParserCombinators.ReadP.ReadP a
  readDecP :: forall a. (GHC.Classes.Eq a, GHC.Internal.Num.Num a) => GHC.Internal.Text.ParserCombinators.ReadP.ReadP a
  readHexP :: forall a. (GHC.Classes.Eq a, GHC.Internal.Num.Num a) => GHC.Internal.Text.ParserCombinators.ReadP.ReadP a
  readIntP :: forall a. GHC.Internal.Num.Num a => a -> (GHC.Types.Char -> GHC.Types.Bool) -> (GHC.Types.Char -> GHC.Types.Int) -> GHC.Internal.Text.ParserCombinators.ReadP.ReadP a
  readOctP :: forall a. (GHC.Classes.Eq a, GHC.Internal.Num.Num a) => GHC.Internal.Text.ParserCombinators.ReadP.ReadP a

module Text.Show where
  -- Safety: Safe
  type Show :: * -> Constraint
  class Show a where
    showsPrec :: GHC.Types.Int -> a -> ShowS
    show :: a -> GHC.Internal.Base.String
    showList :: [a] -> ShowS
    {-# MINIMAL showsPrec | show #-}
  type ShowS :: *
  type ShowS = GHC.Internal.Base.String -> GHC.Internal.Base.String
  showChar :: GHC.Types.Char -> ShowS
  showListWith :: forall a. (a -> ShowS) -> [a] -> ShowS
  showParen :: GHC.Types.Bool -> ShowS -> ShowS
  showString :: GHC.Internal.Base.String -> ShowS
  shows :: forall a. Show a => a -> ShowS

module Text.Show.Functions where
  -- Safety: Safe

module Type.Reflection where
  -- Safety: Safe
  type role (:~:) nominal nominal
  type (:~:) :: forall {k}. k -> k -> *
  data (:~:) a b where
    Refl :: forall {k} (a :: k). (:~:) a a
  type role (:~~:) nominal nominal
  type (:~~:) :: forall k1 k2. k1 -> k2 -> *
  data (:~~:) a b where
    HRefl :: forall {k1} (a :: k1). (:~~:) a a
  pattern App :: forall k2 (t :: k2). () => forall k1 (a :: k1 -> k2) (b :: k1). (t ~ a b) => TypeRep a -> TypeRep b -> TypeRep t
  pattern Con :: forall k (a :: k). () => ghc-internal-0.1.0.0:GHC.Internal.Data.Typeable.Internal.NotApplication a => TyCon -> TypeRep a
  pattern Con' :: forall k (a :: k). () => ghc-internal-0.1.0.0:GHC.Internal.Data.Typeable.Internal.NotApplication a => TyCon -> [SomeTypeRep] -> TypeRep a
  pattern Fun :: forall k (fun :: k). () => forall (r1 :: GHC.Types.RuntimeRep) (r2 :: GHC.Types.RuntimeRep) (arg :: TYPE r1) (res :: TYPE r2). (k ~ *, fun ~~ (arg -> res)) => TypeRep arg -> TypeRep res -> TypeRep fun
  type Module :: *
  data Module = ...
  type SomeTypeRep :: *
  data SomeTypeRep where
    SomeTypeRep :: forall k (a :: k). !(TypeRep a) -> SomeTypeRep
  type TyCon :: *
  data TyCon = ...
  pattern TypeRep :: forall {k} (a :: k). () => Typeable a => TypeRep a
  type role TypeRep nominal
  type TypeRep :: forall k. k -> *
  data TypeRep a where
    ...
  type Typeable :: forall k. k -> Constraint
  class Typeable a where
    ...
    {-# MINIMAL ghc-internal-0.1.0.0:GHC.Internal.Data.Typeable.Internal.typeRep# #-}
  decTypeRep :: forall k1 k2 (a :: k1) (b :: k2). TypeRep a -> TypeRep b -> GHC.Internal.Data.Either.Either ((a :~~: b) -> GHC.Internal.Base.Void) (a :~~: b)
  eqTypeRep :: forall k1 k2 (a :: k1) (b :: k2). TypeRep a -> TypeRep b -> GHC.Internal.Maybe.Maybe (a :~~: b)
  moduleName :: Module -> GHC.Internal.Base.String
  modulePackage :: Module -> GHC.Internal.Base.String
  rnfModule :: Module -> ()
  rnfSomeTypeRep :: SomeTypeRep -> ()
  rnfTyCon :: TyCon -> ()
  rnfTypeRep :: forall {k} (a :: k). TypeRep a -> ()
  someTypeRep :: forall {k} (proxy :: k -> *) (a :: k). Typeable a => proxy a -> SomeTypeRep
  someTypeRepTyCon :: SomeTypeRep -> TyCon
  splitApps :: forall {k} (a :: k). TypeRep a -> (TyCon, [SomeTypeRep])
  tyConModule :: TyCon -> GHC.Internal.Base.String
  tyConName :: TyCon -> GHC.Internal.Base.String
  tyConPackage :: TyCon -> GHC.Internal.Base.String
  typeOf :: forall a. Typeable a => a -> TypeRep a
  typeRep :: forall {k} (a :: k). Typeable a => TypeRep a
  typeRepKind :: forall k (a :: k). TypeRep a -> TypeRep k
  typeRepTyCon :: forall {k} (a :: k). TypeRep a -> TyCon
  withTypeable :: forall k (a :: k) (rep :: GHC.Types.RuntimeRep) (r :: TYPE rep). TypeRep a -> (Typeable a => r) -> r

module Type.Reflection.Unsafe where
  -- Safety: None
  type KindRep :: *
  data KindRep = KindRepTyConApp TyCon [KindRep] | KindRepVar {-# UNPACK #-}GHC.Types.KindBndr | KindRepApp KindRep KindRep | KindRepFun KindRep KindRep | KindRepTYPE !GHC.Types.RuntimeRep | KindRepTypeLitS TypeLitSort GHC.Prim.Addr# | KindRepTypeLitD TypeLitSort [GHC.Types.Char]
  pattern KindRepTypeLit :: TypeLitSort -> GHC.Internal.Base.String -> KindRep
  type TyCon :: *
  data TyCon = ...
  type TypeLitSort :: *
  data TypeLitSort = TypeLitSymbol | TypeLitNat | TypeLitChar
  type role TypeRep nominal
  type TypeRep :: forall k. k -> *
  data TypeRep a where
    ...
  mkTrApp :: forall k1 k2 (a :: k1 -> k2) (b :: k1). TypeRep a -> TypeRep b -> TypeRep (a b)
  mkTrCon :: forall k (a :: k). TyCon -> [ghc-internal-0.1.0.0:GHC.Internal.Data.Typeable.Internal.SomeTypeRep] -> TypeRep a
  mkTyCon :: GHC.Internal.Base.String -> GHC.Internal.Base.String -> GHC.Internal.Base.String -> GHC.Types.Int -> KindRep -> TyCon
  someTypeRepFingerprint :: ghc-internal-0.1.0.0:GHC.Internal.Data.Typeable.Internal.SomeTypeRep -> GHC.Internal.Fingerprint.Type.Fingerprint
  tyConFingerprint :: TyCon -> GHC.Internal.Fingerprint.Type.Fingerprint
  tyConKindArgs :: TyCon -> GHC.Types.Int
  tyConKindRep :: TyCon -> KindRep
  typeRepFingerprint :: forall {k} (a :: k). TypeRep a -> GHC.Internal.Fingerprint.Type.Fingerprint

module Unsafe.Coerce where
  -- Safety: None
  type role UnsafeEquality nominal nominal
  type UnsafeEquality :: forall {k}. k -> k -> *
  data UnsafeEquality a b where
    UnsafeRefl :: forall {k} (a :: k). UnsafeEquality a a
  unsafeCoerce :: forall a b. a -> b
  unsafeCoerce# :: forall (q :: GHC.Types.RuntimeRep) (r :: GHC.Types.RuntimeRep) (a :: TYPE q) (b :: TYPE r). a -> b
  unsafeCoerceAddr :: forall (a :: TYPE GHC.Types.AddrRep) (b :: TYPE GHC.Types.AddrRep). a -> b
  unsafeCoerceUnlifted :: forall (a :: GHC.Types.UnliftedType) (b :: GHC.Types.UnliftedType). a -> b
  unsafeEqualityProof :: forall {k} (a :: k) (b :: k). UnsafeEquality a b


-- Instances:
instance Control.Monad.IO.Class.MonadIO GHC.Types.IO -- Defined in ‘Control.Monad.IO.Class’
instance [safe] Control.Monad.Zip.MonadZip GHC.Internal.Data.Ord.Down -- Defined in ‘Control.Monad.Zip’
instance [safe] Control.Monad.Zip.MonadZip GHC.Internal.Data.Semigroup.Internal.Dual -- Defined in ‘Control.Monad.Zip’
instance [safe] Control.Monad.Zip.MonadZip GHC.Internal.Data.Monoid.First -- Defined in ‘Control.Monad.Zip’
instance [safe] Control.Monad.Zip.MonadZip GHC.Internal.Data.Functor.Identity.Identity -- Defined in ‘Control.Monad.Zip’
instance [safe] Control.Monad.Zip.MonadZip GHC.Internal.Data.Monoid.Last -- Defined in ‘Control.Monad.Zip’
instance [safe] Control.Monad.Zip.MonadZip [] -- Defined in ‘Control.Monad.Zip’
instance [safe] Control.Monad.Zip.MonadZip GHC.Internal.Maybe.Maybe -- Defined in ‘Control.Monad.Zip’
instance [safe] Control.Monad.Zip.MonadZip GHC.Internal.Base.NonEmpty -- Defined in ‘Control.Monad.Zip’
instance [safe] Control.Monad.Zip.MonadZip GHC.Internal.Generics.Par1 -- Defined in ‘Control.Monad.Zip’
instance [safe] Control.Monad.Zip.MonadZip GHC.Internal.Data.Semigroup.Internal.Product -- Defined in ‘Control.Monad.Zip’
instance [safe] Control.Monad.Zip.MonadZip Solo -- Defined in ‘Control.Monad.Zip’
instance [safe] Control.Monad.Zip.MonadZip GHC.Internal.Data.Semigroup.Internal.Sum -- Defined in ‘Control.Monad.Zip’
instance Control.Monad.Zip.MonadZip Data.Complex.Complex -- Defined in ‘Data.Complex’
instance [safe] Data.Bifoldable.Bifoldable GHC.Internal.Data.Either.Either -- Defined in ‘Data.Bifoldable’
instance [safe] Data.Bifoldable.Bifoldable (,) -- Defined in ‘Data.Bifoldable’
instance [safe] forall x. Data.Bifoldable.Bifoldable ((,,) x) -- Defined in ‘Data.Bifoldable’
instance [safe] forall x y. Data.Bifoldable.Bifoldable ((,,,) x y) -- Defined in ‘Data.Bifoldable’
instance [safe] forall x y z. Data.Bifoldable.Bifoldable ((,,,,) x y z) -- Defined in ‘Data.Bifoldable’
instance [safe] forall x y z w. Data.Bifoldable.Bifoldable ((,,,,,) x y z w) -- Defined in ‘Data.Bifoldable’
instance [safe] forall x y z w v. Data.Bifoldable.Bifoldable ((,,,,,,) x y z w v) -- Defined in ‘Data.Bifoldable’
instance Data.Bifoldable.Bifoldable Data.Semigroup.Arg -- Defined in ‘Data.Semigroup’
instance [safe] Data.Bifoldable1.Bifoldable1 Data.Semigroup.Arg -- Defined in ‘Data.Bifoldable1’
instance [safe] Data.Bifoldable1.Bifoldable1 GHC.Internal.Data.Either.Either -- Defined in ‘Data.Bifoldable1’
instance [safe] Data.Bifoldable1.Bifoldable1 (,) -- Defined in ‘Data.Bifoldable1’
instance [safe] forall x. Data.Bifoldable1.Bifoldable1 ((,,) x) -- Defined in ‘Data.Bifoldable1’
instance [safe] forall x y. Data.Bifoldable1.Bifoldable1 ((,,,) x y) -- Defined in ‘Data.Bifoldable1’
instance [safe] forall x y z. Data.Bifoldable1.Bifoldable1 ((,,,,) x y z) -- Defined in ‘Data.Bifoldable1’
instance [safe] Data.Bifunctor.Bifunctor GHC.Internal.Data.Either.Either -- Defined in ‘Data.Bifunctor’
instance [safe] Data.Bifunctor.Bifunctor (,) -- Defined in ‘Data.Bifunctor’
instance [safe] forall x1. Data.Bifunctor.Bifunctor ((,,) x1) -- Defined in ‘Data.Bifunctor’
instance [safe] forall x1 x2. Data.Bifunctor.Bifunctor ((,,,) x1 x2) -- Defined in ‘Data.Bifunctor’
instance [safe] forall x1 x2 x3. Data.Bifunctor.Bifunctor ((,,,,) x1 x2 x3) -- Defined in ‘Data.Bifunctor’
instance [safe] forall x1 x2 x3 x4. Data.Bifunctor.Bifunctor ((,,,,,) x1 x2 x3 x4) -- Defined in ‘Data.Bifunctor’
instance [safe] forall x1 x2 x3 x4 x5. Data.Bifunctor.Bifunctor ((,,,,,,) x1 x2 x3 x4 x5) -- Defined in ‘Data.Bifunctor’
instance Data.Bifunctor.Bifunctor Data.Semigroup.Arg -- Defined in ‘Data.Semigroup’
instance Data.Bitraversable.Bitraversable GHC.Internal.Data.Either.Either -- Defined in ‘Data.Bitraversable’
instance Data.Bitraversable.Bitraversable (,) -- Defined in ‘Data.Bitraversable’
instance forall x. Data.Bitraversable.Bitraversable ((,,) x) -- Defined in ‘Data.Bitraversable’
instance forall x y. Data.Bitraversable.Bitraversable ((,,,) x y) -- Defined in ‘Data.Bitraversable’
instance forall x y z. Data.Bitraversable.Bitraversable ((,,,,) x y z) -- Defined in ‘Data.Bitraversable’
instance forall x y z w. Data.Bitraversable.Bitraversable ((,,,,,) x y z w) -- Defined in ‘Data.Bitraversable’
instance forall x y z w v. Data.Bitraversable.Bitraversable ((,,,,,,) x y z w v) -- Defined in ‘Data.Bitraversable’
instance Data.Bitraversable.Bitraversable Data.Semigroup.Arg -- Defined in ‘Data.Semigroup’
instance forall (n :: GHC.Internal.TypeNats.Nat). GHC.Internal.TypeNats.KnownNat n => Data.Fixed.HasResolution n -- Defined in ‘Data.Fixed’
instance Data.Foldable1.Foldable1 Data.Complex.Complex -- Defined in ‘Data.Foldable1’
instance Data.Foldable1.Foldable1 GHC.Internal.Data.Ord.Down -- Defined in ‘Data.Foldable1’
instance Data.Foldable1.Foldable1 GHC.Internal.Data.Semigroup.Internal.Dual -- Defined in ‘Data.Foldable1’
instance Data.Foldable1.Foldable1 Data.Semigroup.First -- Defined in ‘Data.Foldable1’
instance Data.Foldable1.Foldable1 GHC.Internal.Data.Functor.Identity.Identity -- Defined in ‘Data.Foldable1’
instance Data.Foldable1.Foldable1 Data.Semigroup.Last -- Defined in ‘Data.Foldable1’
instance Data.Foldable1.Foldable1 Data.Semigroup.Max -- Defined in ‘Data.Foldable1’
instance Data.Foldable1.Foldable1 Data.Semigroup.Min -- Defined in ‘Data.Foldable1’
instance Data.Foldable1.Foldable1 GHC.Internal.Base.NonEmpty -- Defined in ‘Data.Foldable1’
instance Data.Foldable1.Foldable1 GHC.Internal.Generics.Par1 -- Defined in ‘Data.Foldable1’
instance Data.Foldable1.Foldable1 GHC.Internal.Data.Semigroup.Internal.Product -- Defined in ‘Data.Foldable1’
instance Data.Foldable1.Foldable1 Solo -- Defined in ‘Data.Foldable1’
instance Data.Foldable1.Foldable1 GHC.Internal.Data.Semigroup.Internal.Sum -- Defined in ‘Data.Foldable1’
instance forall a. Data.Foldable1.Foldable1 ((,) a) -- Defined in ‘Data.Foldable1’
instance [safe] Data.Functor.Classes.Eq1 Data.Complex.Complex -- Defined in ‘Data.Functor.Classes’
instance [safe] Data.Functor.Classes.Eq1 GHC.Internal.Data.Ord.Down -- Defined in ‘Data.Functor.Classes’
instance [safe] forall a. GHC.Classes.Eq a => Data.Functor.Classes.Eq1 (GHC.Internal.Data.Either.Either a) -- Defined in ‘Data.Functor.Classes’
instance [safe] Data.Functor.Classes.Eq1 GHC.Internal.Data.Functor.Identity.Identity -- Defined in ‘Data.Functor.Classes’
instance [safe] Data.Functor.Classes.Eq1 [] -- Defined in ‘Data.Functor.Classes’
instance [safe] Data.Functor.Classes.Eq1 GHC.Internal.Maybe.Maybe -- Defined in ‘Data.Functor.Classes’
instance [safe] Data.Functor.Classes.Eq1 GHC.Internal.Base.NonEmpty -- Defined in ‘Data.Functor.Classes’
instance [safe] Data.Functor.Classes.Eq1 Solo -- Defined in ‘Data.Functor.Classes’
instance [safe] forall a. GHC.Classes.Eq a => Data.Functor.Classes.Eq1 ((,) a) -- Defined in ‘Data.Functor.Classes’
instance [safe] forall a b. (GHC.Classes.Eq a, GHC.Classes.Eq b) => Data.Functor.Classes.Eq1 ((,,) a b) -- Defined in ‘Data.Functor.Classes’
instance [safe] forall a b c. (GHC.Classes.Eq a, GHC.Classes.Eq b, GHC.Classes.Eq c) => Data.Functor.Classes.Eq1 ((,,,) a b c) -- Defined in ‘Data.Functor.Classes’
instance [safe] Data.Functor.Classes.Eq2 GHC.Internal.Data.Either.Either -- Defined in ‘Data.Functor.Classes’
instance [safe] Data.Functor.Classes.Eq2 (,) -- Defined in ‘Data.Functor.Classes’
instance [safe] forall a. GHC.Classes.Eq a => Data.Functor.Classes.Eq2 ((,,) a) -- Defined in ‘Data.Functor.Classes’
instance [safe] forall a b. (GHC.Classes.Eq a, GHC.Classes.Eq b) => Data.Functor.Classes.Eq2 ((,,,) a b) -- Defined in ‘Data.Functor.Classes’
instance [safe] Data.Functor.Classes.Ord1 GHC.Internal.Data.Ord.Down -- Defined in ‘Data.Functor.Classes’
instance [safe] forall a. GHC.Classes.Ord a => Data.Functor.Classes.Ord1 (GHC.Internal.Data.Either.Either a) -- Defined in ‘Data.Functor.Classes’
instance [safe] Data.Functor.Classes.Ord1 GHC.Internal.Data.Functor.Identity.Identity -- Defined in ‘Data.Functor.Classes’
instance [safe] Data.Functor.Classes.Ord1 [] -- Defined in ‘Data.Functor.Classes’
instance [safe] Data.Functor.Classes.Ord1 GHC.Internal.Maybe.Maybe -- Defined in ‘Data.Functor.Classes’
instance [safe] Data.Functor.Classes.Ord1 GHC.Internal.Base.NonEmpty -- Defined in ‘Data.Functor.Classes’
instance [safe] Data.Functor.Classes.Ord1 Solo -- Defined in ‘Data.Functor.Classes’
instance [safe] forall a. GHC.Classes.Ord a => Data.Functor.Classes.Ord1 ((,) a) -- Defined in ‘Data.Functor.Classes’
instance [safe] forall a b. (GHC.Classes.Ord a, GHC.Classes.Ord b) => Data.Functor.Classes.Ord1 ((,,) a b) -- Defined in ‘Data.Functor.Classes’
instance [safe] forall a b c. (GHC.Classes.Ord a, GHC.Classes.Ord b, GHC.Classes.Ord c) => Data.Functor.Classes.Ord1 ((,,,) a b c) -- Defined in ‘Data.Functor.Classes’
instance [safe] Data.Functor.Classes.Ord2 GHC.Internal.Data.Either.Either -- Defined in ‘Data.Functor.Classes’
instance [safe] Data.Functor.Classes.Ord2 (,) -- Defined in ‘Data.Functor.Classes’
instance [safe] forall a. GHC.Classes.Ord a => Data.Functor.Classes.Ord2 ((,,) a) -- Defined in ‘Data.Functor.Classes’
instance [safe] forall a b. (GHC.Classes.Ord a, GHC.Classes.Ord b) => Data.Functor.Classes.Ord2 ((,,,) a b) -- Defined in ‘Data.Functor.Classes’
instance [safe] Data.Functor.Classes.Read1 Data.Complex.Complex -- Defined in ‘Data.Functor.Classes’
instance [safe] Data.Functor.Classes.Read1 GHC.Internal.Data.Ord.Down -- Defined in ‘Data.Functor.Classes’
instance [safe] forall a. GHC.Internal.Read.Read a => Data.Functor.Classes.Read1 (GHC.Internal.Data.Either.Either a) -- Defined in ‘Data.Functor.Classes’
instance [safe] Data.Functor.Classes.Read1 GHC.Internal.Data.Functor.Identity.Identity -- Defined in ‘Data.Functor.Classes’
instance [safe] Data.Functor.Classes.Read1 [] -- Defined in ‘Data.Functor.Classes’
instance [safe] Data.Functor.Classes.Read1 GHC.Internal.Maybe.Maybe -- Defined in ‘Data.Functor.Classes’
instance [safe] Data.Functor.Classes.Read1 GHC.Internal.Base.NonEmpty -- Defined in ‘Data.Functor.Classes’
instance [safe] Data.Functor.Classes.Read1 Solo -- Defined in ‘Data.Functor.Classes’
instance [safe] forall a. GHC.Internal.Read.Read a => Data.Functor.Classes.Read1 ((,) a) -- Defined in ‘Data.Functor.Classes’
instance [safe] forall a b. (GHC.Internal.Read.Read a, GHC.Internal.Read.Read b) => Data.Functor.Classes.Read1 ((,,) a b) -- Defined in ‘Data.Functor.Classes’
instance [safe] forall a b c. (GHC.Internal.Read.Read a, GHC.Internal.Read.Read b, GHC.Internal.Read.Read c) => Data.Functor.Classes.Read1 ((,,,) a b c) -- Defined in ‘Data.Functor.Classes’
instance [safe] Data.Functor.Classes.Read2 GHC.Internal.Data.Either.Either -- Defined in ‘Data.Functor.Classes’
instance [safe] Data.Functor.Classes.Read2 (,) -- Defined in ‘Data.Functor.Classes’
instance [safe] forall a. GHC.Internal.Read.Read a => Data.Functor.Classes.Read2 ((,,) a) -- Defined in ‘Data.Functor.Classes’
instance [safe] forall a b. (GHC.Internal.Read.Read a, GHC.Internal.Read.Read b) => Data.Functor.Classes.Read2 ((,,,) a b) -- Defined in ‘Data.Functor.Classes’
instance [safe] Data.Functor.Classes.Show1 Data.Complex.Complex -- Defined in ‘Data.Functor.Classes’
instance [safe] Data.Functor.Classes.Show1 GHC.Internal.Data.Ord.Down -- Defined in ‘Data.Functor.Classes’
instance [safe] forall a. GHC.Internal.Show.Show a => Data.Functor.Classes.Show1 (GHC.Internal.Data.Either.Either a) -- Defined in ‘Data.Functor.Classes’
instance [safe] Data.Functor.Classes.Show1 GHC.Internal.Data.Functor.Identity.Identity -- Defined in ‘Data.Functor.Classes’
instance [safe] Data.Functor.Classes.Show1 [] -- Defined in ‘Data.Functor.Classes’
instance [safe] Data.Functor.Classes.Show1 GHC.Internal.Maybe.Maybe -- Defined in ‘Data.Functor.Classes’
instance [safe] Data.Functor.Classes.Show1 GHC.Internal.Base.NonEmpty -- Defined in ‘Data.Functor.Classes’
instance [safe] Data.Functor.Classes.Show1 Solo -- Defined in ‘Data.Functor.Classes’
instance [safe] forall a. GHC.Internal.Show.Show a => Data.Functor.Classes.Show1 ((,) a) -- Defined in ‘Data.Functor.Classes’
instance [safe] forall a b. (GHC.Internal.Show.Show a, GHC.Internal.Show.Show b) => Data.Functor.Classes.Show1 ((,,) a b) -- Defined in ‘Data.Functor.Classes’
instance [safe] forall a b c. (GHC.Internal.Show.Show a, GHC.Internal.Show.Show b, GHC.Internal.Show.Show c) => Data.Functor.Classes.Show1 ((,,,) a b c) -- Defined in ‘Data.Functor.Classes’
instance [safe] Data.Functor.Classes.Show2 GHC.Internal.Data.Either.Either -- Defined in ‘Data.Functor.Classes’
instance [safe] Data.Functor.Classes.Show2 (,) -- Defined in ‘Data.Functor.Classes’
instance [safe] forall a. GHC.Internal.Show.Show a => Data.Functor.Classes.Show2 ((,,) a) -- Defined in ‘Data.Functor.Classes’
instance [safe] forall a b. (GHC.Internal.Show.Show a, GHC.Internal.Show.Show b) => Data.Functor.Classes.Show2 ((,,,) a b) -- Defined in ‘Data.Functor.Classes’
instance Data.Functor.Contravariant.Contravariant Data.Functor.Contravariant.Comparison -- Defined in ‘Data.Functor.Contravariant’
instance Data.Functor.Contravariant.Contravariant Data.Functor.Contravariant.Equivalence -- Defined in ‘Data.Functor.Contravariant’
instance forall a. Data.Functor.Contravariant.Contravariant (Data.Functor.Contravariant.Op a) -- Defined in ‘Data.Functor.Contravariant’
instance Data.Functor.Contravariant.Contravariant Data.Functor.Contravariant.Predicate -- Defined in ‘Data.Functor.Contravariant’
instance [safe] forall a. (a ~ ()) => Text.Printf.HPrintfType (GHC.Types.IO a) -- Defined in ‘Text.Printf’
instance [safe] Text.Printf.IsChar GHC.Types.Char -- Defined in ‘Text.Printf’
instance [safe] Text.Printf.PrintfArg GHC.Types.Char -- Defined in ‘Text.Printf’
instance [safe] Text.Printf.PrintfArg GHC.Types.Double -- Defined in ‘Text.Printf’
instance [safe] Text.Printf.PrintfArg GHC.Types.Float -- Defined in ‘Text.Printf’
instance [safe] Text.Printf.PrintfArg GHC.Types.Int -- Defined in ‘Text.Printf’
instance [safe] Text.Printf.PrintfArg GHC.Internal.Int.Int16 -- Defined in ‘Text.Printf’
instance [safe] Text.Printf.PrintfArg GHC.Internal.Int.Int32 -- Defined in ‘Text.Printf’
instance [safe] Text.Printf.PrintfArg GHC.Internal.Int.Int64 -- Defined in ‘Text.Printf’
instance [safe] Text.Printf.PrintfArg GHC.Internal.Int.Int8 -- Defined in ‘Text.Printf’
instance [safe] Text.Printf.PrintfArg GHC.Num.Integer.Integer -- Defined in ‘Text.Printf’
instance [safe] forall c. Text.Printf.IsChar c => Text.Printf.PrintfArg [c] -- Defined in ‘Text.Printf’
instance [safe] Text.Printf.PrintfArg GHC.Num.Natural.Natural -- Defined in ‘Text.Printf’
instance [safe] Text.Printf.PrintfArg GHC.Types.Word -- Defined in ‘Text.Printf’
instance [safe] Text.Printf.PrintfArg GHC.Internal.Word.Word16 -- Defined in ‘Text.Printf’
instance [safe] Text.Printf.PrintfArg GHC.Internal.Word.Word32 -- Defined in ‘Text.Printf’
instance [safe] Text.Printf.PrintfArg GHC.Internal.Word.Word64 -- Defined in ‘Text.Printf’
instance [safe] Text.Printf.PrintfArg GHC.Internal.Word.Word8 -- Defined in ‘Text.Printf’
instance [safe] forall a. (a ~ ()) => Text.Printf.PrintfType (GHC.Types.IO a) -- Defined in ‘Text.Printf’
instance [safe] forall c. Text.Printf.IsChar c => Text.Printf.PrintfType [c] -- Defined in ‘Text.Printf’
instance forall (a :: * -> * -> *) b. (GHC.Internal.Control.Arrow.ArrowZero a, GHC.Internal.Control.Arrow.ArrowPlus a) => GHC.Internal.Base.Alternative (Control.Applicative.WrappedArrow a b) -- Defined in ‘Control.Applicative’
instance forall (m :: * -> *). GHC.Internal.Base.MonadPlus m => GHC.Internal.Base.Alternative (Control.Applicative.WrappedMonad m) -- Defined in ‘Control.Applicative’
instance GHC.Internal.Base.Alternative GHC.Types.IO -- Defined in ‘GHC.Internal.Base’
instance GHC.Internal.Base.Alternative [] -- Defined in ‘GHC.Internal.Base’
instance GHC.Internal.Base.Alternative GHC.Internal.Maybe.Maybe -- Defined in ‘GHC.Internal.Base’
instance GHC.Internal.Base.Alternative GHC.Internal.Functor.ZipList.ZipList -- Defined in ‘GHC.Internal.Functor.ZipList’
instance forall (a :: * -> * -> *). GHC.Internal.Control.Arrow.ArrowPlus a => GHC.Internal.Base.Alternative (GHC.Internal.Control.Arrow.ArrowMonad a) -- Defined in ‘GHC.Internal.Control.Arrow’
instance forall (m :: * -> *) a. GHC.Internal.Base.Alternative m => GHC.Internal.Base.Alternative (GHC.Internal.Control.Arrow.Kleisli m a) -- Defined in ‘GHC.Internal.Control.Arrow’
instance GHC.Internal.Base.Alternative GHC.Internal.Conc.Sync.STM -- Defined in ‘GHC.Internal.Conc.Sync’
instance GHC.Internal.Base.Alternative GHC.Internal.Text.ParserCombinators.ReadP.P -- Defined in ‘GHC.Internal.Text.ParserCombinators.ReadP’
instance GHC.Internal.Base.Alternative GHC.Internal.Text.ParserCombinators.ReadP.ReadP -- Defined in ‘GHC.Internal.Text.ParserCombinators.ReadP’
instance GHC.Internal.Base.Alternative GHC.Internal.Text.ParserCombinators.ReadPrec.ReadPrec -- Defined in ‘GHC.Internal.Text.ParserCombinators.ReadPrec’
instance forall (a :: * -> * -> *) b. GHC.Internal.Control.Arrow.Arrow a => GHC.Internal.Base.Applicative (Control.Applicative.WrappedArrow a b) -- Defined in ‘Control.Applicative’
instance forall (m :: * -> *). GHC.Internal.Base.Monad m => GHC.Internal.Base.Applicative (Control.Applicative.WrappedMonad m) -- Defined in ‘Control.Applicative’
instance GHC.Internal.Base.Applicative GHC.Types.IO -- Defined in ‘GHC.Internal.Base’
instance GHC.Internal.Base.Applicative [] -- Defined in ‘GHC.Internal.Base’
instance GHC.Internal.Base.Applicative GHC.Internal.Maybe.Maybe -- Defined in ‘GHC.Internal.Base’
instance GHC.Internal.Base.Applicative GHC.Internal.Base.NonEmpty -- Defined in ‘GHC.Internal.Base’
instance GHC.Internal.Base.Applicative Solo -- Defined in ‘GHC.Internal.Base’
instance forall a. GHC.Internal.Base.Monoid a => GHC.Internal.Base.Applicative ((,) a) -- Defined in ‘GHC.Internal.Base’
instance forall a b. (GHC.Internal.Base.Monoid a, GHC.Internal.Base.Monoid b) => GHC.Internal.Base.Applicative ((,,) a b) -- Defined in ‘GHC.Internal.Base’
instance forall a b c. (GHC.Internal.Base.Monoid a, GHC.Internal.Base.Monoid b, GHC.Internal.Base.Monoid c) => GHC.Internal.Base.Applicative ((,,,) a b c) -- Defined in ‘GHC.Internal.Base’
instance GHC.Internal.Base.Applicative GHC.Internal.Functor.ZipList.ZipList -- Defined in ‘GHC.Internal.Functor.ZipList’
instance forall (a :: * -> * -> *). GHC.Internal.Control.Arrow.Arrow a => GHC.Internal.Base.Applicative (GHC.Internal.Control.Arrow.ArrowMonad a) -- Defined in ‘GHC.Internal.Control.Arrow’
instance forall (m :: * -> *) a. GHC.Internal.Base.Applicative m => GHC.Internal.Base.Applicative (GHC.Internal.Control.Arrow.Kleisli m a) -- Defined in ‘GHC.Internal.Control.Arrow’
instance GHC.Internal.Base.Applicative GHC.Internal.Conc.Sync.STM -- Defined in ‘GHC.Internal.Conc.Sync’
instance forall s. GHC.Internal.Base.Applicative (GHC.Internal.ST.ST s) -- Defined in ‘GHC.Internal.ST’
instance forall s. GHC.Internal.Base.Applicative (GHC.Internal.Control.Monad.ST.Lazy.Imp.ST s) -- Defined in ‘GHC.Internal.Control.Monad.ST.Lazy.Imp’
instance GHC.Internal.Base.Applicative Data.Complex.Complex -- Defined in ‘Data.Complex’
instance forall e. GHC.Internal.Base.Applicative (GHC.Internal.Data.Either.Either e) -- Defined in ‘GHC.Internal.Data.Either’
instance GHC.Internal.Base.Applicative GHC.Internal.Data.Functor.Identity.Identity -- Defined in ‘GHC.Internal.Data.Functor.Identity’
instance GHC.Internal.Base.Applicative GHC.Internal.Data.Semigroup.Internal.Dual -- Defined in ‘GHC.Internal.Data.Semigroup.Internal’
instance GHC.Internal.Base.Applicative GHC.Internal.Data.Semigroup.Internal.Product -- Defined in ‘GHC.Internal.Data.Semigroup.Internal’
instance GHC.Internal.Base.Applicative GHC.Internal.Data.Semigroup.Internal.Sum -- Defined in ‘GHC.Internal.Data.Semigroup.Internal’
instance GHC.Internal.Base.Applicative GHC.Internal.Data.Monoid.First -- Defined in ‘GHC.Internal.Data.Monoid’
instance GHC.Internal.Base.Applicative GHC.Internal.Data.Monoid.Last -- Defined in ‘GHC.Internal.Data.Monoid’
instance GHC.Internal.Base.Applicative GHC.Internal.Data.Ord.Down -- Defined in ‘GHC.Internal.Data.Ord’
instance GHC.Internal.Base.Applicative Data.Semigroup.First -- Defined in ‘Data.Semigroup’
instance GHC.Internal.Base.Applicative Data.Semigroup.Last -- Defined in ‘Data.Semigroup’
instance GHC.Internal.Base.Applicative Data.Semigroup.Max -- Defined in ‘Data.Semigroup’
instance GHC.Internal.Base.Applicative Data.Semigroup.Min -- Defined in ‘Data.Semigroup’
instance GHC.Internal.Base.Applicative GHC.Internal.GHCi.NoIO -- Defined in ‘GHC.Internal.GHCi’
instance GHC.Internal.Base.Applicative GHC.Internal.Generics.Par1 -- Defined in ‘GHC.Internal.Generics’
instance GHC.Internal.Base.Applicative GHC.Internal.Text.ParserCombinators.ReadP.P -- Defined in ‘GHC.Internal.Text.ParserCombinators.ReadP’
instance GHC.Internal.Base.Applicative GHC.Internal.Text.ParserCombinators.ReadP.ReadP -- Defined in ‘GHC.Internal.Text.ParserCombinators.ReadP’
instance GHC.Internal.Base.Applicative GHC.Internal.Text.ParserCombinators.ReadPrec.ReadPrec -- Defined in ‘GHC.Internal.Text.ParserCombinators.ReadPrec’
instance forall (a :: * -> * -> *) b. GHC.Internal.Control.Arrow.Arrow a => GHC.Internal.Base.Functor (Control.Applicative.WrappedArrow a b) -- Defined in ‘Control.Applicative’
instance forall (m :: * -> *). GHC.Internal.Base.Monad m => GHC.Internal.Base.Functor (Control.Applicative.WrappedMonad m) -- Defined in ‘Control.Applicative’
instance GHC.Internal.Base.Functor GHC.Types.IO -- Defined in ‘GHC.Internal.Base’
instance GHC.Internal.Base.Functor [] -- Defined in ‘GHC.Internal.Base’
instance GHC.Internal.Base.Functor GHC.Internal.Maybe.Maybe -- Defined in ‘GHC.Internal.Base’
instance GHC.Internal.Base.Functor GHC.Internal.Base.NonEmpty -- Defined in ‘GHC.Internal.Base’
instance GHC.Internal.Base.Functor Solo -- Defined in ‘GHC.Internal.Base’
instance forall a. GHC.Internal.Base.Functor ((,) a) -- Defined in ‘GHC.Internal.Base’
instance forall a b. GHC.Internal.Base.Functor ((,,) a b) -- Defined in ‘GHC.Internal.Base’
instance forall a b c. GHC.Internal.Base.Functor ((,,,) a b c) -- Defined in ‘GHC.Internal.Base’
instance forall a b c d. GHC.Internal.Base.Functor ((,,,,) a b c d) -- Defined in ‘GHC.Internal.Base’
instance forall a b c d e. GHC.Internal.Base.Functor ((,,,,,) a b c d e) -- Defined in ‘GHC.Internal.Base’
instance forall a b c d e f. GHC.Internal.Base.Functor ((,,,,,,) a b c d e f) -- Defined in ‘GHC.Internal.Base’
instance GHC.Internal.Base.Functor GHC.Internal.Functor.ZipList.ZipList -- Defined in ‘GHC.Internal.Functor.ZipList’
instance forall (a :: * -> * -> *). GHC.Internal.Control.Arrow.Arrow a => GHC.Internal.Base.Functor (GHC.Internal.Control.Arrow.ArrowMonad a) -- Defined in ‘GHC.Internal.Control.Arrow’
instance forall (m :: * -> *) a. GHC.Internal.Base.Functor m => GHC.Internal.Base.Functor (GHC.Internal.Control.Arrow.Kleisli m a) -- Defined in ‘GHC.Internal.Control.Arrow’
instance GHC.Internal.Base.Functor GHC.Internal.Conc.Sync.STM -- Defined in ‘GHC.Internal.Conc.Sync’
instance GHC.Internal.Base.Functor GHC.Internal.Control.Exception.Handler -- Defined in ‘GHC.Internal.Control.Exception’
instance forall s. GHC.Internal.Base.Functor (GHC.Internal.ST.ST s) -- Defined in ‘GHC.Internal.ST’
instance forall s. GHC.Internal.Base.Functor (GHC.Internal.Control.Monad.ST.Lazy.Imp.ST s) -- Defined in ‘GHC.Internal.Control.Monad.ST.Lazy.Imp’
instance GHC.Internal.Base.Functor Data.Complex.Complex -- Defined in ‘Data.Complex’
instance forall a. GHC.Internal.Base.Functor (GHC.Internal.Data.Either.Either a) -- Defined in ‘GHC.Internal.Data.Either’
instance GHC.Internal.Base.Functor GHC.Internal.Data.Functor.Identity.Identity -- Defined in ‘GHC.Internal.Data.Functor.Identity’
instance GHC.Internal.Base.Functor GHC.Internal.Data.Semigroup.Internal.Dual -- Defined in ‘GHC.Internal.Data.Semigroup.Internal’
instance GHC.Internal.Base.Functor GHC.Internal.Data.Semigroup.Internal.Product -- Defined in ‘GHC.Internal.Data.Semigroup.Internal’
instance GHC.Internal.Base.Functor GHC.Internal.Data.Semigroup.Internal.Sum -- Defined in ‘GHC.Internal.Data.Semigroup.Internal’
instance GHC.Internal.Base.Functor GHC.Internal.Data.Monoid.First -- Defined in ‘GHC.Internal.Data.Monoid’
instance GHC.Internal.Base.Functor GHC.Internal.Data.Monoid.Last -- Defined in ‘GHC.Internal.Data.Monoid’
instance GHC.Internal.Base.Functor GHC.Internal.Data.Ord.Down -- Defined in ‘GHC.Internal.Data.Ord’
instance forall a. GHC.Internal.Base.Functor (Data.Semigroup.Arg a) -- Defined in ‘Data.Semigroup’
instance GHC.Internal.Base.Functor Data.Semigroup.First -- Defined in ‘Data.Semigroup’
instance GHC.Internal.Base.Functor Data.Semigroup.Last -- Defined in ‘Data.Semigroup’
instance GHC.Internal.Base.Functor Data.Semigroup.Max -- Defined in ‘Data.Semigroup’
instance GHC.Internal.Base.Functor Data.Semigroup.Min -- Defined in ‘Data.Semigroup’
instance forall i. GHC.Internal.Base.Functor (GHC.Internal.Arr.Array i) -- Defined in ‘GHC.Internal.Arr’
instance GHC.Internal.Base.Functor GHC.Internal.GHCi.NoIO -- Defined in ‘GHC.Internal.GHCi’
instance GHC.Internal.Base.Functor GHC.Internal.Generics.Par1 -- Defined in ‘GHC.Internal.Generics’
instance GHC.Internal.Base.Functor GHC.Internal.Text.ParserCombinators.ReadP.P -- Defined in ‘GHC.Internal.Text.ParserCombinators.ReadP’
instance GHC.Internal.Base.Functor GHC.Internal.Text.ParserCombinators.ReadP.ReadP -- Defined in ‘GHC.Internal.Text.ParserCombinators.ReadP’
instance [safe] GHC.Internal.Base.Functor System.Console.GetOpt.ArgDescr -- Defined in ‘System.Console.GetOpt’
instance [safe] GHC.Internal.Base.Functor System.Console.GetOpt.ArgOrder -- Defined in ‘System.Console.GetOpt’
instance [safe] GHC.Internal.Base.Functor System.Console.GetOpt.OptDescr -- Defined in ‘System.Console.GetOpt’
instance GHC.Internal.Base.Functor GHC.Internal.Text.ParserCombinators.ReadPrec.ReadPrec -- Defined in ‘GHC.Internal.Text.ParserCombinators.ReadPrec’
instance forall (m :: * -> *). GHC.Internal.Base.Monad m => GHC.Internal.Base.Monad (Control.Applicative.WrappedMonad m) -- Defined in ‘Control.Applicative’
instance GHC.Internal.Base.Monad GHC.Types.IO -- Defined in ‘GHC.Internal.Base’
instance GHC.Internal.Base.Monad [] -- Defined in ‘GHC.Internal.Base’
instance GHC.Internal.Base.Monad GHC.Internal.Maybe.Maybe -- Defined in ‘GHC.Internal.Base’
instance GHC.Internal.Base.Monad GHC.Internal.Base.NonEmpty -- Defined in ‘GHC.Internal.Base’
instance GHC.Internal.Base.Monad Solo -- Defined in ‘GHC.Internal.Base’
instance forall a. GHC.Internal.Base.Monoid a => GHC.Internal.Base.Monad ((,) a) -- Defined in ‘GHC.Internal.Base’
instance forall a b. (GHC.Internal.Base.Monoid a, GHC.Internal.Base.Monoid b) => GHC.Internal.Base.Monad ((,,) a b) -- Defined in ‘GHC.Internal.Base’
instance forall a b c. (GHC.Internal.Base.Monoid a, GHC.Internal.Base.Monoid b, GHC.Internal.Base.Monoid c) => GHC.Internal.Base.Monad ((,,,) a b c) -- Defined in ‘GHC.Internal.Base’
instance forall (a :: * -> * -> *). GHC.Internal.Control.Arrow.ArrowApply a => GHC.Internal.Base.Monad (GHC.Internal.Control.Arrow.ArrowMonad a) -- Defined in ‘GHC.Internal.Control.Arrow’
instance forall (m :: * -> *) a. GHC.Internal.Base.Monad m => GHC.Internal.Base.Monad (GHC.Internal.Control.Arrow.Kleisli m a) -- Defined in ‘GHC.Internal.Control.Arrow’
instance GHC.Internal.Base.Monad GHC.Internal.Conc.Sync.STM -- Defined in ‘GHC.Internal.Conc.Sync’
instance forall s. GHC.Internal.Base.Monad (GHC.Internal.ST.ST s) -- Defined in ‘GHC.Internal.ST’
instance forall s. GHC.Internal.Base.Monad (GHC.Internal.Control.Monad.ST.Lazy.Imp.ST s) -- Defined in ‘GHC.Internal.Control.Monad.ST.Lazy.Imp’
instance GHC.Internal.Base.Monad Data.Complex.Complex -- Defined in ‘Data.Complex’
instance forall e. GHC.Internal.Base.Monad (GHC.Internal.Data.Either.Either e) -- Defined in ‘GHC.Internal.Data.Either’
instance GHC.Internal.Base.Monad GHC.Internal.Data.Functor.Identity.Identity -- Defined in ‘GHC.Internal.Data.Functor.Identity’
instance GHC.Internal.Base.Monad GHC.Internal.Data.Semigroup.Internal.Dual -- Defined in ‘GHC.Internal.Data.Semigroup.Internal’
instance GHC.Internal.Base.Monad GHC.Internal.Data.Semigroup.Internal.Product -- Defined in ‘GHC.Internal.Data.Semigroup.Internal’
instance GHC.Internal.Base.Monad GHC.Internal.Data.Semigroup.Internal.Sum -- Defined in ‘GHC.Internal.Data.Semigroup.Internal’
instance GHC.Internal.Base.Monad GHC.Internal.Data.Monoid.First -- Defined in ‘GHC.Internal.Data.Monoid’
instance GHC.Internal.Base.Monad GHC.Internal.Data.Monoid.Last -- Defined in ‘GHC.Internal.Data.Monoid’
instance GHC.Internal.Base.Monad GHC.Internal.Data.Ord.Down -- Defined in ‘GHC.Internal.Data.Ord’
instance GHC.Internal.Base.Monad Data.Semigroup.First -- Defined in ‘Data.Semigroup’
instance GHC.Internal.Base.Monad Data.Semigroup.Last -- Defined in ‘Data.Semigroup’
instance GHC.Internal.Base.Monad Data.Semigroup.Max -- Defined in ‘Data.Semigroup’
instance GHC.Internal.Base.Monad Data.Semigroup.Min -- Defined in ‘Data.Semigroup’
instance GHC.Internal.Base.Monad GHC.Internal.GHCi.NoIO -- Defined in ‘GHC.Internal.GHCi’
instance GHC.Internal.Base.Monad GHC.Internal.Generics.Par1 -- Defined in ‘GHC.Internal.Generics’
instance GHC.Internal.Base.Monad GHC.Internal.Text.ParserCombinators.ReadP.P -- Defined in ‘GHC.Internal.Text.ParserCombinators.ReadP’
instance GHC.Internal.Base.Monad GHC.Internal.Text.ParserCombinators.ReadP.ReadP -- Defined in ‘GHC.Internal.Text.ParserCombinators.ReadP’
instance GHC.Internal.Base.Monad GHC.Internal.Text.ParserCombinators.ReadPrec.ReadPrec -- Defined in ‘GHC.Internal.Text.ParserCombinators.ReadPrec’
instance GHC.Internal.Base.MonadPlus GHC.Types.IO -- Defined in ‘GHC.Internal.Base’
instance GHC.Internal.Base.MonadPlus [] -- Defined in ‘GHC.Internal.Base’
instance GHC.Internal.Base.MonadPlus GHC.Internal.Maybe.Maybe -- Defined in ‘GHC.Internal.Base’
instance forall (a :: * -> * -> *). (GHC.Internal.Control.Arrow.ArrowApply a, GHC.Internal.Control.Arrow.ArrowPlus a) => GHC.Internal.Base.MonadPlus (GHC.Internal.Control.Arrow.ArrowMonad a) -- Defined in ‘GHC.Internal.Control.Arrow’
instance forall (m :: * -> *) a. GHC.Internal.Base.MonadPlus m => GHC.Internal.Base.MonadPlus (GHC.Internal.Control.Arrow.Kleisli m a) -- Defined in ‘GHC.Internal.Control.Arrow’
instance GHC.Internal.Base.MonadPlus GHC.Internal.Conc.Sync.STM -- Defined in ‘GHC.Internal.Conc.Sync’
instance GHC.Internal.Base.MonadPlus GHC.Internal.Text.ParserCombinators.ReadP.P -- Defined in ‘GHC.Internal.Text.ParserCombinators.ReadP’
instance GHC.Internal.Base.MonadPlus GHC.Internal.Text.ParserCombinators.ReadP.ReadP -- Defined in ‘GHC.Internal.Text.ParserCombinators.ReadP’
instance GHC.Internal.Base.MonadPlus GHC.Internal.Text.ParserCombinators.ReadPrec.ReadPrec -- Defined in ‘GHC.Internal.Text.ParserCombinators.ReadPrec’
instance forall a. GHC.Internal.Base.Monoid a => GHC.Internal.Base.Monoid (GHC.Types.IO a) -- Defined in ‘GHC.Internal.Base’
instance forall a. GHC.Internal.Base.Monoid [a] -- Defined in ‘GHC.Internal.Base’
instance forall a. GHC.Internal.Base.Semigroup a => GHC.Internal.Base.Monoid (GHC.Internal.Maybe.Maybe a) -- Defined in ‘GHC.Internal.Base’
instance GHC.Internal.Base.Monoid GHC.Types.Ordering -- Defined in ‘GHC.Internal.Base’
instance forall a. GHC.Internal.Base.Monoid a => GHC.Internal.Base.Monoid (Solo a) -- Defined in ‘GHC.Internal.Base’
instance forall a b. (GHC.Internal.Base.Monoid a, GHC.Internal.Base.Monoid b) => GHC.Internal.Base.Monoid (a, b) -- Defined in ‘GHC.Internal.Base’
instance forall a b c. (GHC.Internal.Base.Monoid a, GHC.Internal.Base.Monoid b, GHC.Internal.Base.Monoid c) => GHC.Internal.Base.Monoid (a, b, c) -- Defined in ‘GHC.Internal.Base’
instance forall a b c d. (GHC.Internal.Base.Monoid a, GHC.Internal.Base.Monoid b, GHC.Internal.Base.Monoid c, GHC.Internal.Base.Monoid d) => GHC.Internal.Base.Monoid (a, b, c, d) -- Defined in ‘GHC.Internal.Base’
instance forall a b c d e. (GHC.Internal.Base.Monoid a, GHC.Internal.Base.Monoid b, GHC.Internal.Base.Monoid c, GHC.Internal.Base.Monoid d, GHC.Internal.Base.Monoid e) => GHC.Internal.Base.Monoid (a, b, c, d, e) -- Defined in ‘GHC.Internal.Base’
instance GHC.Internal.Base.Monoid () -- Defined in ‘GHC.Internal.Base’
instance forall a k (b :: k). GHC.Internal.Base.Monoid a => GHC.Internal.Base.Monoid (GHC.Internal.Data.Functor.Const.Const a b) -- Defined in ‘GHC.Internal.Data.Functor.Const’
instance forall a. GHC.Internal.Base.Monoid a => GHC.Internal.Base.Monoid (GHC.Internal.Conc.Sync.STM a) -- Defined in ‘GHC.Internal.Conc.Sync’
instance GHC.Internal.Base.Monoid GHC.Internal.Exception.Context.ExceptionContext -- Defined in ‘GHC.Internal.Exception.Context’
instance forall a s. GHC.Internal.Base.Monoid a => GHC.Internal.Base.Monoid (GHC.Internal.ST.ST s a) -- Defined in ‘GHC.Internal.ST’
instance GHC.Internal.Base.Monoid Data.Array.Byte.ByteArray -- Defined in ‘Data.Array.Byte’
instance forall a. GHC.Internal.Bits.FiniteBits a => GHC.Internal.Base.Monoid (GHC.Internal.Data.Bits.And a) -- Defined in ‘GHC.Internal.Data.Bits’
instance forall a. GHC.Internal.Bits.FiniteBits a => GHC.Internal.Base.Monoid (GHC.Internal.Data.Bits.Iff a) -- Defined in ‘GHC.Internal.Data.Bits’
instance forall a. GHC.Internal.Bits.Bits a => GHC.Internal.Base.Monoid (GHC.Internal.Data.Bits.Ior a) -- Defined in ‘GHC.Internal.Data.Bits’
instance forall a. GHC.Internal.Bits.Bits a => GHC.Internal.Base.Monoid (GHC.Internal.Data.Bits.Xor a) -- Defined in ‘GHC.Internal.Data.Bits’
instance forall k (s :: k). GHC.Internal.Base.Monoid (GHC.Internal.Data.Proxy.Proxy s) -- Defined in ‘GHC.Internal.Data.Proxy’
instance forall k1 (f :: k1 -> *) k2 (g :: k2 -> k1) (a :: k2). GHC.Internal.Base.Monoid (f (g a)) => GHC.Internal.Base.Monoid (Data.Functor.Compose.Compose f g a) -- Defined in ‘Data.Functor.Compose’
instance forall a. GHC.Internal.Base.Monoid (Data.Functor.Contravariant.Comparison a) -- Defined in ‘Data.Functor.Contravariant’
instance forall a. GHC.Internal.Base.Monoid (Data.Functor.Contravariant.Equivalence a) -- Defined in ‘Data.Functor.Contravariant’
instance forall a b. GHC.Internal.Base.Monoid a => GHC.Internal.Base.Monoid (Data.Functor.Contravariant.Op a b) -- Defined in ‘Data.Functor.Contravariant’
instance forall a. GHC.Internal.Base.Monoid (Data.Functor.Contravariant.Predicate a) -- Defined in ‘Data.Functor.Contravariant’
instance forall a. GHC.Internal.Base.Monoid a => GHC.Internal.Base.Monoid (GHC.Internal.Data.Functor.Identity.Identity a) -- Defined in ‘GHC.Internal.Data.Functor.Identity’
instance [safe] forall k (f :: k -> *) (a :: k) (g :: k -> *). (GHC.Internal.Base.Monoid (f a), GHC.Internal.Base.Monoid (g a)) => GHC.Internal.Base.Monoid (Data.Functor.Product.Product f g a) -- Defined in ‘Data.Functor.Product’
instance GHC.Internal.Base.Monoid GHC.Internal.Data.Semigroup.Internal.All -- Defined in ‘GHC.Internal.Data.Semigroup.Internal’
instance GHC.Internal.Base.Monoid GHC.Internal.Data.Semigroup.Internal.Any -- Defined in ‘GHC.Internal.Data.Semigroup.Internal’
instance forall a. GHC.Internal.Base.Monoid a => GHC.Internal.Base.Monoid (GHC.Internal.Data.Semigroup.Internal.Dual a) -- Defined in ‘GHC.Internal.Data.Semigroup.Internal’
instance forall a. GHC.Internal.Base.Monoid (GHC.Internal.Data.Semigroup.Internal.Endo a) -- Defined in ‘GHC.Internal.Data.Semigroup.Internal’
instance forall a. GHC.Internal.Num.Num a => GHC.Internal.Base.Monoid (GHC.Internal.Data.Semigroup.Internal.Product a) -- Defined in ‘GHC.Internal.Data.Semigroup.Internal’
instance forall a. GHC.Internal.Num.Num a => GHC.Internal.Base.Monoid (GHC.Internal.Data.Semigroup.Internal.Sum a) -- Defined in ‘GHC.Internal.Data.Semigroup.Internal’
instance forall a. GHC.Internal.Base.Monoid (GHC.Internal.Data.Monoid.First a) -- Defined in ‘GHC.Internal.Data.Monoid’
instance forall a. GHC.Internal.Base.Monoid (GHC.Internal.Data.Monoid.Last a) -- Defined in ‘GHC.Internal.Data.Monoid’
instance forall a. GHC.Internal.Base.Monoid a => GHC.Internal.Base.Monoid (GHC.Internal.Data.Ord.Down a) -- Defined in ‘GHC.Internal.Data.Ord’
instance forall a. (GHC.Classes.Ord a, GHC.Internal.Enum.Bounded a) => GHC.Internal.Base.Monoid (Data.Semigroup.Max a) -- Defined in ‘Data.Semigroup’
instance forall a. (GHC.Classes.Ord a, GHC.Internal.Enum.Bounded a) => GHC.Internal.Base.Monoid (Data.Semigroup.Min a) -- Defined in ‘Data.Semigroup’
instance forall m. GHC.Internal.Base.Monoid m => GHC.Internal.Base.Monoid (Data.Semigroup.WrappedMonoid m) -- Defined in ‘Data.Semigroup’
instance GHC.Internal.Base.Monoid ghc-internal-0.1.0.0:GHC.Internal.Event.Internal.Types.Event -- Defined in ‘ghc-internal-0.1.0.0:GHC.Internal.Event.Internal.Types’
instance GHC.Internal.Base.Monoid ghc-internal-0.1.0.0:GHC.Internal.Event.Internal.Types.EventLifetime -- Defined in ‘ghc-internal-0.1.0.0:GHC.Internal.Event.Internal.Types’
instance GHC.Internal.Base.Monoid ghc-internal-0.1.0.0:GHC.Internal.Event.Internal.Types.Lifetime -- Defined in ‘ghc-internal-0.1.0.0:GHC.Internal.Event.Internal.Types’
instance forall k (f :: k -> *) (p :: k) (g :: k -> *). (GHC.Internal.Base.Monoid (f p), GHC.Internal.Base.Monoid (g p)) => GHC.Internal.Base.Monoid ((GHC.Internal.Generics.:*:) f g p) -- Defined in ‘GHC.Internal.Generics’
instance forall k2 k1 (f :: k2 -> *) (g :: k1 -> k2) (p :: k1). GHC.Internal.Base.Monoid (f (g p)) => GHC.Internal.Base.Monoid ((GHC.Internal.Generics.:.:) f g p) -- Defined in ‘GHC.Internal.Generics’
instance forall a. (GHC.Internal.Generics.Generic a, GHC.Internal.Base.Monoid (GHC.Internal.Generics.Rep a ())) => GHC.Internal.Base.Monoid (GHC.Internal.Generics.Generically a) -- Defined in ‘GHC.Internal.Generics’
instance forall k c i (p :: k). GHC.Internal.Base.Monoid c => GHC.Internal.Base.Monoid (GHC.Internal.Generics.K1 i c p) -- Defined in ‘GHC.Internal.Generics’
instance forall k (f :: k -> *) (p :: k) i (c :: GHC.Internal.Generics.Meta). GHC.Internal.Base.Monoid (f p) => GHC.Internal.Base.Monoid (GHC.Internal.Generics.M1 i c f p) -- Defined in ‘GHC.Internal.Generics’
instance forall p. GHC.Internal.Base.Monoid p => GHC.Internal.Base.Monoid (GHC.Internal.Generics.Par1 p) -- Defined in ‘GHC.Internal.Generics’
instance forall k (f :: k -> *) (p :: k). GHC.Internal.Base.Monoid (f p) => GHC.Internal.Base.Monoid (GHC.Internal.Generics.Rec1 f p) -- Defined in ‘GHC.Internal.Generics’
instance forall k (p :: k). GHC.Internal.Base.Monoid (GHC.Internal.Generics.U1 p) -- Defined in ‘GHC.Internal.Generics’
instance forall a. GHC.Internal.Base.Semigroup a => GHC.Internal.Base.Semigroup (GHC.Types.IO a) -- Defined in ‘GHC.Internal.Base’
instance forall a. GHC.Internal.Base.Semigroup [a] -- Defined in ‘GHC.Internal.Base’
instance forall a. GHC.Internal.Base.Semigroup a => GHC.Internal.Base.Semigroup (GHC.Internal.Maybe.Maybe a) -- Defined in ‘GHC.Internal.Base’
instance forall a. GHC.Internal.Base.Semigroup (GHC.Internal.Base.NonEmpty a) -- Defined in ‘GHC.Internal.Base’
instance GHC.Internal.Base.Semigroup GHC.Types.Ordering -- Defined in ‘GHC.Internal.Base’
instance forall a. GHC.Internal.Base.Semigroup a => GHC.Internal.Base.Semigroup (Solo a) -- Defined in ‘GHC.Internal.Base’
instance forall a b. (GHC.Internal.Base.Semigroup a, GHC.Internal.Base.Semigroup b) => GHC.Internal.Base.Semigroup (a, b) -- Defined in ‘GHC.Internal.Base’
instance forall a b c. (GHC.Internal.Base.Semigroup a, GHC.Internal.Base.Semigroup b, GHC.Internal.Base.Semigroup c) => GHC.Internal.Base.Semigroup (a, b, c) -- Defined in ‘GHC.Internal.Base’
instance forall a b c d. (GHC.Internal.Base.Semigroup a, GHC.Internal.Base.Semigroup b, GHC.Internal.Base.Semigroup c, GHC.Internal.Base.Semigroup d) => GHC.Internal.Base.Semigroup (a, b, c, d) -- Defined in ‘GHC.Internal.Base’
instance forall a b c d e. (GHC.Internal.Base.Semigroup a, GHC.Internal.Base.Semigroup b, GHC.Internal.Base.Semigroup c, GHC.Internal.Base.Semigroup d, GHC.Internal.Base.Semigroup e) => GHC.Internal.Base.Semigroup (a, b, c, d, e) -- Defined in ‘GHC.Internal.Base’
instance GHC.Internal.Base.Semigroup () -- Defined in ‘GHC.Internal.Base’
instance GHC.Internal.Base.Semigroup GHC.Internal.Base.Void -- Defined in ‘GHC.Internal.Base’
instance forall a k (b :: k). GHC.Internal.Base.Semigroup a => GHC.Internal.Base.Semigroup (GHC.Internal.Data.Functor.Const.Const a b) -- Defined in ‘GHC.Internal.Data.Functor.Const’
instance forall a. GHC.Internal.Base.Semigroup a => GHC.Internal.Base.Semigroup (GHC.Internal.Conc.Sync.STM a) -- Defined in ‘GHC.Internal.Conc.Sync’
instance GHC.Internal.Base.Semigroup GHC.Internal.Exception.Context.ExceptionContext -- Defined in ‘GHC.Internal.Exception.Context’
instance forall a s. GHC.Internal.Base.Semigroup a => GHC.Internal.Base.Semigroup (GHC.Internal.ST.ST s a) -- Defined in ‘GHC.Internal.ST’
instance GHC.Internal.Base.Semigroup Data.Array.Byte.ByteArray -- Defined in ‘Data.Array.Byte’
instance forall a. GHC.Internal.Bits.Bits a => GHC.Internal.Base.Semigroup (GHC.Internal.Data.Bits.And a) -- Defined in ‘GHC.Internal.Data.Bits’
instance forall a. GHC.Internal.Bits.FiniteBits a => GHC.Internal.Base.Semigroup (GHC.Internal.Data.Bits.Iff a) -- Defined in ‘GHC.Internal.Data.Bits’
instance forall a. GHC.Internal.Bits.Bits a => GHC.Internal.Base.Semigroup (GHC.Internal.Data.Bits.Ior a) -- Defined in ‘GHC.Internal.Data.Bits’
instance forall a. GHC.Internal.Bits.Bits a => GHC.Internal.Base.Semigroup (GHC.Internal.Data.Bits.Xor a) -- Defined in ‘GHC.Internal.Data.Bits’
instance forall k (s :: k). GHC.Internal.Base.Semigroup (GHC.Internal.Data.Proxy.Proxy s) -- Defined in ‘GHC.Internal.Data.Proxy’
instance forall a b. GHC.Internal.Base.Semigroup (GHC.Internal.Data.Either.Either a b) -- Defined in ‘GHC.Internal.Data.Either’
instance forall b. GHC.Internal.Base.Semigroup (Data.Foldable1.FromMaybe b) -- Defined in ‘Data.Foldable1’
instance forall a. GHC.Internal.Base.Semigroup a => GHC.Internal.Base.Semigroup (Data.Foldable1.JoinWith a) -- Defined in ‘Data.Foldable1’
instance forall a. GHC.Internal.Base.Semigroup (Data.Foldable1.NonEmptyDList a) -- Defined in ‘Data.Foldable1’
instance forall k1 (f :: k1 -> *) k2 (g :: k2 -> k1) (a :: k2). GHC.Internal.Base.Semigroup (f (g a)) => GHC.Internal.Base.Semigroup (Data.Functor.Compose.Compose f g a) -- Defined in ‘Data.Functor.Compose’
instance forall a. GHC.Internal.Base.Semigroup (Data.Functor.Contravariant.Comparison a) -- Defined in ‘Data.Functor.Contravariant’
instance forall a. GHC.Internal.Base.Semigroup (Data.Functor.Contravariant.Equivalence a) -- Defined in ‘Data.Functor.Contravariant’
instance forall a b. GHC.Internal.Base.Semigroup a => GHC.Internal.Base.Semigroup (Data.Functor.Contravariant.Op a b) -- Defined in ‘Data.Functor.Contravariant’
instance forall a. GHC.Internal.Base.Semigroup (Data.Functor.Contravariant.Predicate a) -- Defined in ‘Data.Functor.Contravariant’
instance forall a. GHC.Internal.Base.Semigroup a => GHC.Internal.Base.Semigroup (GHC.Internal.Data.Functor.Identity.Identity a) -- Defined in ‘GHC.Internal.Data.Functor.Identity’
instance [safe] forall k (f :: k -> *) (a :: k) (g :: k -> *). (GHC.Internal.Base.Semigroup (f a), GHC.Internal.Base.Semigroup (g a)) => GHC.Internal.Base.Semigroup (Data.Functor.Product.Product f g a) -- Defined in ‘Data.Functor.Product’
instance GHC.Internal.Base.Semigroup GHC.Internal.Data.Semigroup.Internal.All -- Defined in ‘GHC.Internal.Data.Semigroup.Internal’
instance GHC.Internal.Base.Semigroup GHC.Internal.Data.Semigroup.Internal.Any -- Defined in ‘GHC.Internal.Data.Semigroup.Internal’
instance forall a. GHC.Internal.Base.Semigroup a => GHC.Internal.Base.Semigroup (GHC.Internal.Data.Semigroup.Internal.Dual a) -- Defined in ‘GHC.Internal.Data.Semigroup.Internal’
instance forall a. GHC.Internal.Base.Semigroup (GHC.Internal.Data.Semigroup.Internal.Endo a) -- Defined in ‘GHC.Internal.Data.Semigroup.Internal’
instance forall a. GHC.Internal.Num.Num a => GHC.Internal.Base.Semigroup (GHC.Internal.Data.Semigroup.Internal.Product a) -- Defined in ‘GHC.Internal.Data.Semigroup.Internal’
instance forall a. GHC.Internal.Num.Num a => GHC.Internal.Base.Semigroup (GHC.Internal.Data.Semigroup.Internal.Sum a) -- Defined in ‘GHC.Internal.Data.Semigroup.Internal’
instance forall a. GHC.Internal.Base.Semigroup (GHC.Internal.Data.Monoid.First a) -- Defined in ‘GHC.Internal.Data.Monoid’
instance forall a. GHC.Internal.Base.Semigroup (GHC.Internal.Data.Monoid.Last a) -- Defined in ‘GHC.Internal.Data.Monoid’
instance forall a. GHC.Internal.Base.Semigroup a => GHC.Internal.Base.Semigroup (GHC.Internal.Data.Ord.Down a) -- Defined in ‘GHC.Internal.Data.Ord’
instance forall a. GHC.Internal.Base.Semigroup (Data.Semigroup.First a) -- Defined in ‘Data.Semigroup’
instance forall a. GHC.Internal.Base.Semigroup (Data.Semigroup.Last a) -- Defined in ‘Data.Semigroup’
instance forall a. GHC.Classes.Ord a => GHC.Internal.Base.Semigroup (Data.Semigroup.Max a) -- Defined in ‘Data.Semigroup’
instance forall a. GHC.Classes.Ord a => GHC.Internal.Base.Semigroup (Data.Semigroup.Min a) -- Defined in ‘Data.Semigroup’
instance forall m. GHC.Internal.Base.Monoid m => GHC.Internal.Base.Semigroup (Data.Semigroup.WrappedMonoid m) -- Defined in ‘Data.Semigroup’
instance GHC.Internal.Base.Semigroup ghc-internal-0.1.0.0:GHC.Internal.Event.Internal.Types.Event -- Defined in ‘ghc-internal-0.1.0.0:GHC.Internal.Event.Internal.Types’
instance GHC.Internal.Base.Semigroup ghc-internal-0.1.0.0:GHC.Internal.Event.Internal.Types.EventLifetime -- Defined in ‘ghc-internal-0.1.0.0:GHC.Internal.Event.Internal.Types’
instance GHC.Internal.Base.Semigroup ghc-internal-0.1.0.0:GHC.Internal.Event.Internal.Types.Lifetime -- Defined in ‘ghc-internal-0.1.0.0:GHC.Internal.Event.Internal.Types’
instance forall k (f :: k -> *) (p :: k) (g :: k -> *). (GHC.Internal.Base.Semigroup (f p), GHC.Internal.Base.Semigroup (g p)) => GHC.Internal.Base.Semigroup ((GHC.Internal.Generics.:*:) f g p) -- Defined in ‘GHC.Internal.Generics’
instance forall k2 k1 (f :: k2 -> *) (g :: k1 -> k2) (p :: k1). GHC.Internal.Base.Semigroup (f (g p)) => GHC.Internal.Base.Semigroup ((GHC.Internal.Generics.:.:) f g p) -- Defined in ‘GHC.Internal.Generics’
instance forall a. (GHC.Internal.Generics.Generic a, GHC.Internal.Base.Semigroup (GHC.Internal.Generics.Rep a ())) => GHC.Internal.Base.Semigroup (GHC.Internal.Generics.Generically a) -- Defined in ‘GHC.Internal.Generics’
instance forall k c i (p :: k). GHC.Internal.Base.Semigroup c => GHC.Internal.Base.Semigroup (GHC.Internal.Generics.K1 i c p) -- Defined in ‘GHC.Internal.Generics’
instance forall k (f :: k -> *) (p :: k) i (c :: GHC.Internal.Generics.Meta). GHC.Internal.Base.Semigroup (f p) => GHC.Internal.Base.Semigroup (GHC.Internal.Generics.M1 i c f p) -- Defined in ‘GHC.Internal.Generics’
instance forall p. GHC.Internal.Base.Semigroup p => GHC.Internal.Base.Semigroup (GHC.Internal.Generics.Par1 p) -- Defined in ‘GHC.Internal.Generics’
instance forall k (f :: k -> *) (p :: k). GHC.Internal.Base.Semigroup (f p) => GHC.Internal.Base.Semigroup (GHC.Internal.Generics.Rec1 f p) -- Defined in ‘GHC.Internal.Generics’
instance forall k (p :: k). GHC.Internal.Base.Semigroup (GHC.Internal.Generics.U1 p) -- Defined in ‘GHC.Internal.Generics’
instance forall k (p :: k). GHC.Internal.Base.Semigroup (GHC.Internal.Generics.V1 p) -- Defined in ‘GHC.Internal.Generics’
instance forall a k (b :: k). GHC.Internal.Bits.Bits a => GHC.Internal.Bits.Bits (GHC.Internal.Data.Functor.Const.Const a b) -- Defined in ‘GHC.Internal.Data.Functor.Const’
instance forall a. GHC.Internal.Bits.Bits a => GHC.Internal.Bits.Bits (GHC.Internal.Data.Bits.And a) -- Defined in ‘GHC.Internal.Data.Bits’
instance forall a. GHC.Internal.Bits.Bits a => GHC.Internal.Bits.Bits (GHC.Internal.Data.Bits.Iff a) -- Defined in ‘GHC.Internal.Data.Bits’
instance forall a. GHC.Internal.Bits.Bits a => GHC.Internal.Bits.Bits (GHC.Internal.Data.Bits.Ior a) -- Defined in ‘GHC.Internal.Data.Bits’
instance forall a. GHC.Internal.Bits.Bits a => GHC.Internal.Bits.Bits (GHC.Internal.Data.Bits.Xor a) -- Defined in ‘GHC.Internal.Data.Bits’
instance GHC.Internal.Bits.Bits GHC.Types.Bool -- Defined in ‘GHC.Internal.Bits’
instance GHC.Internal.Bits.Bits GHC.Types.Int -- Defined in ‘GHC.Internal.Bits’
instance GHC.Internal.Bits.Bits GHC.Num.Integer.Integer -- Defined in ‘GHC.Internal.Bits’
instance GHC.Internal.Bits.Bits GHC.Num.Natural.Natural -- Defined in ‘GHC.Internal.Bits’
instance GHC.Internal.Bits.Bits GHC.Types.Word -- Defined in ‘GHC.Internal.Bits’
instance forall a. GHC.Internal.Bits.Bits a => GHC.Internal.Bits.Bits (GHC.Internal.Data.Functor.Identity.Identity a) -- Defined in ‘GHC.Internal.Data.Functor.Identity’
instance GHC.Internal.Bits.Bits GHC.Internal.Int.Int16 -- Defined in ‘GHC.Internal.Int’
instance GHC.Internal.Bits.Bits GHC.Internal.Int.Int32 -- Defined in ‘GHC.Internal.Int’
instance GHC.Internal.Bits.Bits GHC.Internal.Int.Int64 -- Defined in ‘GHC.Internal.Int’
instance GHC.Internal.Bits.Bits GHC.Internal.Int.Int8 -- Defined in ‘GHC.Internal.Int’
instance forall a. GHC.Internal.Bits.Bits a => GHC.Internal.Bits.Bits (GHC.Internal.Data.Ord.Down a) -- Defined in ‘GHC.Internal.Data.Ord’
instance GHC.Internal.Bits.Bits GHC.Internal.Word.Word16 -- Defined in ‘GHC.Internal.Word’
instance GHC.Internal.Bits.Bits GHC.Internal.Word.Word32 -- Defined in ‘GHC.Internal.Word’
instance GHC.Internal.Bits.Bits GHC.Internal.Word.Word64 -- Defined in ‘GHC.Internal.Word’
instance GHC.Internal.Bits.Bits GHC.Internal.Word.Word8 -- Defined in ‘GHC.Internal.Word’
instance GHC.Internal.Bits.Bits GHC.Internal.Foreign.Ptr.IntPtr -- Defined in ‘GHC.Internal.Foreign.Ptr’
instance GHC.Internal.Bits.Bits GHC.Internal.Foreign.Ptr.WordPtr -- Defined in ‘GHC.Internal.Foreign.Ptr’
instance GHC.Internal.Bits.Bits GHC.Internal.Foreign.C.Types.CBool -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Bits.Bits GHC.Internal.Foreign.C.Types.CChar -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Bits.Bits GHC.Internal.Foreign.C.Types.CInt -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Bits.Bits GHC.Internal.Foreign.C.Types.CIntMax -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Bits.Bits GHC.Internal.Foreign.C.Types.CIntPtr -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Bits.Bits GHC.Internal.Foreign.C.Types.CLLong -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Bits.Bits GHC.Internal.Foreign.C.Types.CLong -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Bits.Bits GHC.Internal.Foreign.C.Types.CPtrdiff -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Bits.Bits GHC.Internal.Foreign.C.Types.CSChar -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Bits.Bits GHC.Internal.Foreign.C.Types.CShort -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Bits.Bits GHC.Internal.Foreign.C.Types.CSigAtomic -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Bits.Bits GHC.Internal.Foreign.C.Types.CSize -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Bits.Bits GHC.Internal.Foreign.C.Types.CUChar -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Bits.Bits GHC.Internal.Foreign.C.Types.CUInt -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Bits.Bits GHC.Internal.Foreign.C.Types.CUIntMax -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Bits.Bits GHC.Internal.Foreign.C.Types.CUIntPtr -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Bits.Bits GHC.Internal.Foreign.C.Types.CULLong -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Bits.Bits GHC.Internal.Foreign.C.Types.CULong -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Bits.Bits GHC.Internal.Foreign.C.Types.CUShort -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Bits.Bits GHC.Internal.Foreign.C.Types.CWchar -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance forall a k (b :: k). GHC.Internal.Bits.FiniteBits a => GHC.Internal.Bits.FiniteBits (GHC.Internal.Data.Functor.Const.Const a b) -- Defined in ‘GHC.Internal.Data.Functor.Const’
instance forall a. GHC.Internal.Bits.FiniteBits a => GHC.Internal.Bits.FiniteBits (GHC.Internal.Data.Bits.And a) -- Defined in ‘GHC.Internal.Data.Bits’
instance forall a. GHC.Internal.Bits.FiniteBits a => GHC.Internal.Bits.FiniteBits (GHC.Internal.Data.Bits.Iff a) -- Defined in ‘GHC.Internal.Data.Bits’
instance forall a. GHC.Internal.Bits.FiniteBits a => GHC.Internal.Bits.FiniteBits (GHC.Internal.Data.Bits.Ior a) -- Defined in ‘GHC.Internal.Data.Bits’
instance forall a. GHC.Internal.Bits.FiniteBits a => GHC.Internal.Bits.FiniteBits (GHC.Internal.Data.Bits.Xor a) -- Defined in ‘GHC.Internal.Data.Bits’
instance GHC.Internal.Bits.FiniteBits GHC.Types.Bool -- Defined in ‘GHC.Internal.Bits’
instance GHC.Internal.Bits.FiniteBits GHC.Types.Int -- Defined in ‘GHC.Internal.Bits’
instance GHC.Internal.Bits.FiniteBits GHC.Types.Word -- Defined in ‘GHC.Internal.Bits’
instance forall a. GHC.Internal.Bits.FiniteBits a => GHC.Internal.Bits.FiniteBits (GHC.Internal.Data.Functor.Identity.Identity a) -- Defined in ‘GHC.Internal.Data.Functor.Identity’
instance GHC.Internal.Bits.FiniteBits GHC.Internal.Int.Int16 -- Defined in ‘GHC.Internal.Int’
instance GHC.Internal.Bits.FiniteBits GHC.Internal.Int.Int32 -- Defined in ‘GHC.Internal.Int’
instance GHC.Internal.Bits.FiniteBits GHC.Internal.Int.Int64 -- Defined in ‘GHC.Internal.Int’
instance GHC.Internal.Bits.FiniteBits GHC.Internal.Int.Int8 -- Defined in ‘GHC.Internal.Int’
instance forall a. GHC.Internal.Bits.FiniteBits a => GHC.Internal.Bits.FiniteBits (GHC.Internal.Data.Ord.Down a) -- Defined in ‘GHC.Internal.Data.Ord’
instance GHC.Internal.Bits.FiniteBits GHC.Internal.Word.Word16 -- Defined in ‘GHC.Internal.Word’
instance GHC.Internal.Bits.FiniteBits GHC.Internal.Word.Word32 -- Defined in ‘GHC.Internal.Word’
instance GHC.Internal.Bits.FiniteBits GHC.Internal.Word.Word64 -- Defined in ‘GHC.Internal.Word’
instance GHC.Internal.Bits.FiniteBits GHC.Internal.Word.Word8 -- Defined in ‘GHC.Internal.Word’
instance GHC.Internal.Bits.FiniteBits GHC.Internal.Foreign.Ptr.IntPtr -- Defined in ‘GHC.Internal.Foreign.Ptr’
instance GHC.Internal.Bits.FiniteBits GHC.Internal.Foreign.Ptr.WordPtr -- Defined in ‘GHC.Internal.Foreign.Ptr’
instance GHC.Internal.Bits.FiniteBits GHC.Internal.Foreign.C.Types.CBool -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Bits.FiniteBits GHC.Internal.Foreign.C.Types.CChar -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Bits.FiniteBits GHC.Internal.Foreign.C.Types.CInt -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Bits.FiniteBits GHC.Internal.Foreign.C.Types.CIntMax -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Bits.FiniteBits GHC.Internal.Foreign.C.Types.CIntPtr -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Bits.FiniteBits GHC.Internal.Foreign.C.Types.CLLong -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Bits.FiniteBits GHC.Internal.Foreign.C.Types.CLong -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Bits.FiniteBits GHC.Internal.Foreign.C.Types.CPtrdiff -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Bits.FiniteBits GHC.Internal.Foreign.C.Types.CSChar -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Bits.FiniteBits GHC.Internal.Foreign.C.Types.CShort -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Bits.FiniteBits GHC.Internal.Foreign.C.Types.CSigAtomic -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Bits.FiniteBits GHC.Internal.Foreign.C.Types.CSize -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Bits.FiniteBits GHC.Internal.Foreign.C.Types.CUChar -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Bits.FiniteBits GHC.Internal.Foreign.C.Types.CUInt -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Bits.FiniteBits GHC.Internal.Foreign.C.Types.CUIntMax -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Bits.FiniteBits GHC.Internal.Foreign.C.Types.CUIntPtr -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Bits.FiniteBits GHC.Internal.Foreign.C.Types.CULLong -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Bits.FiniteBits GHC.Internal.Foreign.C.Types.CULong -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Bits.FiniteBits GHC.Internal.Foreign.C.Types.CUShort -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Bits.FiniteBits GHC.Internal.Foreign.C.Types.CWchar -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance forall (m :: * -> *). GHC.Internal.Base.Monad m => GHC.Internal.Control.Arrow.Arrow (GHC.Internal.Control.Arrow.Kleisli m) -- Defined in ‘GHC.Internal.Control.Arrow’
instance forall (m :: * -> *). GHC.Internal.Base.Monad m => GHC.Internal.Control.Arrow.ArrowApply (GHC.Internal.Control.Arrow.Kleisli m) -- Defined in ‘GHC.Internal.Control.Arrow’
instance forall (m :: * -> *). GHC.Internal.Base.Monad m => GHC.Internal.Control.Arrow.ArrowChoice (GHC.Internal.Control.Arrow.Kleisli m) -- Defined in ‘GHC.Internal.Control.Arrow’
instance forall (m :: * -> *). GHC.Internal.Control.Monad.Fix.MonadFix m => GHC.Internal.Control.Arrow.ArrowLoop (GHC.Internal.Control.Arrow.Kleisli m) -- Defined in ‘GHC.Internal.Control.Arrow’
instance forall (m :: * -> *). GHC.Internal.Base.MonadPlus m => GHC.Internal.Control.Arrow.ArrowPlus (GHC.Internal.Control.Arrow.Kleisli m) -- Defined in ‘GHC.Internal.Control.Arrow’
instance forall (m :: * -> *). GHC.Internal.Base.MonadPlus m => GHC.Internal.Control.Arrow.ArrowZero (GHC.Internal.Control.Arrow.Kleisli m) -- Defined in ‘GHC.Internal.Control.Arrow’
instance forall k. GHC.Internal.Control.Category.Category (GHC.Internal.Data.Type.Equality.:~:) -- Defined in ‘GHC.Internal.Control.Category’
instance forall k. GHC.Internal.Control.Category.Category (GHC.Internal.Data.Type.Equality.:~~:) -- Defined in ‘GHC.Internal.Control.Category’
instance forall k. GHC.Internal.Control.Category.Category GHC.Internal.Data.Type.Coercion.Coercion -- Defined in ‘GHC.Internal.Control.Category’
instance GHC.Internal.Control.Monad.Fail.MonadFail GHC.Types.IO -- Defined in ‘GHC.Internal.Control.Monad.Fail’
instance GHC.Internal.Control.Monad.Fail.MonadFail [] -- Defined in ‘GHC.Internal.Control.Monad.Fail’
instance GHC.Internal.Control.Monad.Fail.MonadFail GHC.Internal.Maybe.Maybe -- Defined in ‘GHC.Internal.Control.Monad.Fail’
instance GHC.Internal.Control.Monad.Fail.MonadFail GHC.Internal.Text.ParserCombinators.ReadP.P -- Defined in ‘GHC.Internal.Text.ParserCombinators.ReadP’
instance GHC.Internal.Control.Monad.Fail.MonadFail GHC.Internal.Text.ParserCombinators.ReadP.ReadP -- Defined in ‘GHC.Internal.Text.ParserCombinators.ReadP’
instance GHC.Internal.Control.Monad.Fail.MonadFail GHC.Internal.Text.ParserCombinators.ReadPrec.ReadPrec -- Defined in ‘GHC.Internal.Text.ParserCombinators.ReadPrec’
instance GHC.Internal.Control.Monad.Fix.MonadFix GHC.Internal.Data.Ord.Down -- Defined in ‘GHC.Internal.Control.Monad.Fix’
instance GHC.Internal.Control.Monad.Fix.MonadFix GHC.Internal.Data.Semigroup.Internal.Dual -- Defined in ‘GHC.Internal.Control.Monad.Fix’
instance forall e. GHC.Internal.Control.Monad.Fix.MonadFix (GHC.Internal.Data.Either.Either e) -- Defined in ‘GHC.Internal.Control.Monad.Fix’
instance GHC.Internal.Control.Monad.Fix.MonadFix GHC.Internal.Data.Monoid.First -- Defined in ‘GHC.Internal.Control.Monad.Fix’
instance GHC.Internal.Control.Monad.Fix.MonadFix GHC.Types.IO -- Defined in ‘GHC.Internal.Control.Monad.Fix’
instance GHC.Internal.Control.Monad.Fix.MonadFix GHC.Internal.Data.Monoid.Last -- Defined in ‘GHC.Internal.Control.Monad.Fix’
instance GHC.Internal.Control.Monad.Fix.MonadFix [] -- Defined in ‘GHC.Internal.Control.Monad.Fix’
instance GHC.Internal.Control.Monad.Fix.MonadFix GHC.Internal.Maybe.Maybe -- Defined in ‘GHC.Internal.Control.Monad.Fix’
instance GHC.Internal.Control.Monad.Fix.MonadFix GHC.Internal.Base.NonEmpty -- Defined in ‘GHC.Internal.Control.Monad.Fix’
instance GHC.Internal.Control.Monad.Fix.MonadFix GHC.Internal.Generics.Par1 -- Defined in ‘GHC.Internal.Control.Monad.Fix’
instance GHC.Internal.Control.Monad.Fix.MonadFix GHC.Internal.Data.Semigroup.Internal.Product -- Defined in ‘GHC.Internal.Control.Monad.Fix’
instance forall s. GHC.Internal.Control.Monad.Fix.MonadFix (GHC.Internal.ST.ST s) -- Defined in ‘GHC.Internal.Control.Monad.Fix’
instance GHC.Internal.Control.Monad.Fix.MonadFix Solo -- Defined in ‘GHC.Internal.Control.Monad.Fix’
instance GHC.Internal.Control.Monad.Fix.MonadFix GHC.Internal.Data.Semigroup.Internal.Sum -- Defined in ‘GHC.Internal.Control.Monad.Fix’
instance forall s. GHC.Internal.Control.Monad.Fix.MonadFix (GHC.Internal.Control.Monad.ST.Lazy.Imp.ST s) -- Defined in ‘GHC.Internal.Control.Monad.ST.Lazy.Imp’
instance GHC.Internal.Control.Monad.Fix.MonadFix Data.Complex.Complex -- Defined in ‘Data.Complex’
instance GHC.Internal.Control.Monad.Fix.MonadFix GHC.Internal.Data.Functor.Identity.Identity -- Defined in ‘GHC.Internal.Data.Functor.Identity’
instance GHC.Internal.Control.Monad.Fix.MonadFix Data.Semigroup.First -- Defined in ‘Data.Semigroup’
instance GHC.Internal.Control.Monad.Fix.MonadFix Data.Semigroup.Last -- Defined in ‘Data.Semigroup’
instance GHC.Internal.Control.Monad.Fix.MonadFix Data.Semigroup.Max -- Defined in ‘Data.Semigroup’
instance GHC.Internal.Control.Monad.Fix.MonadFix Data.Semigroup.Min -- Defined in ‘Data.Semigroup’
instance forall (a :: * -> * -> *) b c. (ghc-internal-0.1.0.0:GHC.Internal.Data.Typeable.Internal.Typeable a, ghc-internal-0.1.0.0:GHC.Internal.Data.Typeable.Internal.Typeable b, ghc-internal-0.1.0.0:GHC.Internal.Data.Typeable.Internal.Typeable c, GHC.Internal.Data.Data.Data (a b c)) => GHC.Internal.Data.Data.Data (Control.Applicative.WrappedArrow a b c) -- Defined in ‘Control.Applicative’
instance forall (m :: * -> *) a. (ghc-internal-0.1.0.0:GHC.Internal.Data.Typeable.Internal.Typeable m, ghc-internal-0.1.0.0:GHC.Internal.Data.Typeable.Internal.Typeable a, GHC.Internal.Data.Data.Data (m a)) => GHC.Internal.Data.Data.Data (Control.Applicative.WrappedMonad m a) -- Defined in ‘Control.Applicative’
instance forall a. GHC.Internal.Data.Data.Data a => GHC.Internal.Data.Data.Data (GHC.Internal.Functor.ZipList.ZipList a) -- Defined in ‘GHC.Internal.Functor.ZipList’
instance GHC.Internal.Data.Data.Data Data.Array.Byte.ByteArray -- Defined in ‘Data.Array.Byte’
instance forall s. ghc-internal-0.1.0.0:GHC.Internal.Data.Typeable.Internal.Typeable s => GHC.Internal.Data.Data.Data (Data.Array.Byte.MutableByteArray s) -- Defined in ‘Data.Array.Byte’
instance forall a. GHC.Internal.Data.Data.Data a => GHC.Internal.Data.Data.Data (Data.Complex.Complex a) -- Defined in ‘Data.Complex’
instance forall i j (a :: i) (b :: j). (ghc-internal-0.1.0.0:GHC.Internal.Data.Typeable.Internal.Typeable i, ghc-internal-0.1.0.0:GHC.Internal.Data.Typeable.Internal.Typeable j, ghc-internal-0.1.0.0:GHC.Internal.Data.Typeable.Internal.Typeable a, ghc-internal-0.1.0.0:GHC.Internal.Data.Typeable.Internal.Typeable b, a ~~ b) => GHC.Internal.Data.Data.Data (a GHC.Internal.Data.Type.Equality.:~~: b) -- Defined in ‘GHC.Internal.Data.Data’
instance GHC.Internal.Data.Data.Data GHC.Internal.Data.Semigroup.Internal.All -- Defined in ‘GHC.Internal.Data.Data’
instance GHC.Internal.Data.Data.Data GHC.Internal.Data.Semigroup.Internal.Any -- Defined in ‘GHC.Internal.Data.Data’
instance forall a b. (GHC.Internal.Data.Data.Data a, GHC.Internal.Data.Data.Data b, GHC.Internal.Ix.Ix a) => GHC.Internal.Data.Data.Data (GHC.Internal.Arr.Array a b) -- Defined in ‘GHC.Internal.Data.Data’
instance GHC.Internal.Data.Data.Data GHC.Internal.Generics.Associativity -- Defined in ‘GHC.Internal.Data.Data’
instance GHC.Internal.Data.Data.Data GHC.Types.Bool -- Defined in ‘GHC.Internal.Data.Data’
instance GHC.Internal.Data.Data.Data GHC.Types.Char -- Defined in ‘GHC.Internal.Data.Data’
instance forall k a (b :: k). (ghc-internal-0.1.0.0:GHC.Internal.Data.Typeable.Internal.Typeable k, GHC.Internal.Data.Data.Data a, ghc-internal-0.1.0.0:GHC.Internal.Data.Typeable.Internal.Typeable b) => GHC.Internal.Data.Data.Data (GHC.Internal.Data.Functor.Const.Const a b) -- Defined in ‘GHC.Internal.Data.Data’
instance forall a. GHC.Internal.Data.Data.Data a => GHC.Internal.Data.Data.Data (GHC.Internal.Foreign.C.ConstPtr.ConstPtr a) -- Defined in ‘GHC.Internal.Data.Data’
instance GHC.Internal.Data.Data.Data GHC.Internal.Generics.DecidedStrictness -- Defined in ‘GHC.Internal.Data.Data’
instance GHC.Internal.Data.Data.Data GHC.Types.Double -- Defined in ‘GHC.Internal.Data.Data’
instance forall a. GHC.Internal.Data.Data.Data a => GHC.Internal.Data.Data.Data (GHC.Internal.Data.Ord.Down a) -- Defined in ‘GHC.Internal.Data.Data’
instance forall a. GHC.Internal.Data.Data.Data a => GHC.Internal.Data.Data.Data (GHC.Internal.Data.Semigroup.Internal.Dual a) -- Defined in ‘GHC.Internal.Data.Data’
instance forall a b. (GHC.Internal.Data.Data.Data a, GHC.Internal.Data.Data.Data b) => GHC.Internal.Data.Data.Data (GHC.Internal.Data.Either.Either a b) -- Defined in ‘GHC.Internal.Data.Data’
instance forall a. GHC.Internal.Data.Data.Data a => GHC.Internal.Data.Data.Data (GHC.Internal.Data.Monoid.First a) -- Defined in ‘GHC.Internal.Data.Data’
instance GHC.Internal.Data.Data.Data GHC.Internal.Generics.Fixity -- Defined in ‘GHC.Internal.Data.Data’
instance GHC.Internal.Data.Data.Data GHC.Types.Float -- Defined in ‘GHC.Internal.Data.Data’
instance forall a. GHC.Internal.Data.Data.Data a => GHC.Internal.Data.Data.Data (GHC.Internal.ForeignPtr.ForeignPtr a) -- Defined in ‘GHC.Internal.Data.Data’
instance forall a. GHC.Internal.Data.Data.Data a => GHC.Internal.Data.Data.Data (GHC.Internal.Data.Functor.Identity.Identity a) -- Defined in ‘GHC.Internal.Data.Data’
instance GHC.Internal.Data.Data.Data GHC.Types.Int -- Defined in ‘GHC.Internal.Data.Data’
instance GHC.Internal.Data.Data.Data GHC.Internal.Int.Int16 -- Defined in ‘GHC.Internal.Data.Data’
instance GHC.Internal.Data.Data.Data GHC.Internal.Int.Int32 -- Defined in ‘GHC.Internal.Data.Data’
instance GHC.Internal.Data.Data.Data GHC.Internal.Int.Int64 -- Defined in ‘GHC.Internal.Data.Data’
instance GHC.Internal.Data.Data.Data GHC.Internal.Int.Int8 -- Defined in ‘GHC.Internal.Data.Data’
instance GHC.Internal.Data.Data.Data GHC.Internal.Foreign.Ptr.IntPtr -- Defined in ‘GHC.Internal.Data.Data’
instance GHC.Internal.Data.Data.Data GHC.Num.Integer.Integer -- Defined in ‘GHC.Internal.Data.Data’
instance forall a. GHC.Internal.Data.Data.Data a => GHC.Internal.Data.Data.Data (GHC.Internal.Data.Monoid.Last a) -- Defined in ‘GHC.Internal.Data.Data’
instance forall a. GHC.Internal.Data.Data.Data a => GHC.Internal.Data.Data.Data [a] -- Defined in ‘GHC.Internal.Data.Data’
instance forall a. GHC.Internal.Data.Data.Data a => GHC.Internal.Data.Data.Data (GHC.Internal.Maybe.Maybe a) -- Defined in ‘GHC.Internal.Data.Data’
instance GHC.Internal.Data.Data.Data GHC.Num.Natural.Natural -- Defined in ‘GHC.Internal.Data.Data’
instance forall a. GHC.Internal.Data.Data.Data a => GHC.Internal.Data.Data.Data (GHC.Internal.Base.NonEmpty a) -- Defined in ‘GHC.Internal.Data.Data’
instance GHC.Internal.Data.Data.Data GHC.Types.Ordering -- Defined in ‘GHC.Internal.Data.Data’
instance forall p. GHC.Internal.Data.Data.Data p => GHC.Internal.Data.Data.Data (GHC.Internal.Generics.Par1 p) -- Defined in ‘GHC.Internal.Data.Data’
instance forall a. GHC.Internal.Data.Data.Data a => GHC.Internal.Data.Data.Data (GHC.Internal.Data.Semigroup.Internal.Product a) -- Defined in ‘GHC.Internal.Data.Data’
instance forall a. GHC.Internal.Data.Data.Data a => GHC.Internal.Data.Data.Data (GHC.Internal.Ptr.Ptr a) -- Defined in ‘GHC.Internal.Data.Data’
instance forall a. (GHC.Internal.Data.Data.Data a, GHC.Internal.Real.Integral a) => GHC.Internal.Data.Data.Data (GHC.Internal.Real.Ratio a) -- Defined in ‘GHC.Internal.Data.Data’
instance forall a. GHC.Internal.Data.Data.Data a => GHC.Internal.Data.Data.Data (Solo a) -- Defined in ‘GHC.Internal.Data.Data’
instance GHC.Internal.Data.Data.Data GHC.Internal.Generics.SourceStrictness -- Defined in ‘GHC.Internal.Data.Data’
instance GHC.Internal.Data.Data.Data GHC.Internal.Generics.SourceUnpackedness -- Defined in ‘GHC.Internal.Data.Data’
instance forall a. GHC.Internal.Data.Data.Data a => GHC.Internal.Data.Data.Data (GHC.Internal.Data.Semigroup.Internal.Sum a) -- Defined in ‘GHC.Internal.Data.Data’
instance forall a b. (GHC.Internal.Data.Data.Data a, GHC.Internal.Data.Data.Data b) => GHC.Internal.Data.Data.Data (a, b) -- Defined in ‘GHC.Internal.Data.Data’
instance forall a b c. (GHC.Internal.Data.Data.Data a, GHC.Internal.Data.Data.Data b, GHC.Internal.Data.Data.Data c) => GHC.Internal.Data.Data.Data (a, b, c) -- Defined in ‘GHC.Internal.Data.Data’
instance forall a b c d. (GHC.Internal.Data.Data.Data a, GHC.Internal.Data.Data.Data b, GHC.Internal.Data.Data.Data c, GHC.Internal.Data.Data.Data d) => GHC.Internal.Data.Data.Data (a, b, c, d) -- Defined in ‘GHC.Internal.Data.Data’
instance forall a b c d e. (GHC.Internal.Data.Data.Data a, GHC.Internal.Data.Data.Data b, GHC.Internal.Data.Data.Data c, GHC.Internal.Data.Data.Data d, GHC.Internal.Data.Data.Data e) => GHC.Internal.Data.Data.Data (a, b, c, d, e) -- Defined in ‘GHC.Internal.Data.Data’
instance forall a b c d e f. (GHC.Internal.Data.Data.Data a, GHC.Internal.Data.Data.Data b, GHC.Internal.Data.Data.Data c, GHC.Internal.Data.Data.Data d, GHC.Internal.Data.Data.Data e, GHC.Internal.Data.Data.Data f) => GHC.Internal.Data.Data.Data (a, b, c, d, e, f) -- Defined in ‘GHC.Internal.Data.Data’
instance forall a b c d e f g. (GHC.Internal.Data.Data.Data a, GHC.Internal.Data.Data.Data b, GHC.Internal.Data.Data.Data c, GHC.Internal.Data.Data.Data d, GHC.Internal.Data.Data.Data e, GHC.Internal.Data.Data.Data f, GHC.Internal.Data.Data.Data g) => GHC.Internal.Data.Data.Data (a, b, c, d, e, f, g) -- Defined in ‘GHC.Internal.Data.Data’
instance GHC.Internal.Data.Data.Data () -- Defined in ‘GHC.Internal.Data.Data’
instance GHC.Internal.Data.Data.Data GHC.Internal.Data.Version.Version -- Defined in ‘GHC.Internal.Data.Data’
instance GHC.Internal.Data.Data.Data GHC.Internal.Base.Void -- Defined in ‘GHC.Internal.Data.Data’
instance GHC.Internal.Data.Data.Data GHC.Types.Word -- Defined in ‘GHC.Internal.Data.Data’
instance GHC.Internal.Data.Data.Data GHC.Internal.Word.Word16 -- Defined in ‘GHC.Internal.Data.Data’
instance GHC.Internal.Data.Data.Data GHC.Internal.Word.Word32 -- Defined in ‘GHC.Internal.Data.Data’
instance GHC.Internal.Data.Data.Data GHC.Internal.Word.Word64 -- Defined in ‘GHC.Internal.Data.Data’
instance GHC.Internal.Data.Data.Data GHC.Internal.Word.Word8 -- Defined in ‘GHC.Internal.Data.Data’
instance GHC.Internal.Data.Data.Data GHC.Internal.Foreign.Ptr.WordPtr -- Defined in ‘GHC.Internal.Data.Data’
instance forall k (a :: k). (ghc-internal-0.1.0.0:GHC.Internal.Data.Typeable.Internal.Typeable k, ghc-internal-0.1.0.0:GHC.Internal.Data.Typeable.Internal.Typeable a) => GHC.Internal.Data.Data.Data (Data.Fixed.Fixed a) -- Defined in ‘Data.Fixed’
instance forall k1 (f :: k1 -> *) k2 (g :: k2 -> k1) (a :: k2). (ghc-internal-0.1.0.0:GHC.Internal.Data.Typeable.Internal.Typeable a, ghc-internal-0.1.0.0:GHC.Internal.Data.Typeable.Internal.Typeable f, ghc-internal-0.1.0.0:GHC.Internal.Data.Typeable.Internal.Typeable g, ghc-internal-0.1.0.0:GHC.Internal.Data.Typeable.Internal.Typeable k1, ghc-internal-0.1.0.0:GHC.Internal.Data.Typeable.Internal.Typeable k2, GHC.Internal.Data.Data.Data (f (g a))) => GHC.Internal.Data.Data.Data (Data.Functor.Compose.Compose f g a) -- Defined in ‘Data.Functor.Compose’
instance [safe] forall k (f :: k -> *) (g :: k -> *) (a :: k). (ghc-internal-0.1.0.0:GHC.Internal.Data.Typeable.Internal.Typeable a, ghc-internal-0.1.0.0:GHC.Internal.Data.Typeable.Internal.Typeable f, ghc-internal-0.1.0.0:GHC.Internal.Data.Typeable.Internal.Typeable g, ghc-internal-0.1.0.0:GHC.Internal.Data.Typeable.Internal.Typeable k, GHC.Internal.Data.Data.Data (f a), GHC.Internal.Data.Data.Data (g a)) => GHC.Internal.Data.Data.Data (Data.Functor.Product.Product f g a) -- Defined in ‘Data.Functor.Product’
instance [safe] forall k (f :: k -> *) (g :: k -> *) (a :: k). (ghc-internal-0.1.0.0:GHC.Internal.Data.Typeable.Internal.Typeable a, ghc-internal-0.1.0.0:GHC.Internal.Data.Typeable.Internal.Typeable f, ghc-internal-0.1.0.0:GHC.Internal.Data.Typeable.Internal.Typeable g, ghc-internal-0.1.0.0:GHC.Internal.Data.Typeable.Internal.Typeable k, GHC.Internal.Data.Data.Data (f a), GHC.Internal.Data.Data.Data (g a)) => GHC.Internal.Data.Data.Data (Data.Functor.Sum.Sum f g a) -- Defined in ‘Data.Functor.Sum’
instance forall a b. (GHC.Internal.Data.Data.Data a, GHC.Internal.Data.Data.Data b) => GHC.Internal.Data.Data.Data (Data.Semigroup.Arg a b) -- Defined in ‘Data.Semigroup’
instance forall a. GHC.Internal.Data.Data.Data a => GHC.Internal.Data.Data.Data (Data.Semigroup.First a) -- Defined in ‘Data.Semigroup’
instance forall a. GHC.Internal.Data.Data.Data a => GHC.Internal.Data.Data.Data (Data.Semigroup.Last a) -- Defined in ‘Data.Semigroup’
instance forall a. GHC.Internal.Data.Data.Data a => GHC.Internal.Data.Data.Data (Data.Semigroup.Max a) -- Defined in ‘Data.Semigroup’
instance forall a. GHC.Internal.Data.Data.Data a => GHC.Internal.Data.Data.Data (Data.Semigroup.Min a) -- Defined in ‘Data.Semigroup’
instance forall m. GHC.Internal.Data.Data.Data m => GHC.Internal.Data.Data.Data (Data.Semigroup.WrappedMonoid m) -- Defined in ‘Data.Semigroup’
instance GHC.Internal.Data.Data.Data GHC.Internal.Exts.SpecConstrAnnotation -- Defined in ‘GHC.Internal.Exts’
instance GHC.Internal.Data.Foldable.Foldable GHC.Internal.Functor.ZipList.ZipList -- Defined in ‘GHC.Internal.Functor.ZipList’
instance forall i. GHC.Internal.Data.Foldable.Foldable (GHC.Internal.Arr.Array i) -- Defined in ‘GHC.Internal.Data.Foldable’
instance GHC.Internal.Data.Foldable.Foldable GHC.Internal.Data.Ord.Down -- Defined in ‘GHC.Internal.Data.Foldable’
instance GHC.Internal.Data.Foldable.Foldable GHC.Internal.Data.Semigroup.Internal.Dual -- Defined in ‘GHC.Internal.Data.Foldable’
instance forall a. GHC.Internal.Data.Foldable.Foldable (GHC.Internal.Data.Either.Either a) -- Defined in ‘GHC.Internal.Data.Foldable’
instance GHC.Internal.Data.Foldable.Foldable GHC.Internal.Data.Monoid.First -- Defined in ‘GHC.Internal.Data.Foldable’
instance GHC.Internal.Data.Foldable.Foldable GHC.Internal.Data.Monoid.Last -- Defined in ‘GHC.Internal.Data.Foldable’
instance GHC.Internal.Data.Foldable.Foldable [] -- Defined in ‘GHC.Internal.Data.Foldable’
instance GHC.Internal.Data.Foldable.Foldable GHC.Internal.Maybe.Maybe -- Defined in ‘GHC.Internal.Data.Foldable’
instance GHC.Internal.Data.Foldable.Foldable GHC.Internal.Base.NonEmpty -- Defined in ‘GHC.Internal.Data.Foldable’
instance GHC.Internal.Data.Foldable.Foldable GHC.Internal.Generics.Par1 -- Defined in ‘GHC.Internal.Data.Foldable’
instance GHC.Internal.Data.Foldable.Foldable GHC.Internal.Data.Semigroup.Internal.Product -- Defined in ‘GHC.Internal.Data.Foldable’
instance GHC.Internal.Data.Foldable.Foldable Solo -- Defined in ‘GHC.Internal.Data.Foldable’
instance GHC.Internal.Data.Foldable.Foldable GHC.Internal.Data.Semigroup.Internal.Sum -- Defined in ‘GHC.Internal.Data.Foldable’
instance forall a. GHC.Internal.Data.Foldable.Foldable ((,) a) -- Defined in ‘GHC.Internal.Data.Foldable’
instance GHC.Internal.Data.Foldable.Foldable Data.Complex.Complex -- Defined in ‘Data.Complex’
instance GHC.Internal.Data.Foldable.Foldable GHC.Internal.Data.Functor.Identity.Identity -- Defined in ‘GHC.Internal.Data.Functor.Identity’
instance forall a. GHC.Internal.Data.Foldable.Foldable (Data.Semigroup.Arg a) -- Defined in ‘Data.Semigroup’
instance GHC.Internal.Data.Foldable.Foldable Data.Semigroup.First -- Defined in ‘Data.Semigroup’
instance GHC.Internal.Data.Foldable.Foldable Data.Semigroup.Last -- Defined in ‘Data.Semigroup’
instance GHC.Internal.Data.Foldable.Foldable Data.Semigroup.Max -- Defined in ‘Data.Semigroup’
instance GHC.Internal.Data.Foldable.Foldable Data.Semigroup.Min -- Defined in ‘Data.Semigroup’
instance forall a k (b :: k). GHC.Internal.Data.String.IsString a => GHC.Internal.Data.String.IsString (GHC.Internal.Data.Functor.Const.Const a b) -- Defined in ‘GHC.Internal.Data.String’
instance forall a. GHC.Internal.Data.String.IsString a => GHC.Internal.Data.String.IsString (GHC.Internal.Data.Functor.Identity.Identity a) -- Defined in ‘GHC.Internal.Data.String’
instance forall a. (a ~ GHC.Types.Char) => GHC.Internal.Data.String.IsString [a] -- Defined in ‘GHC.Internal.Data.String’
instance GHC.Internal.Data.Traversable.Traversable GHC.Internal.Functor.ZipList.ZipList -- Defined in ‘GHC.Internal.Functor.ZipList’
instance forall i. GHC.Internal.Ix.Ix i => GHC.Internal.Data.Traversable.Traversable (GHC.Internal.Arr.Array i) -- Defined in ‘GHC.Internal.Data.Traversable’
instance GHC.Internal.Data.Traversable.Traversable GHC.Internal.Data.Ord.Down -- Defined in ‘GHC.Internal.Data.Traversable’
instance GHC.Internal.Data.Traversable.Traversable GHC.Internal.Data.Semigroup.Internal.Dual -- Defined in ‘GHC.Internal.Data.Traversable’
instance forall a. GHC.Internal.Data.Traversable.Traversable (GHC.Internal.Data.Either.Either a) -- Defined in ‘GHC.Internal.Data.Traversable’
instance GHC.Internal.Data.Traversable.Traversable GHC.Internal.Data.Monoid.First -- Defined in ‘GHC.Internal.Data.Traversable’
instance GHC.Internal.Data.Traversable.Traversable GHC.Internal.Data.Functor.Identity.Identity -- Defined in ‘GHC.Internal.Data.Traversable’
instance GHC.Internal.Data.Traversable.Traversable GHC.Internal.Data.Monoid.Last -- Defined in ‘GHC.Internal.Data.Traversable’
instance GHC.Internal.Data.Traversable.Traversable [] -- Defined in ‘GHC.Internal.Data.Traversable’
instance GHC.Internal.Data.Traversable.Traversable GHC.Internal.Maybe.Maybe -- Defined in ‘GHC.Internal.Data.Traversable’
instance GHC.Internal.Data.Traversable.Traversable GHC.Internal.Base.NonEmpty -- Defined in ‘GHC.Internal.Data.Traversable’
instance GHC.Internal.Data.Traversable.Traversable GHC.Internal.Generics.Par1 -- Defined in ‘GHC.Internal.Data.Traversable’
instance GHC.Internal.Data.Traversable.Traversable GHC.Internal.Data.Semigroup.Internal.Product -- Defined in ‘GHC.Internal.Data.Traversable’
instance GHC.Internal.Data.Traversable.Traversable Solo -- Defined in ‘GHC.Internal.Data.Traversable’
instance GHC.Internal.Data.Traversable.Traversable GHC.Internal.Data.Semigroup.Internal.Sum -- Defined in ‘GHC.Internal.Data.Traversable’
instance forall a. GHC.Internal.Data.Traversable.Traversable ((,) a) -- Defined in ‘GHC.Internal.Data.Traversable’
instance GHC.Internal.Data.Traversable.Traversable Data.Complex.Complex -- Defined in ‘Data.Complex’
instance forall a. GHC.Internal.Data.Traversable.Traversable (Data.Semigroup.Arg a) -- Defined in ‘Data.Semigroup’
instance GHC.Internal.Data.Traversable.Traversable Data.Semigroup.First -- Defined in ‘Data.Semigroup’
instance GHC.Internal.Data.Traversable.Traversable Data.Semigroup.Last -- Defined in ‘Data.Semigroup’
instance GHC.Internal.Data.Traversable.Traversable Data.Semigroup.Max -- Defined in ‘Data.Semigroup’
instance GHC.Internal.Data.Traversable.Traversable Data.Semigroup.Min -- Defined in ‘Data.Semigroup’
instance GHC.Internal.Data.Type.Coercion.TestCoercion GHC.Internal.TypeNats.SNat -- Defined in ‘GHC.Internal.TypeNats’
instance GHC.Internal.Data.Type.Coercion.TestCoercion GHC.Internal.TypeLits.SChar -- Defined in ‘GHC.Internal.TypeLits’
instance GHC.Internal.Data.Type.Coercion.TestCoercion GHC.Internal.TypeLits.SSymbol -- Defined in ‘GHC.Internal.TypeLits’
instance forall k (a :: k). GHC.Internal.Data.Type.Coercion.TestCoercion ((GHC.Internal.Data.Type.Equality.:~:) a) -- Defined in ‘GHC.Internal.Data.Type.Coercion’
instance forall k1 k (a :: k1). GHC.Internal.Data.Type.Coercion.TestCoercion ((GHC.Internal.Data.Type.Equality.:~~:) a) -- Defined in ‘GHC.Internal.Data.Type.Coercion’
instance forall k (a :: k). GHC.Internal.Data.Type.Coercion.TestCoercion (GHC.Internal.Data.Type.Coercion.Coercion a) -- Defined in ‘GHC.Internal.Data.Type.Coercion’
instance GHC.Internal.Data.Type.Equality.TestEquality GHC.Internal.TypeNats.SNat -- Defined in ‘GHC.Internal.TypeNats’
instance GHC.Internal.Data.Type.Equality.TestEquality GHC.Internal.TypeLits.SChar -- Defined in ‘GHC.Internal.TypeLits’
instance GHC.Internal.Data.Type.Equality.TestEquality GHC.Internal.TypeLits.SSymbol -- Defined in ‘GHC.Internal.TypeLits’
instance forall k (a :: k). GHC.Internal.Data.Type.Equality.TestEquality ((GHC.Internal.Data.Type.Equality.:~:) a) -- Defined in ‘GHC.Internal.Data.Type.Equality’
instance forall k1 k (a :: k1). GHC.Internal.Data.Type.Equality.TestEquality ((GHC.Internal.Data.Type.Equality.:~~:) a) -- Defined in ‘GHC.Internal.Data.Type.Equality’
instance forall k. GHC.Internal.Data.Type.Equality.TestEquality ghc-internal-0.1.0.0:GHC.Internal.Data.Typeable.Internal.TypeRep -- Defined in ‘ghc-internal-0.1.0.0:GHC.Internal.Data.Typeable.Internal’
instance forall k1 k2 (f :: k1 -> *) (g :: k2 -> k1). GHC.Internal.Data.Type.Equality.TestEquality f => GHC.Internal.Data.Type.Equality.TestEquality (Data.Functor.Compose.Compose f g) -- Defined in ‘Data.Functor.Compose’
instance forall a k (b :: k). GHC.Internal.Enum.Bounded a => GHC.Internal.Enum.Bounded (GHC.Internal.Data.Functor.Const.Const a b) -- Defined in ‘GHC.Internal.Data.Functor.Const’
instance forall a. GHC.Internal.Enum.Bounded a => GHC.Internal.Enum.Bounded (GHC.Internal.Data.Bits.And a) -- Defined in ‘GHC.Internal.Data.Bits’
instance forall a. GHC.Internal.Enum.Bounded a => GHC.Internal.Enum.Bounded (GHC.Internal.Data.Bits.Iff a) -- Defined in ‘GHC.Internal.Data.Bits’
instance forall a. GHC.Internal.Enum.Bounded a => GHC.Internal.Enum.Bounded (GHC.Internal.Data.Bits.Ior a) -- Defined in ‘GHC.Internal.Data.Bits’
instance forall a. GHC.Internal.Enum.Bounded a => GHC.Internal.Enum.Bounded (GHC.Internal.Data.Bits.Xor a) -- Defined in ‘GHC.Internal.Data.Bits’
instance GHC.Internal.Enum.Bounded GHC.Internal.Unicode.GeneralCategory -- Defined in ‘GHC.Internal.Unicode’
instance forall k (a :: k) (b :: k). (a ~ b) => GHC.Internal.Enum.Bounded (a GHC.Internal.Data.Type.Equality.:~: b) -- Defined in ‘GHC.Internal.Data.Type.Equality’
instance forall k1 k2 (a :: k1) (b :: k2). (a ~~ b) => GHC.Internal.Enum.Bounded (a GHC.Internal.Data.Type.Equality.:~~: b) -- Defined in ‘GHC.Internal.Data.Type.Equality’
instance forall k (t :: k). GHC.Internal.Enum.Bounded (GHC.Internal.Data.Proxy.Proxy t) -- Defined in ‘GHC.Internal.Data.Proxy’
instance GHC.Internal.Enum.Bounded GHC.Types.Bool -- Defined in ‘GHC.Internal.Enum’
instance GHC.Internal.Enum.Bounded GHC.Types.Char -- Defined in ‘GHC.Internal.Enum’
instance GHC.Internal.Enum.Bounded GHC.Types.Int -- Defined in ‘GHC.Internal.Enum’
instance GHC.Internal.Enum.Bounded GHC.Types.Levity -- Defined in ‘GHC.Internal.Enum’
instance GHC.Internal.Enum.Bounded GHC.Types.Ordering -- Defined in ‘GHC.Internal.Enum’
instance forall a. GHC.Internal.Enum.Bounded a => GHC.Internal.Enum.Bounded (Solo a) -- Defined in ‘GHC.Internal.Enum’
instance forall a b c d e f g h i j. (GHC.Internal.Enum.Bounded a, GHC.Internal.Enum.Bounded b, GHC.Internal.Enum.Bounded c, GHC.Internal.Enum.Bounded d, GHC.Internal.Enum.Bounded e, GHC.Internal.Enum.Bounded f, GHC.Internal.Enum.Bounded g, GHC.Internal.Enum.Bounded h, GHC.Internal.Enum.Bounded i, GHC.Internal.Enum.Bounded j) => GHC.Internal.Enum.Bounded (a, b, c, d, e, f, g, h, i, j) -- Defined in ‘GHC.Internal.Enum’
instance forall a b c d e f g h i j k. (GHC.Internal.Enum.Bounded a, GHC.Internal.Enum.Bounded b, GHC.Internal.Enum.Bounded c, GHC.Internal.Enum.Bounded d, GHC.Internal.Enum.Bounded e, GHC.Internal.Enum.Bounded f, GHC.Internal.Enum.Bounded g, GHC.Internal.Enum.Bounded h, GHC.Internal.Enum.Bounded i, GHC.Internal.Enum.Bounded j, GHC.Internal.Enum.Bounded k) => GHC.Internal.Enum.Bounded (a, b, c, d, e, f, g, h, i, j, k) -- Defined in ‘GHC.Internal.Enum’
instance forall a b c d e f g h i j k l. (GHC.Internal.Enum.Bounded a, GHC.Internal.Enum.Bounded b, GHC.Internal.Enum.Bounded c, GHC.Internal.Enum.Bounded d, GHC.Internal.Enum.Bounded e, GHC.Internal.Enum.Bounded f, GHC.Internal.Enum.Bounded g, GHC.Internal.Enum.Bounded h, GHC.Internal.Enum.Bounded i, GHC.Internal.Enum.Bounded j, GHC.Internal.Enum.Bounded k, GHC.Internal.Enum.Bounded l) => GHC.Internal.Enum.Bounded (a, b, c, d, e, f, g, h, i, j, k, l) -- Defined in ‘GHC.Internal.Enum’
instance forall a b c d e f g h i j k l m. (GHC.Internal.Enum.Bounded a, GHC.Internal.Enum.Bounded b, GHC.Internal.Enum.Bounded c, GHC.Internal.Enum.Bounded d, GHC.Internal.Enum.Bounded e, GHC.Internal.Enum.Bounded f, GHC.Internal.Enum.Bounded g, GHC.Internal.Enum.Bounded h, GHC.Internal.Enum.Bounded i, GHC.Internal.Enum.Bounded j, GHC.Internal.Enum.Bounded k, GHC.Internal.Enum.Bounded l, GHC.Internal.Enum.Bounded m) => GHC.Internal.Enum.Bounded (a, b, c, d, e, f, g, h, i, j, k, l, m) -- Defined in ‘GHC.Internal.Enum’
instance forall a b c d e f g h i j k l m n. (GHC.Internal.Enum.Bounded a, GHC.Internal.Enum.Bounded b, GHC.Internal.Enum.Bounded c, GHC.Internal.Enum.Bounded d, GHC.Internal.Enum.Bounded e, GHC.Internal.Enum.Bounded f, GHC.Internal.Enum.Bounded g, GHC.Internal.Enum.Bounded h, GHC.Internal.Enum.Bounded i, GHC.Internal.Enum.Bounded j, GHC.Internal.Enum.Bounded k, GHC.Internal.Enum.Bounded l, GHC.Internal.Enum.Bounded m, GHC.Internal.Enum.Bounded n) => GHC.Internal.Enum.Bounded (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -- Defined in ‘GHC.Internal.Enum’
instance forall a b c d e f g h i j k l m n o. (GHC.Internal.Enum.Bounded a, GHC.Internal.Enum.Bounded b, GHC.Internal.Enum.Bounded c, GHC.Internal.Enum.Bounded d, GHC.Internal.Enum.Bounded e, GHC.Internal.Enum.Bounded f, GHC.Internal.Enum.Bounded g, GHC.Internal.Enum.Bounded h, GHC.Internal.Enum.Bounded i, GHC.Internal.Enum.Bounded j, GHC.Internal.Enum.Bounded k, GHC.Internal.Enum.Bounded l, GHC.Internal.Enum.Bounded m, GHC.Internal.Enum.Bounded n, GHC.Internal.Enum.Bounded o) => GHC.Internal.Enum.Bounded (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -- Defined in ‘GHC.Internal.Enum’
instance forall a b. (GHC.Internal.Enum.Bounded a, GHC.Internal.Enum.Bounded b) => GHC.Internal.Enum.Bounded (a, b) -- Defined in ‘GHC.Internal.Enum’
instance forall a b c. (GHC.Internal.Enum.Bounded a, GHC.Internal.Enum.Bounded b, GHC.Internal.Enum.Bounded c) => GHC.Internal.Enum.Bounded (a, b, c) -- Defined in ‘GHC.Internal.Enum’
instance forall a b c d. (GHC.Internal.Enum.Bounded a, GHC.Internal.Enum.Bounded b, GHC.Internal.Enum.Bounded c, GHC.Internal.Enum.Bounded d) => GHC.Internal.Enum.Bounded (a, b, c, d) -- Defined in ‘GHC.Internal.Enum’
instance forall a b c d e. (GHC.Internal.Enum.Bounded a, GHC.Internal.Enum.Bounded b, GHC.Internal.Enum.Bounded c, GHC.Internal.Enum.Bounded d, GHC.Internal.Enum.Bounded e) => GHC.Internal.Enum.Bounded (a, b, c, d, e) -- Defined in ‘GHC.Internal.Enum’
instance forall a b c d e f. (GHC.Internal.Enum.Bounded a, GHC.Internal.Enum.Bounded b, GHC.Internal.Enum.Bounded c, GHC.Internal.Enum.Bounded d, GHC.Internal.Enum.Bounded e, GHC.Internal.Enum.Bounded f) => GHC.Internal.Enum.Bounded (a, b, c, d, e, f) -- Defined in ‘GHC.Internal.Enum’
instance forall a b c d e f g. (GHC.Internal.Enum.Bounded a, GHC.Internal.Enum.Bounded b, GHC.Internal.Enum.Bounded c, GHC.Internal.Enum.Bounded d, GHC.Internal.Enum.Bounded e, GHC.Internal.Enum.Bounded f, GHC.Internal.Enum.Bounded g) => GHC.Internal.Enum.Bounded (a, b, c, d, e, f, g) -- Defined in ‘GHC.Internal.Enum’
instance forall a b c d e f g h. (GHC.Internal.Enum.Bounded a, GHC.Internal.Enum.Bounded b, GHC.Internal.Enum.Bounded c, GHC.Internal.Enum.Bounded d, GHC.Internal.Enum.Bounded e, GHC.Internal.Enum.Bounded f, GHC.Internal.Enum.Bounded g, GHC.Internal.Enum.Bounded h) => GHC.Internal.Enum.Bounded (a, b, c, d, e, f, g, h) -- Defined in ‘GHC.Internal.Enum’
instance forall a b c d e f g h i. (GHC.Internal.Enum.Bounded a, GHC.Internal.Enum.Bounded b, GHC.Internal.Enum.Bounded c, GHC.Internal.Enum.Bounded d, GHC.Internal.Enum.Bounded e, GHC.Internal.Enum.Bounded f, GHC.Internal.Enum.Bounded g, GHC.Internal.Enum.Bounded h, GHC.Internal.Enum.Bounded i) => GHC.Internal.Enum.Bounded (a, b, c, d, e, f, g, h, i) -- Defined in ‘GHC.Internal.Enum’
instance GHC.Internal.Enum.Bounded () -- Defined in ‘GHC.Internal.Enum’
instance GHC.Internal.Enum.Bounded GHC.Types.VecCount -- Defined in ‘GHC.Internal.Enum’
instance GHC.Internal.Enum.Bounded GHC.Types.VecElem -- Defined in ‘GHC.Internal.Enum’
instance GHC.Internal.Enum.Bounded GHC.Types.Word -- Defined in ‘GHC.Internal.Enum’
instance forall k1 k2 (f :: k1 -> *) (g :: k2 -> k1) (a :: k2). GHC.Internal.Enum.Bounded (f (g a)) => GHC.Internal.Enum.Bounded (Data.Functor.Compose.Compose f g a) -- Defined in ‘Data.Functor.Compose’
instance forall a. GHC.Internal.Enum.Bounded a => GHC.Internal.Enum.Bounded (GHC.Internal.Data.Functor.Identity.Identity a) -- Defined in ‘GHC.Internal.Data.Functor.Identity’
instance GHC.Internal.Enum.Bounded GHC.Internal.Int.Int16 -- Defined in ‘GHC.Internal.Int’
instance GHC.Internal.Enum.Bounded GHC.Internal.Int.Int32 -- Defined in ‘GHC.Internal.Int’
instance GHC.Internal.Enum.Bounded GHC.Internal.Int.Int64 -- Defined in ‘GHC.Internal.Int’
instance GHC.Internal.Enum.Bounded GHC.Internal.Int.Int8 -- Defined in ‘GHC.Internal.Int’
instance GHC.Internal.Enum.Bounded GHC.Internal.Data.Semigroup.Internal.All -- Defined in ‘GHC.Internal.Data.Semigroup.Internal’
instance GHC.Internal.Enum.Bounded GHC.Internal.Data.Semigroup.Internal.Any -- Defined in ‘GHC.Internal.Data.Semigroup.Internal’
instance forall a. GHC.Internal.Enum.Bounded a => GHC.Internal.Enum.Bounded (GHC.Internal.Data.Semigroup.Internal.Dual a) -- Defined in ‘GHC.Internal.Data.Semigroup.Internal’
instance forall a. GHC.Internal.Enum.Bounded a => GHC.Internal.Enum.Bounded (GHC.Internal.Data.Semigroup.Internal.Product a) -- Defined in ‘GHC.Internal.Data.Semigroup.Internal’
instance forall a. GHC.Internal.Enum.Bounded a => GHC.Internal.Enum.Bounded (GHC.Internal.Data.Semigroup.Internal.Sum a) -- Defined in ‘GHC.Internal.Data.Semigroup.Internal’
instance forall a. GHC.Internal.Enum.Bounded a => GHC.Internal.Enum.Bounded (GHC.Internal.Data.Ord.Down a) -- Defined in ‘GHC.Internal.Data.Ord’
instance forall a. GHC.Internal.Enum.Bounded a => GHC.Internal.Enum.Bounded (Data.Semigroup.First a) -- Defined in ‘Data.Semigroup’
instance forall a. GHC.Internal.Enum.Bounded a => GHC.Internal.Enum.Bounded (Data.Semigroup.Last a) -- Defined in ‘Data.Semigroup’
instance forall a. GHC.Internal.Enum.Bounded a => GHC.Internal.Enum.Bounded (Data.Semigroup.Max a) -- Defined in ‘Data.Semigroup’
instance forall a. GHC.Internal.Enum.Bounded a => GHC.Internal.Enum.Bounded (Data.Semigroup.Min a) -- Defined in ‘Data.Semigroup’
instance forall m. GHC.Internal.Enum.Bounded m => GHC.Internal.Enum.Bounded (Data.Semigroup.WrappedMonoid m) -- Defined in ‘Data.Semigroup’
instance forall k (a :: k) (b :: k). Coercible a b => GHC.Internal.Enum.Bounded (GHC.Internal.Data.Type.Coercion.Coercion a b) -- Defined in ‘GHC.Internal.Data.Type.Coercion’
instance GHC.Internal.Enum.Bounded GHC.Internal.Word.Word16 -- Defined in ‘GHC.Internal.Word’
instance GHC.Internal.Enum.Bounded GHC.Internal.Word.Word32 -- Defined in ‘GHC.Internal.Word’
instance GHC.Internal.Enum.Bounded GHC.Internal.Word.Word64 -- Defined in ‘GHC.Internal.Word’
instance GHC.Internal.Enum.Bounded GHC.Internal.Word.Word8 -- Defined in ‘GHC.Internal.Word’
instance GHC.Internal.Enum.Bounded GHC.Internal.Foreign.Ptr.IntPtr -- Defined in ‘GHC.Internal.Foreign.Ptr’
instance GHC.Internal.Enum.Bounded GHC.Internal.Foreign.Ptr.WordPtr -- Defined in ‘GHC.Internal.Foreign.Ptr’
instance GHC.Internal.Enum.Bounded GHC.Internal.Foreign.C.Types.CBool -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Enum.Bounded GHC.Internal.Foreign.C.Types.CChar -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Enum.Bounded GHC.Internal.Foreign.C.Types.CInt -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Enum.Bounded GHC.Internal.Foreign.C.Types.CIntMax -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Enum.Bounded GHC.Internal.Foreign.C.Types.CIntPtr -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Enum.Bounded GHC.Internal.Foreign.C.Types.CLLong -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Enum.Bounded GHC.Internal.Foreign.C.Types.CLong -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Enum.Bounded GHC.Internal.Foreign.C.Types.CPtrdiff -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Enum.Bounded GHC.Internal.Foreign.C.Types.CSChar -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Enum.Bounded GHC.Internal.Foreign.C.Types.CShort -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Enum.Bounded GHC.Internal.Foreign.C.Types.CSigAtomic -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Enum.Bounded GHC.Internal.Foreign.C.Types.CSize -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Enum.Bounded GHC.Internal.Foreign.C.Types.CUChar -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Enum.Bounded GHC.Internal.Foreign.C.Types.CUInt -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Enum.Bounded GHC.Internal.Foreign.C.Types.CUIntMax -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Enum.Bounded GHC.Internal.Foreign.C.Types.CUIntPtr -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Enum.Bounded GHC.Internal.Foreign.C.Types.CULLong -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Enum.Bounded GHC.Internal.Foreign.C.Types.CULong -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Enum.Bounded GHC.Internal.Foreign.C.Types.CUShort -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Enum.Bounded GHC.Internal.Foreign.C.Types.CWchar -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Enum.Bounded GHC.Internal.ByteOrder.ByteOrder -- Defined in ‘GHC.Internal.ByteOrder’
instance GHC.Internal.Enum.Bounded GHC.Internal.Generics.Associativity -- Defined in ‘GHC.Internal.Generics’
instance GHC.Internal.Enum.Bounded GHC.Internal.Generics.DecidedStrictness -- Defined in ‘GHC.Internal.Generics’
instance GHC.Internal.Enum.Bounded GHC.Internal.Generics.SourceStrictness -- Defined in ‘GHC.Internal.Generics’
instance GHC.Internal.Enum.Bounded GHC.Internal.Generics.SourceUnpackedness -- Defined in ‘GHC.Internal.Generics’
instance forall a k (b :: k). GHC.Internal.Enum.Enum a => GHC.Internal.Enum.Enum (GHC.Internal.Data.Functor.Const.Const a b) -- Defined in ‘GHC.Internal.Data.Functor.Const’
instance forall a. GHC.Internal.Enum.Enum a => GHC.Internal.Enum.Enum (GHC.Internal.Data.Bits.And a) -- Defined in ‘GHC.Internal.Data.Bits’
instance forall a. GHC.Internal.Enum.Enum a => GHC.Internal.Enum.Enum (GHC.Internal.Data.Bits.Iff a) -- Defined in ‘GHC.Internal.Data.Bits’
instance forall a. GHC.Internal.Enum.Enum a => GHC.Internal.Enum.Enum (GHC.Internal.Data.Bits.Ior a) -- Defined in ‘GHC.Internal.Data.Bits’
instance forall a. GHC.Internal.Enum.Enum a => GHC.Internal.Enum.Enum (GHC.Internal.Data.Bits.Xor a) -- Defined in ‘GHC.Internal.Data.Bits’
instance GHC.Internal.Enum.Enum GHC.Internal.Unicode.GeneralCategory -- Defined in ‘GHC.Internal.Unicode’
instance forall k (a :: k) (b :: k). (a ~ b) => GHC.Internal.Enum.Enum (a GHC.Internal.Data.Type.Equality.:~: b) -- Defined in ‘GHC.Internal.Data.Type.Equality’
instance forall k1 k2 (a :: k1) (b :: k2). (a ~~ b) => GHC.Internal.Enum.Enum (a GHC.Internal.Data.Type.Equality.:~~: b) -- Defined in ‘GHC.Internal.Data.Type.Equality’
instance forall k (s :: k). GHC.Internal.Enum.Enum (GHC.Internal.Data.Proxy.Proxy s) -- Defined in ‘GHC.Internal.Data.Proxy’
instance GHC.Internal.Enum.Enum GHC.Types.Bool -- Defined in ‘GHC.Internal.Enum’
instance GHC.Internal.Enum.Enum GHC.Types.Char -- Defined in ‘GHC.Internal.Enum’
instance GHC.Internal.Enum.Enum GHC.Types.Int -- Defined in ‘GHC.Internal.Enum’
instance GHC.Internal.Enum.Enum GHC.Num.Integer.Integer -- Defined in ‘GHC.Internal.Enum’
instance GHC.Internal.Enum.Enum GHC.Types.Levity -- Defined in ‘GHC.Internal.Enum’
instance GHC.Internal.Enum.Enum GHC.Num.Natural.Natural -- Defined in ‘GHC.Internal.Enum’
instance GHC.Internal.Enum.Enum GHC.Types.Ordering -- Defined in ‘GHC.Internal.Enum’
instance forall a. GHC.Internal.Enum.Enum a => GHC.Internal.Enum.Enum (Solo a) -- Defined in ‘GHC.Internal.Enum’
instance GHC.Internal.Enum.Enum () -- Defined in ‘GHC.Internal.Enum’
instance GHC.Internal.Enum.Enum GHC.Types.VecCount -- Defined in ‘GHC.Internal.Enum’
instance GHC.Internal.Enum.Enum GHC.Types.VecElem -- Defined in ‘GHC.Internal.Enum’
instance GHC.Internal.Enum.Enum GHC.Types.Word -- Defined in ‘GHC.Internal.Enum’
instance forall k (a :: k). GHC.Internal.Enum.Enum (Data.Fixed.Fixed a) -- Defined in ‘Data.Fixed’
instance forall k1 k2 (f :: k1 -> *) (g :: k2 -> k1) (a :: k2). GHC.Internal.Enum.Enum (f (g a)) => GHC.Internal.Enum.Enum (Data.Functor.Compose.Compose f g a) -- Defined in ‘Data.Functor.Compose’
instance forall a. GHC.Internal.Enum.Enum a => GHC.Internal.Enum.Enum (GHC.Internal.Data.Functor.Identity.Identity a) -- Defined in ‘GHC.Internal.Data.Functor.Identity’
instance GHC.Internal.Enum.Enum GHC.Internal.Int.Int16 -- Defined in ‘GHC.Internal.Int’
instance GHC.Internal.Enum.Enum GHC.Internal.Int.Int32 -- Defined in ‘GHC.Internal.Int’
instance GHC.Internal.Enum.Enum GHC.Internal.Int.Int64 -- Defined in ‘GHC.Internal.Int’
instance GHC.Internal.Enum.Enum GHC.Internal.Int.Int8 -- Defined in ‘GHC.Internal.Int’
instance forall k (f :: k -> *) (a :: k). GHC.Internal.Enum.Enum (f a) => GHC.Internal.Enum.Enum (GHC.Internal.Data.Semigroup.Internal.Alt f a) -- Defined in ‘GHC.Internal.Data.Semigroup.Internal’
instance forall k (f :: k -> *) (a :: k). GHC.Internal.Enum.Enum (f a) => GHC.Internal.Enum.Enum (GHC.Internal.Data.Monoid.Ap f a) -- Defined in ‘GHC.Internal.Data.Monoid’
instance forall a. (GHC.Internal.Enum.Enum a, GHC.Internal.Enum.Bounded a, GHC.Classes.Eq a) => GHC.Internal.Enum.Enum (GHC.Internal.Data.Ord.Down a) -- Defined in ‘GHC.Internal.Data.Ord’
instance forall a. GHC.Internal.Real.Integral a => GHC.Internal.Enum.Enum (GHC.Internal.Real.Ratio a) -- Defined in ‘GHC.Internal.Real’
instance forall a. GHC.Internal.Enum.Enum a => GHC.Internal.Enum.Enum (Data.Semigroup.First a) -- Defined in ‘Data.Semigroup’
instance forall a. GHC.Internal.Enum.Enum a => GHC.Internal.Enum.Enum (Data.Semigroup.Last a) -- Defined in ‘Data.Semigroup’
instance forall a. GHC.Internal.Enum.Enum a => GHC.Internal.Enum.Enum (Data.Semigroup.Max a) -- Defined in ‘Data.Semigroup’
instance forall a. GHC.Internal.Enum.Enum a => GHC.Internal.Enum.Enum (Data.Semigroup.Min a) -- Defined in ‘Data.Semigroup’
instance forall a. GHC.Internal.Enum.Enum a => GHC.Internal.Enum.Enum (Data.Semigroup.WrappedMonoid a) -- Defined in ‘Data.Semigroup’
instance forall k (a :: k) (b :: k). Coercible a b => GHC.Internal.Enum.Enum (GHC.Internal.Data.Type.Coercion.Coercion a b) -- Defined in ‘GHC.Internal.Data.Type.Coercion’
instance GHC.Internal.Enum.Enum GHC.Internal.Word.Word16 -- Defined in ‘GHC.Internal.Word’
instance GHC.Internal.Enum.Enum GHC.Internal.Word.Word32 -- Defined in ‘GHC.Internal.Word’
instance GHC.Internal.Enum.Enum GHC.Internal.Word.Word64 -- Defined in ‘GHC.Internal.Word’
instance GHC.Internal.Enum.Enum GHC.Internal.Word.Word8 -- Defined in ‘GHC.Internal.Word’
instance GHC.Internal.Enum.Enum GHC.Internal.Foreign.Ptr.IntPtr -- Defined in ‘GHC.Internal.Foreign.Ptr’
instance GHC.Internal.Enum.Enum GHC.Internal.Foreign.Ptr.WordPtr -- Defined in ‘GHC.Internal.Foreign.Ptr’
instance GHC.Internal.Enum.Enum GHC.Internal.Foreign.C.Types.CBool -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Enum.Enum GHC.Internal.Foreign.C.Types.CChar -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Enum.Enum GHC.Internal.Foreign.C.Types.CClock -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Enum.Enum GHC.Internal.Foreign.C.Types.CDouble -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Enum.Enum GHC.Internal.Foreign.C.Types.CFloat -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Enum.Enum GHC.Internal.Foreign.C.Types.CInt -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Enum.Enum GHC.Internal.Foreign.C.Types.CIntMax -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Enum.Enum GHC.Internal.Foreign.C.Types.CIntPtr -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Enum.Enum GHC.Internal.Foreign.C.Types.CLLong -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Enum.Enum GHC.Internal.Foreign.C.Types.CLong -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Enum.Enum GHC.Internal.Foreign.C.Types.CPtrdiff -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Enum.Enum GHC.Internal.Foreign.C.Types.CSChar -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Enum.Enum GHC.Internal.Foreign.C.Types.CSUSeconds -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Enum.Enum GHC.Internal.Foreign.C.Types.CShort -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Enum.Enum GHC.Internal.Foreign.C.Types.CSigAtomic -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Enum.Enum GHC.Internal.Foreign.C.Types.CSize -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Enum.Enum GHC.Internal.Foreign.C.Types.CTime -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Enum.Enum GHC.Internal.Foreign.C.Types.CUChar -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Enum.Enum GHC.Internal.Foreign.C.Types.CUInt -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Enum.Enum GHC.Internal.Foreign.C.Types.CUIntMax -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Enum.Enum GHC.Internal.Foreign.C.Types.CUIntPtr -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Enum.Enum GHC.Internal.Foreign.C.Types.CULLong -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Enum.Enum GHC.Internal.Foreign.C.Types.CULong -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Enum.Enum GHC.Internal.Foreign.C.Types.CUSeconds -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Enum.Enum GHC.Internal.Foreign.C.Types.CUShort -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Enum.Enum GHC.Internal.Foreign.C.Types.CWchar -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Enum.Enum GHC.Internal.ByteOrder.ByteOrder -- Defined in ‘GHC.Internal.ByteOrder’
instance GHC.Internal.Enum.Enum GHC.Types.Double -- Defined in ‘GHC.Internal.Float’
instance GHC.Internal.Enum.Enum GHC.Types.Float -- Defined in ‘GHC.Internal.Float’
instance GHC.Internal.Enum.Enum GHC.Internal.Generics.Associativity -- Defined in ‘GHC.Internal.Generics’
instance GHC.Internal.Enum.Enum GHC.Internal.Generics.DecidedStrictness -- Defined in ‘GHC.Internal.Generics’
instance GHC.Internal.Enum.Enum GHC.Internal.Generics.SourceStrictness -- Defined in ‘GHC.Internal.Generics’
instance GHC.Internal.Enum.Enum GHC.Internal.Generics.SourceUnpackedness -- Defined in ‘GHC.Internal.Generics’
instance GHC.Internal.Enum.Enum GHC.Internal.IO.Device.SeekMode -- Defined in ‘GHC.Internal.IO.Device’
instance GHC.Internal.Enum.Enum GHC.Internal.IO.IOMode.IOMode -- Defined in ‘GHC.Internal.IO.IOMode’
instance GHC.Internal.Enum.Enum GHC.Internal.RTS.Flags.DoCostCentres -- Defined in ‘GHC.Internal.RTS.Flags’
instance GHC.Internal.Enum.Enum GHC.Internal.RTS.Flags.DoHeapProfile -- Defined in ‘GHC.Internal.RTS.Flags’
instance GHC.Internal.Enum.Enum GHC.Internal.RTS.Flags.DoTrace -- Defined in ‘GHC.Internal.RTS.Flags’
instance GHC.Internal.Enum.Enum GHC.Internal.RTS.Flags.GiveGCStats -- Defined in ‘GHC.Internal.RTS.Flags’
instance GHC.Internal.Enum.Enum GHC.Internal.RTS.Flags.IoSubSystem -- Defined in ‘GHC.Internal.RTS.Flags’
instance GHC.Internal.Exception.Context.ExceptionAnnotation GHC.Internal.Exception.Backtrace.Backtraces -- Defined in ‘GHC.Internal.Exception.Backtrace’
instance GHC.Internal.Exception.Type.Exception GHC.Internal.IO.Exception.AllocationLimitExceeded -- Defined in ‘GHC.Internal.IO.Exception’
instance GHC.Internal.Exception.Type.Exception GHC.Internal.IO.Exception.ArrayException -- Defined in ‘GHC.Internal.IO.Exception’
instance GHC.Internal.Exception.Type.Exception GHC.Internal.IO.Exception.AssertionFailed -- Defined in ‘GHC.Internal.IO.Exception’
instance GHC.Internal.Exception.Type.Exception GHC.Internal.IO.Exception.AsyncException -- Defined in ‘GHC.Internal.IO.Exception’
instance GHC.Internal.Exception.Type.Exception GHC.Internal.IO.Exception.BlockedIndefinitelyOnMVar -- Defined in ‘GHC.Internal.IO.Exception’
instance GHC.Internal.Exception.Type.Exception GHC.Internal.IO.Exception.BlockedIndefinitelyOnSTM -- Defined in ‘GHC.Internal.IO.Exception’
instance GHC.Internal.Exception.Type.Exception GHC.Internal.IO.Exception.CompactionFailed -- Defined in ‘GHC.Internal.IO.Exception’
instance GHC.Internal.Exception.Type.Exception GHC.Internal.IO.Exception.Deadlock -- Defined in ‘GHC.Internal.IO.Exception’
instance GHC.Internal.Exception.Type.Exception GHC.Internal.IO.Exception.ExitCode -- Defined in ‘GHC.Internal.IO.Exception’
instance GHC.Internal.Exception.Type.Exception GHC.Internal.IO.Exception.FixIOException -- Defined in ‘GHC.Internal.IO.Exception’
instance GHC.Internal.Exception.Type.Exception GHC.Internal.IO.Exception.IOException -- Defined in ‘GHC.Internal.IO.Exception’
instance GHC.Internal.Exception.Type.Exception GHC.Internal.IO.Exception.SomeAsyncException -- Defined in ‘GHC.Internal.IO.Exception’
instance GHC.Internal.Exception.Type.Exception GHC.Internal.Exception.Type.ArithException -- Defined in ‘GHC.Internal.Exception.Type’
instance forall a. GHC.Internal.Exception.Type.Exception a => GHC.Internal.Exception.Type.Exception (GHC.Internal.Exception.Type.ExceptionWithContext a) -- Defined in ‘GHC.Internal.Exception.Type’
instance forall e. GHC.Internal.Exception.Type.Exception e => GHC.Internal.Exception.Type.Exception (GHC.Internal.Exception.Type.NoBacktrace e) -- Defined in ‘GHC.Internal.Exception.Type’
instance GHC.Internal.Exception.Type.Exception GHC.Internal.Exception.Type.SomeException -- Defined in ‘GHC.Internal.Exception.Type’
instance GHC.Internal.Exception.Type.Exception GHC.Internal.Base.Void -- Defined in ‘GHC.Internal.Exception.Type’
instance GHC.Internal.Exception.Type.Exception GHC.Internal.Exception.ErrorCall -- Defined in ‘GHC.Internal.Exception’
instance GHC.Internal.Exception.Type.Exception GHC.Internal.Control.Exception.Base.NestedAtomically -- Defined in ‘GHC.Internal.Control.Exception.Base’
instance GHC.Internal.Exception.Type.Exception GHC.Internal.Control.Exception.Base.NoMatchingContinuationPrompt -- Defined in ‘GHC.Internal.Control.Exception.Base’
instance GHC.Internal.Exception.Type.Exception GHC.Internal.Control.Exception.Base.NoMethodError -- Defined in ‘GHC.Internal.Control.Exception.Base’
instance GHC.Internal.Exception.Type.Exception GHC.Internal.Control.Exception.Base.NonTermination -- Defined in ‘GHC.Internal.Control.Exception.Base’
instance GHC.Internal.Exception.Type.Exception GHC.Internal.Control.Exception.Base.PatternMatchFail -- Defined in ‘GHC.Internal.Control.Exception.Base’
instance GHC.Internal.Exception.Type.Exception GHC.Internal.Control.Exception.Base.RecConError -- Defined in ‘GHC.Internal.Control.Exception.Base’
instance GHC.Internal.Exception.Type.Exception GHC.Internal.Control.Exception.Base.RecSelError -- Defined in ‘GHC.Internal.Control.Exception.Base’
instance GHC.Internal.Exception.Type.Exception GHC.Internal.Control.Exception.Base.RecUpdError -- Defined in ‘GHC.Internal.Control.Exception.Base’
instance GHC.Internal.Exception.Type.Exception GHC.Internal.Control.Exception.Base.TypeError -- Defined in ‘GHC.Internal.Control.Exception.Base’
instance GHC.Internal.Exception.Type.Exception GHC.Internal.Data.Dynamic.Dynamic -- Defined in ‘GHC.Internal.Data.Dynamic’
instance [safe] GHC.Internal.Exception.Type.Exception ghc-internal-0.1.0.0:GHC.Internal.IO.Handle.Lock.Common.FileLockingNotSupported -- Defined in ‘ghc-internal-0.1.0.0:GHC.Internal.IO.Handle.Lock.Common’
instance GHC.Internal.Exception.Type.Exception GHC.Internal.IOPort.IOPortException -- Defined in ‘GHC.Internal.IOPort’
instance [safe] GHC.Internal.Exception.Type.Exception System.Timeout.Timeout -- Defined in ‘System.Timeout’
instance forall a k (b :: k). GHC.Internal.Float.Floating a => GHC.Internal.Float.Floating (GHC.Internal.Data.Functor.Const.Const a b) -- Defined in ‘GHC.Internal.Data.Functor.Const’
instance forall a. GHC.Internal.Float.RealFloat a => GHC.Internal.Float.Floating (Data.Complex.Complex a) -- Defined in ‘Data.Complex’
instance forall k1 k2 (f :: k1 -> *) (g :: k2 -> k1) (a :: k2). GHC.Internal.Float.Floating (f (g a)) => GHC.Internal.Float.Floating (Data.Functor.Compose.Compose f g a) -- Defined in ‘Data.Functor.Compose’
instance forall a b. GHC.Internal.Float.Floating a => GHC.Internal.Float.Floating (Data.Functor.Contravariant.Op a b) -- Defined in ‘Data.Functor.Contravariant’
instance forall a. GHC.Internal.Float.Floating a => GHC.Internal.Float.Floating (GHC.Internal.Data.Functor.Identity.Identity a) -- Defined in ‘GHC.Internal.Data.Functor.Identity’
instance forall a. GHC.Internal.Float.Floating a => GHC.Internal.Float.Floating (GHC.Internal.Data.Ord.Down a) -- Defined in ‘GHC.Internal.Data.Ord’
instance GHC.Internal.Float.Floating GHC.Internal.Foreign.C.Types.CDouble -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Float.Floating GHC.Internal.Foreign.C.Types.CFloat -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Float.Floating GHC.Types.Double -- Defined in ‘GHC.Internal.Float’
instance GHC.Internal.Float.Floating GHC.Types.Float -- Defined in ‘GHC.Internal.Float’
instance forall a k (b :: k). GHC.Internal.Float.RealFloat a => GHC.Internal.Float.RealFloat (GHC.Internal.Data.Functor.Const.Const a b) -- Defined in ‘GHC.Internal.Data.Functor.Const’
instance forall k1 k2 (f :: k1 -> *) (g :: k2 -> k1) (a :: k2). GHC.Internal.Float.RealFloat (f (g a)) => GHC.Internal.Float.RealFloat (Data.Functor.Compose.Compose f g a) -- Defined in ‘Data.Functor.Compose’
instance forall a. GHC.Internal.Float.RealFloat a => GHC.Internal.Float.RealFloat (GHC.Internal.Data.Functor.Identity.Identity a) -- Defined in ‘GHC.Internal.Data.Functor.Identity’
instance forall a. GHC.Internal.Float.RealFloat a => GHC.Internal.Float.RealFloat (GHC.Internal.Data.Ord.Down a) -- Defined in ‘GHC.Internal.Data.Ord’
instance GHC.Internal.Float.RealFloat GHC.Internal.Foreign.C.Types.CDouble -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Float.RealFloat GHC.Internal.Foreign.C.Types.CFloat -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Float.RealFloat GHC.Types.Double -- Defined in ‘GHC.Internal.Float’
instance GHC.Internal.Float.RealFloat GHC.Types.Float -- Defined in ‘GHC.Internal.Float’
instance forall a k (b :: k). GHC.Internal.Foreign.Storable.Storable a => GHC.Internal.Foreign.Storable.Storable (GHC.Internal.Data.Functor.Const.Const a b) -- Defined in ‘GHC.Internal.Data.Functor.Const’
instance forall a. GHC.Internal.Foreign.Storable.Storable a => GHC.Internal.Foreign.Storable.Storable (Data.Complex.Complex a) -- Defined in ‘Data.Complex’
instance forall a. GHC.Internal.Foreign.Storable.Storable a => GHC.Internal.Foreign.Storable.Storable (GHC.Internal.Data.Functor.Identity.Identity a) -- Defined in ‘GHC.Internal.Data.Functor.Identity’
instance forall a. GHC.Internal.Foreign.Storable.Storable a => GHC.Internal.Foreign.Storable.Storable (GHC.Internal.Data.Ord.Down a) -- Defined in ‘GHC.Internal.Data.Ord’
instance GHC.Internal.Foreign.Storable.Storable GHC.Internal.Foreign.Ptr.IntPtr -- Defined in ‘GHC.Internal.Foreign.Ptr’
instance GHC.Internal.Foreign.Storable.Storable GHC.Internal.Foreign.Ptr.WordPtr -- Defined in ‘GHC.Internal.Foreign.Ptr’
instance GHC.Internal.Foreign.Storable.Storable GHC.Types.Bool -- Defined in ‘GHC.Internal.Foreign.Storable’
instance GHC.Internal.Foreign.Storable.Storable GHC.Types.Char -- Defined in ‘GHC.Internal.Foreign.Storable’
instance forall a. GHC.Internal.Foreign.Storable.Storable (GHC.Internal.Foreign.C.ConstPtr.ConstPtr a) -- Defined in ‘GHC.Internal.Foreign.Storable’
instance GHC.Internal.Foreign.Storable.Storable GHC.Types.Double -- Defined in ‘GHC.Internal.Foreign.Storable’
instance GHC.Internal.Foreign.Storable.Storable GHC.Internal.Fingerprint.Type.Fingerprint -- Defined in ‘GHC.Internal.Foreign.Storable’
instance GHC.Internal.Foreign.Storable.Storable GHC.Types.Float -- Defined in ‘GHC.Internal.Foreign.Storable’
instance forall a. GHC.Internal.Foreign.Storable.Storable (GHC.Internal.Ptr.FunPtr a) -- Defined in ‘GHC.Internal.Foreign.Storable’
instance GHC.Internal.Foreign.Storable.Storable GHC.Types.Int -- Defined in ‘GHC.Internal.Foreign.Storable’
instance GHC.Internal.Foreign.Storable.Storable GHC.Internal.Int.Int16 -- Defined in ‘GHC.Internal.Foreign.Storable’
instance GHC.Internal.Foreign.Storable.Storable GHC.Internal.Int.Int32 -- Defined in ‘GHC.Internal.Foreign.Storable’
instance GHC.Internal.Foreign.Storable.Storable GHC.Internal.Int.Int64 -- Defined in ‘GHC.Internal.Foreign.Storable’
instance GHC.Internal.Foreign.Storable.Storable GHC.Internal.Int.Int8 -- Defined in ‘GHC.Internal.Foreign.Storable’
instance forall a. GHC.Internal.Foreign.Storable.Storable (GHC.Internal.Ptr.Ptr a) -- Defined in ‘GHC.Internal.Foreign.Storable’
instance forall a. (GHC.Internal.Foreign.Storable.Storable a, GHC.Internal.Real.Integral a) => GHC.Internal.Foreign.Storable.Storable (GHC.Internal.Real.Ratio a) -- Defined in ‘GHC.Internal.Foreign.Storable’
instance forall a. GHC.Internal.Foreign.Storable.Storable (GHC.Internal.Stable.StablePtr a) -- Defined in ‘GHC.Internal.Foreign.Storable’
instance GHC.Internal.Foreign.Storable.Storable () -- Defined in ‘GHC.Internal.Foreign.Storable’
instance GHC.Internal.Foreign.Storable.Storable GHC.Types.Word -- Defined in ‘GHC.Internal.Foreign.Storable’
instance GHC.Internal.Foreign.Storable.Storable GHC.Internal.Word.Word16 -- Defined in ‘GHC.Internal.Foreign.Storable’
instance GHC.Internal.Foreign.Storable.Storable GHC.Internal.Word.Word32 -- Defined in ‘GHC.Internal.Foreign.Storable’
instance GHC.Internal.Foreign.Storable.Storable GHC.Internal.Word.Word64 -- Defined in ‘GHC.Internal.Foreign.Storable’
instance GHC.Internal.Foreign.Storable.Storable GHC.Internal.Word.Word8 -- Defined in ‘GHC.Internal.Foreign.Storable’
instance GHC.Internal.Foreign.Storable.Storable GHC.Internal.Foreign.C.Types.CBool -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Foreign.Storable.Storable GHC.Internal.Foreign.C.Types.CChar -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Foreign.Storable.Storable GHC.Internal.Foreign.C.Types.CClock -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Foreign.Storable.Storable GHC.Internal.Foreign.C.Types.CDouble -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Foreign.Storable.Storable GHC.Internal.Foreign.C.Types.CFloat -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Foreign.Storable.Storable GHC.Internal.Foreign.C.Types.CInt -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Foreign.Storable.Storable GHC.Internal.Foreign.C.Types.CIntMax -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Foreign.Storable.Storable GHC.Internal.Foreign.C.Types.CIntPtr -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Foreign.Storable.Storable GHC.Internal.Foreign.C.Types.CLLong -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Foreign.Storable.Storable GHC.Internal.Foreign.C.Types.CLong -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Foreign.Storable.Storable GHC.Internal.Foreign.C.Types.CPtrdiff -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Foreign.Storable.Storable GHC.Internal.Foreign.C.Types.CSChar -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Foreign.Storable.Storable GHC.Internal.Foreign.C.Types.CSUSeconds -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Foreign.Storable.Storable GHC.Internal.Foreign.C.Types.CShort -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Foreign.Storable.Storable GHC.Internal.Foreign.C.Types.CSigAtomic -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Foreign.Storable.Storable GHC.Internal.Foreign.C.Types.CSize -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Foreign.Storable.Storable GHC.Internal.Foreign.C.Types.CTime -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Foreign.Storable.Storable GHC.Internal.Foreign.C.Types.CUChar -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Foreign.Storable.Storable GHC.Internal.Foreign.C.Types.CUInt -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Foreign.Storable.Storable GHC.Internal.Foreign.C.Types.CUIntMax -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Foreign.Storable.Storable GHC.Internal.Foreign.C.Types.CUIntPtr -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Foreign.Storable.Storable GHC.Internal.Foreign.C.Types.CULLong -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Foreign.Storable.Storable GHC.Internal.Foreign.C.Types.CULong -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Foreign.Storable.Storable GHC.Internal.Foreign.C.Types.CUSeconds -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Foreign.Storable.Storable GHC.Internal.Foreign.C.Types.CUShort -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Foreign.Storable.Storable GHC.Internal.Foreign.C.Types.CWchar -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Foreign.Storable.Storable GHC.Internal.RTS.Flags.IoSubSystem -- Defined in ‘GHC.Internal.RTS.Flags’
instance GHC.Internal.GHCi.GHCiSandboxIO GHC.Types.IO -- Defined in ‘GHC.Internal.GHCi’
instance GHC.Internal.GHCi.GHCiSandboxIO GHC.Internal.GHCi.NoIO -- Defined in ‘GHC.Internal.GHCi’
instance forall (n :: GHC.Types.Symbol) (f :: GHC.Internal.Generics.FixityI) (r :: GHC.Types.Bool). (GHC.Internal.TypeLits.KnownSymbol n, GHC.Internal.Generics.SingI f, GHC.Internal.Generics.SingI r) => GHC.Internal.Generics.Constructor (GHC.Internal.Generics.MetaCons n f r) -- Defined in ‘GHC.Internal.Generics’
instance forall (n :: GHC.Types.Symbol) (m :: GHC.Types.Symbol) (p :: GHC.Types.Symbol) (nt :: GHC.Types.Bool). (GHC.Internal.TypeLits.KnownSymbol n, GHC.Internal.TypeLits.KnownSymbol m, GHC.Internal.TypeLits.KnownSymbol p, GHC.Internal.Generics.SingI nt) => GHC.Internal.Generics.Datatype (GHC.Internal.Generics.MetaData n m p nt) -- Defined in ‘GHC.Internal.Generics’
instance forall (a :: * -> * -> *) b c. GHC.Internal.Generics.Generic (Control.Applicative.WrappedArrow a b c) -- Defined in ‘Control.Applicative’
instance forall (m :: * -> *) a. GHC.Internal.Generics.Generic (Control.Applicative.WrappedMonad m a) -- Defined in ‘Control.Applicative’
instance forall a k (b :: k). GHC.Internal.Generics.Generic (GHC.Internal.Data.Functor.Const.Const a b) -- Defined in ‘GHC.Internal.Data.Functor.Const’
instance forall a. GHC.Internal.Generics.Generic (GHC.Internal.Functor.ZipList.ZipList a) -- Defined in ‘GHC.Internal.Functor.ZipList’
instance forall (m :: * -> *) a b. GHC.Internal.Generics.Generic (GHC.Internal.Control.Arrow.Kleisli m a b) -- Defined in ‘GHC.Internal.Control.Arrow’
instance GHC.Internal.Generics.Generic GHC.Internal.IO.Exception.ExitCode -- Defined in ‘GHC.Internal.IO.Exception’
instance forall a. GHC.Internal.Generics.Generic (Data.Complex.Complex a) -- Defined in ‘Data.Complex’
instance forall k1 (f :: k1 -> *) k2 (g :: k2 -> k1) (a :: k2). GHC.Internal.Generics.Generic (Data.Functor.Compose.Compose f g a) -- Defined in ‘Data.Functor.Compose’
instance forall a. GHC.Internal.Generics.Generic (GHC.Internal.Data.Functor.Identity.Identity a) -- Defined in ‘GHC.Internal.Data.Functor.Identity’
instance [safe] forall k (f :: k -> *) (g :: k -> *) (a :: k). GHC.Internal.Generics.Generic (Data.Functor.Product.Product f g a) -- Defined in ‘Data.Functor.Product’
instance [safe] forall k (f :: k -> *) (g :: k -> *) (a :: k). GHC.Internal.Generics.Generic (Data.Functor.Sum.Sum f g a) -- Defined in ‘Data.Functor.Sum’
instance GHC.Internal.Generics.Generic GHC.Internal.Data.Semigroup.Internal.All -- Defined in ‘GHC.Internal.Data.Semigroup.Internal’
instance forall k (f :: k -> *) (a :: k). GHC.Internal.Generics.Generic (GHC.Internal.Data.Semigroup.Internal.Alt f a) -- Defined in ‘GHC.Internal.Data.Semigroup.Internal’
instance GHC.Internal.Generics.Generic GHC.Internal.Data.Semigroup.Internal.Any -- Defined in ‘GHC.Internal.Data.Semigroup.Internal’
instance forall a. GHC.Internal.Generics.Generic (GHC.Internal.Data.Semigroup.Internal.Dual a) -- Defined in ‘GHC.Internal.Data.Semigroup.Internal’
instance forall a. GHC.Internal.Generics.Generic (GHC.Internal.Data.Semigroup.Internal.Endo a) -- Defined in ‘GHC.Internal.Data.Semigroup.Internal’
instance forall a. GHC.Internal.Generics.Generic (GHC.Internal.Data.Semigroup.Internal.Product a) -- Defined in ‘GHC.Internal.Data.Semigroup.Internal’
instance forall a. GHC.Internal.Generics.Generic (GHC.Internal.Data.Semigroup.Internal.Sum a) -- Defined in ‘GHC.Internal.Data.Semigroup.Internal’
instance forall k (f :: k -> *) (a :: k). GHC.Internal.Generics.Generic (GHC.Internal.Data.Monoid.Ap f a) -- Defined in ‘GHC.Internal.Data.Monoid’
instance forall a. GHC.Internal.Generics.Generic (GHC.Internal.Data.Monoid.First a) -- Defined in ‘GHC.Internal.Data.Monoid’
instance forall a. GHC.Internal.Generics.Generic (GHC.Internal.Data.Monoid.Last a) -- Defined in ‘GHC.Internal.Data.Monoid’
instance forall a b. GHC.Internal.Generics.Generic (Data.Semigroup.Arg a b) -- Defined in ‘Data.Semigroup’
instance forall a. GHC.Internal.Generics.Generic (Data.Semigroup.First a) -- Defined in ‘Data.Semigroup’
instance forall a. GHC.Internal.Generics.Generic (Data.Semigroup.Last a) -- Defined in ‘Data.Semigroup’
instance forall a. GHC.Internal.Generics.Generic (Data.Semigroup.Max a) -- Defined in ‘Data.Semigroup’
instance forall a. GHC.Internal.Generics.Generic (Data.Semigroup.Min a) -- Defined in ‘Data.Semigroup’
instance forall m. GHC.Internal.Generics.Generic (Data.Semigroup.WrappedMonoid m) -- Defined in ‘Data.Semigroup’
instance GHC.Internal.Generics.Generic GHC.Internal.Data.Version.Version -- Defined in ‘GHC.Internal.Data.Version’
instance GHC.Internal.Generics.Generic GHC.Internal.ByteOrder.ByteOrder -- Defined in ‘GHC.Internal.ByteOrder’
instance forall k (f :: k -> *) (g :: k -> *) (p :: k). GHC.Internal.Generics.Generic ((GHC.Internal.Generics.:*:) f g p) -- Defined in ‘GHC.Internal.Generics’
instance forall k (f :: k -> *) (g :: k -> *) (p :: k). GHC.Internal.Generics.Generic ((GHC.Internal.Generics.:+:) f g p) -- Defined in ‘GHC.Internal.Generics’
instance forall k2 (f :: k2 -> *) k1 (g :: k1 -> k2) (p :: k1). GHC.Internal.Generics.Generic ((GHC.Internal.Generics.:.:) f g p) -- Defined in ‘GHC.Internal.Generics’
instance GHC.Internal.Generics.Generic GHC.Internal.Generics.Associativity -- Defined in ‘GHC.Internal.Generics’
instance GHC.Internal.Generics.Generic GHC.Types.Bool -- Defined in ‘GHC.Internal.Generics’
instance GHC.Internal.Generics.Generic GHC.Internal.Generics.DecidedStrictness -- Defined in ‘GHC.Internal.Generics’
instance forall a. GHC.Internal.Generics.Generic (GHC.Internal.Data.Ord.Down a) -- Defined in ‘GHC.Internal.Generics’
instance forall a b. GHC.Internal.Generics.Generic (GHC.Internal.Data.Either.Either a b) -- Defined in ‘GHC.Internal.Generics’
instance GHC.Internal.Generics.Generic GHC.Internal.Fingerprint.Type.Fingerprint -- Defined in ‘GHC.Internal.Generics’
instance GHC.Internal.Generics.Generic GHC.Internal.Generics.Fixity -- Defined in ‘GHC.Internal.Generics’
instance GHC.Internal.Generics.Generic GHC.Internal.Unicode.GeneralCategory -- Defined in ‘GHC.Internal.Generics’
instance forall i c k (p :: k). GHC.Internal.Generics.Generic (GHC.Internal.Generics.K1 i c p) -- Defined in ‘GHC.Internal.Generics’
instance forall a. GHC.Internal.Generics.Generic [a] -- Defined in ‘GHC.Internal.Generics’
instance forall i (c :: GHC.Internal.Generics.Meta) k (f :: k -> *) (p :: k). GHC.Internal.Generics.Generic (GHC.Internal.Generics.M1 i c f p) -- Defined in ‘GHC.Internal.Generics’
instance forall a. GHC.Internal.Generics.Generic (GHC.Internal.Maybe.Maybe a) -- Defined in ‘GHC.Internal.Generics’
instance forall a. GHC.Internal.Generics.Generic (GHC.Internal.Base.NonEmpty a) -- Defined in ‘GHC.Internal.Generics’
instance GHC.Internal.Generics.Generic GHC.Types.Ordering -- Defined in ‘GHC.Internal.Generics’
instance forall p. GHC.Internal.Generics.Generic (GHC.Internal.Generics.Par1 p) -- Defined in ‘GHC.Internal.Generics’
instance forall k (t :: k). GHC.Internal.Generics.Generic (GHC.Internal.Data.Proxy.Proxy t) -- Defined in ‘GHC.Internal.Generics’
instance forall k (f :: k -> *) (p :: k). GHC.Internal.Generics.Generic (GHC.Internal.Generics.Rec1 f p) -- Defined in ‘GHC.Internal.Generics’
instance forall a. GHC.Internal.Generics.Generic (Solo a) -- Defined in ‘GHC.Internal.Generics’
instance GHC.Internal.Generics.Generic GHC.Internal.Generics.SourceStrictness -- Defined in ‘GHC.Internal.Generics’
instance GHC.Internal.Generics.Generic GHC.Internal.Generics.SourceUnpackedness -- Defined in ‘GHC.Internal.Generics’
instance GHC.Internal.Generics.Generic GHC.Internal.Stack.Types.SrcLoc -- Defined in ‘GHC.Internal.Generics’
instance forall a b c d e f g h i j. GHC.Internal.Generics.Generic (a, b, c, d, e, f, g, h, i, j) -- Defined in ‘GHC.Internal.Generics’
instance forall a b c d e f g h i j k. GHC.Internal.Generics.Generic (a, b, c, d, e, f, g, h, i, j, k) -- Defined in ‘GHC.Internal.Generics’
instance forall a b c d e f g h i j k l. GHC.Internal.Generics.Generic (a, b, c, d, e, f, g, h, i, j, k, l) -- Defined in ‘GHC.Internal.Generics’
instance forall a b c d e f g h i j k l m. GHC.Internal.Generics.Generic (a, b, c, d, e, f, g, h, i, j, k, l, m) -- Defined in ‘GHC.Internal.Generics’
instance forall a b c d e f g h i j k l m n. GHC.Internal.Generics.Generic (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -- Defined in ‘GHC.Internal.Generics’
instance forall a b c d e f g h i j k l m n o. GHC.Internal.Generics.Generic (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -- Defined in ‘GHC.Internal.Generics’
instance forall a b. GHC.Internal.Generics.Generic (a, b) -- Defined in ‘GHC.Internal.Generics’
instance forall a b c. GHC.Internal.Generics.Generic (a, b, c) -- Defined in ‘GHC.Internal.Generics’
instance forall a b c d. GHC.Internal.Generics.Generic (a, b, c, d) -- Defined in ‘GHC.Internal.Generics’
instance forall a b c d e. GHC.Internal.Generics.Generic (a, b, c, d, e) -- Defined in ‘GHC.Internal.Generics’
instance forall a b c d e f. GHC.Internal.Generics.Generic (a, b, c, d, e, f) -- Defined in ‘GHC.Internal.Generics’
instance forall a b c d e f g. GHC.Internal.Generics.Generic (a, b, c, d, e, f, g) -- Defined in ‘GHC.Internal.Generics’
instance forall a b c d e f g h. GHC.Internal.Generics.Generic (a, b, c, d, e, f, g, h) -- Defined in ‘GHC.Internal.Generics’
instance forall a b c d e f g h i. GHC.Internal.Generics.Generic (a, b, c, d, e, f, g, h, i) -- Defined in ‘GHC.Internal.Generics’
instance forall k (p :: k). GHC.Internal.Generics.Generic (GHC.Internal.Generics.U1 p) -- Defined in ‘GHC.Internal.Generics’
instance forall k (p :: k). GHC.Internal.Generics.Generic (GHC.Internal.Generics.URec (GHC.Internal.Ptr.Ptr ()) p) -- Defined in ‘GHC.Internal.Generics’
instance forall k (p :: k). GHC.Internal.Generics.Generic (GHC.Internal.Generics.URec GHC.Types.Char p) -- Defined in ‘GHC.Internal.Generics’
instance forall k (p :: k). GHC.Internal.Generics.Generic (GHC.Internal.Generics.URec GHC.Types.Double p) -- Defined in ‘GHC.Internal.Generics’
instance forall k (p :: k). GHC.Internal.Generics.Generic (GHC.Internal.Generics.URec GHC.Types.Float p) -- Defined in ‘GHC.Internal.Generics’
instance forall k (p :: k). GHC.Internal.Generics.Generic (GHC.Internal.Generics.URec GHC.Types.Int p) -- Defined in ‘GHC.Internal.Generics’
instance forall k (p :: k). GHC.Internal.Generics.Generic (GHC.Internal.Generics.URec GHC.Types.Word p) -- Defined in ‘GHC.Internal.Generics’
instance GHC.Internal.Generics.Generic () -- Defined in ‘GHC.Internal.Generics’
instance forall k (p :: k). GHC.Internal.Generics.Generic (GHC.Internal.Generics.V1 p) -- Defined in ‘GHC.Internal.Generics’
instance GHC.Internal.Generics.Generic GHC.Internal.Base.Void -- Defined in ‘GHC.Internal.Generics’
instance GHC.Internal.Generics.Generic GHC.Internal.RTS.Flags.CCFlags -- Defined in ‘GHC.Internal.RTS.Flags’
instance GHC.Internal.Generics.Generic GHC.Internal.RTS.Flags.ConcFlags -- Defined in ‘GHC.Internal.RTS.Flags’
instance GHC.Internal.Generics.Generic GHC.Internal.RTS.Flags.DebugFlags -- Defined in ‘GHC.Internal.RTS.Flags’
instance GHC.Internal.Generics.Generic GHC.Internal.RTS.Flags.DoCostCentres -- Defined in ‘GHC.Internal.RTS.Flags’
instance GHC.Internal.Generics.Generic GHC.Internal.RTS.Flags.DoHeapProfile -- Defined in ‘GHC.Internal.RTS.Flags’
instance GHC.Internal.Generics.Generic GHC.Internal.RTS.Flags.DoTrace -- Defined in ‘GHC.Internal.RTS.Flags’
instance GHC.Internal.Generics.Generic GHC.Internal.RTS.Flags.GCFlags -- Defined in ‘GHC.Internal.RTS.Flags’
instance GHC.Internal.Generics.Generic GHC.Internal.RTS.Flags.GiveGCStats -- Defined in ‘GHC.Internal.RTS.Flags’
instance GHC.Internal.Generics.Generic GHC.Internal.RTS.Flags.HpcFlags -- Defined in ‘GHC.Internal.RTS.Flags’
instance GHC.Internal.Generics.Generic GHC.Internal.RTS.Flags.MiscFlags -- Defined in ‘GHC.Internal.RTS.Flags’
instance GHC.Internal.Generics.Generic GHC.Internal.RTS.Flags.ParFlags -- Defined in ‘GHC.Internal.RTS.Flags’
instance GHC.Internal.Generics.Generic GHC.Internal.RTS.Flags.ProfFlags -- Defined in ‘GHC.Internal.RTS.Flags’
instance GHC.Internal.Generics.Generic GHC.Internal.RTS.Flags.RTSFlags -- Defined in ‘GHC.Internal.RTS.Flags’
instance GHC.Internal.Generics.Generic GHC.Internal.RTS.Flags.TickyFlags -- Defined in ‘GHC.Internal.RTS.Flags’
instance GHC.Internal.Generics.Generic GHC.Internal.RTS.Flags.TraceFlags -- Defined in ‘GHC.Internal.RTS.Flags’
instance GHC.Internal.Generics.Generic GHC.Internal.Stats.GCDetails -- Defined in ‘GHC.Internal.Stats’
instance GHC.Internal.Generics.Generic GHC.Internal.Stats.RTSStats -- Defined in ‘GHC.Internal.Stats’
instance forall k a. GHC.Internal.Generics.Generic1 (GHC.Internal.Data.Functor.Const.Const a) -- Defined in ‘GHC.Internal.Data.Functor.Const’
instance [safe] forall k (f :: k -> *) (g :: k -> *). GHC.Internal.Generics.Generic1 (Data.Functor.Product.Product f g) -- Defined in ‘Data.Functor.Product’
instance [safe] forall k (f :: k -> *) (g :: k -> *). GHC.Internal.Generics.Generic1 (Data.Functor.Sum.Sum f g) -- Defined in ‘Data.Functor.Sum’
instance forall k (f :: k -> *). GHC.Internal.Generics.Generic1 (GHC.Internal.Data.Semigroup.Internal.Alt f) -- Defined in ‘GHC.Internal.Data.Semigroup.Internal’
instance forall k (f :: k -> *). GHC.Internal.Generics.Generic1 (GHC.Internal.Data.Monoid.Ap f) -- Defined in ‘GHC.Internal.Data.Monoid’
instance forall k (f :: k -> *) (g :: k -> *). GHC.Internal.Generics.Generic1 (f GHC.Internal.Generics.:*: g) -- Defined in ‘GHC.Internal.Generics’
instance forall k (f :: k -> *) (g :: k -> *). GHC.Internal.Generics.Generic1 (f GHC.Internal.Generics.:+: g) -- Defined in ‘GHC.Internal.Generics’
instance forall k i c. GHC.Internal.Generics.Generic1 (GHC.Internal.Generics.K1 i c) -- Defined in ‘GHC.Internal.Generics’
instance forall i (c :: GHC.Internal.Generics.Meta) k (f :: k -> *). GHC.Internal.Generics.Generic1 (GHC.Internal.Generics.M1 i c f) -- Defined in ‘GHC.Internal.Generics’
instance forall k. GHC.Internal.Generics.Generic1 GHC.Internal.Data.Proxy.Proxy -- Defined in ‘GHC.Internal.Generics’
instance forall k (f :: k -> *). GHC.Internal.Generics.Generic1 (GHC.Internal.Generics.Rec1 f) -- Defined in ‘GHC.Internal.Generics’
instance forall k. GHC.Internal.Generics.Generic1 GHC.Internal.Generics.U1 -- Defined in ‘GHC.Internal.Generics’
instance forall k. GHC.Internal.Generics.Generic1 (GHC.Internal.Generics.URec (GHC.Internal.Ptr.Ptr ())) -- Defined in ‘GHC.Internal.Generics’
instance forall k. GHC.Internal.Generics.Generic1 (GHC.Internal.Generics.URec GHC.Types.Char) -- Defined in ‘GHC.Internal.Generics’
instance forall k. GHC.Internal.Generics.Generic1 (GHC.Internal.Generics.URec GHC.Types.Double) -- Defined in ‘GHC.Internal.Generics’
instance forall k. GHC.Internal.Generics.Generic1 (GHC.Internal.Generics.URec GHC.Types.Float) -- Defined in ‘GHC.Internal.Generics’
instance forall k. GHC.Internal.Generics.Generic1 (GHC.Internal.Generics.URec GHC.Types.Int) -- Defined in ‘GHC.Internal.Generics’
instance forall k. GHC.Internal.Generics.Generic1 (GHC.Internal.Generics.URec GHC.Types.Word) -- Defined in ‘GHC.Internal.Generics’
instance forall k. GHC.Internal.Generics.Generic1 GHC.Internal.Generics.V1 -- Defined in ‘GHC.Internal.Generics’
instance forall (mn :: GHC.Internal.Maybe.Maybe GHC.Types.Symbol) (su :: GHC.Internal.Generics.SourceUnpackedness) (ss :: GHC.Internal.Generics.SourceStrictness) (ds :: GHC.Internal.Generics.DecidedStrictness). (GHC.Internal.Generics.SingI mn, GHC.Internal.Generics.SingI su, GHC.Internal.Generics.SingI ss, GHC.Internal.Generics.SingI ds) => GHC.Internal.Generics.Selector (GHC.Internal.Generics.MetaSel mn su ss ds) -- Defined in ‘GHC.Internal.Generics’
instance GHC.Internal.Generics.SingI GHC.Internal.Generics.LeftAssociative -- Defined in ‘GHC.Internal.Generics’
instance GHC.Internal.Generics.SingI GHC.Internal.Generics.NotAssociative -- Defined in ‘GHC.Internal.Generics’
instance GHC.Internal.Generics.SingI GHC.Internal.Generics.RightAssociative -- Defined in ‘GHC.Internal.Generics’
instance GHC.Internal.Generics.SingI GHC.Types.False -- Defined in ‘GHC.Internal.Generics’
instance GHC.Internal.Generics.SingI GHC.Types.True -- Defined in ‘GHC.Internal.Generics’
instance GHC.Internal.Generics.SingI GHC.Internal.Generics.DecidedLazy -- Defined in ‘GHC.Internal.Generics’
instance GHC.Internal.Generics.SingI GHC.Internal.Generics.DecidedStrict -- Defined in ‘GHC.Internal.Generics’
instance GHC.Internal.Generics.SingI GHC.Internal.Generics.DecidedUnpack -- Defined in ‘GHC.Internal.Generics’
instance forall (a :: GHC.Internal.Generics.Associativity) (n :: GHC.Internal.TypeNats.Nat). (GHC.Internal.Generics.SingI a, GHC.Internal.TypeNats.KnownNat n) => GHC.Internal.Generics.SingI (GHC.Internal.Generics.InfixI a n) -- Defined in ‘GHC.Internal.Generics’
instance GHC.Internal.Generics.SingI GHC.Internal.Generics.PrefixI -- Defined in ‘GHC.Internal.Generics’
instance forall a1 (a2 :: a1). GHC.Internal.Generics.SingI a2 => GHC.Internal.Generics.SingI (GHC.Internal.Maybe.Just a2) -- Defined in ‘GHC.Internal.Generics’
instance forall a. GHC.Internal.Generics.SingI GHC.Internal.Maybe.Nothing -- Defined in ‘GHC.Internal.Generics’
instance GHC.Internal.Generics.SingI GHC.Internal.Generics.NoSourceStrictness -- Defined in ‘GHC.Internal.Generics’
instance GHC.Internal.Generics.SingI GHC.Internal.Generics.SourceLazy -- Defined in ‘GHC.Internal.Generics’
instance GHC.Internal.Generics.SingI GHC.Internal.Generics.SourceStrict -- Defined in ‘GHC.Internal.Generics’
instance GHC.Internal.Generics.SingI GHC.Internal.Generics.NoSourceUnpackedness -- Defined in ‘GHC.Internal.Generics’
instance GHC.Internal.Generics.SingI GHC.Internal.Generics.SourceNoUnpack -- Defined in ‘GHC.Internal.Generics’
instance GHC.Internal.Generics.SingI GHC.Internal.Generics.SourceUnpack -- Defined in ‘GHC.Internal.Generics’
instance forall (a :: GHC.Types.Symbol). GHC.Internal.TypeLits.KnownSymbol a => GHC.Internal.Generics.SingI a -- Defined in ‘GHC.Internal.Generics’
instance GHC.Internal.Generics.SingKind GHC.Internal.Generics.Associativity -- Defined in ‘GHC.Internal.Generics’
instance GHC.Internal.Generics.SingKind GHC.Types.Bool -- Defined in ‘GHC.Internal.Generics’
instance GHC.Internal.Generics.SingKind GHC.Internal.Generics.DecidedStrictness -- Defined in ‘GHC.Internal.Generics’
instance GHC.Internal.Generics.SingKind GHC.Internal.Generics.FixityI -- Defined in ‘GHC.Internal.Generics’
instance forall a. GHC.Internal.Generics.SingKind a => GHC.Internal.Generics.SingKind (GHC.Internal.Maybe.Maybe a) -- Defined in ‘GHC.Internal.Generics’
instance GHC.Internal.Generics.SingKind GHC.Internal.Generics.SourceStrictness -- Defined in ‘GHC.Internal.Generics’
instance GHC.Internal.Generics.SingKind GHC.Internal.Generics.SourceUnpackedness -- Defined in ‘GHC.Internal.Generics’
instance GHC.Internal.Generics.SingKind GHC.Types.Symbol -- Defined in ‘GHC.Internal.Generics’
instance GHC.Internal.IO.BufferedIO.BufferedIO GHC.Internal.IO.FD.FD -- Defined in ‘GHC.Internal.IO.FD’
instance GHC.Internal.IO.Device.IODevice GHC.Internal.IO.FD.FD -- Defined in ‘GHC.Internal.IO.FD’
instance GHC.Internal.IO.Device.RawIO GHC.Internal.IO.FD.FD -- Defined in ‘GHC.Internal.IO.FD’
instance GHC.Internal.IsList.IsList Data.Array.Byte.ByteArray -- Defined in ‘Data.Array.Byte’
instance GHC.Internal.IsList.IsList GHC.Internal.Stack.Types.CallStack -- Defined in ‘GHC.Internal.IsList’
instance forall a. GHC.Internal.IsList.IsList [a] -- Defined in ‘GHC.Internal.IsList’
instance forall a. GHC.Internal.IsList.IsList (GHC.Internal.Base.NonEmpty a) -- Defined in ‘GHC.Internal.IsList’
instance GHC.Internal.IsList.IsList GHC.Internal.Data.Version.Version -- Defined in ‘GHC.Internal.IsList’
instance forall a. GHC.Internal.IsList.IsList (GHC.Internal.Functor.ZipList.ZipList a) -- Defined in ‘GHC.Internal.IsList’
instance forall a k (b :: k). GHC.Internal.Ix.Ix a => GHC.Internal.Ix.Ix (GHC.Internal.Data.Functor.Const.Const a b) -- Defined in ‘GHC.Internal.Data.Functor.Const’
instance GHC.Internal.Ix.Ix GHC.Internal.Unicode.GeneralCategory -- Defined in ‘GHC.Internal.Unicode’
instance forall k (s :: k). GHC.Internal.Ix.Ix (GHC.Internal.Data.Proxy.Proxy s) -- Defined in ‘GHC.Internal.Data.Proxy’
instance forall a. GHC.Internal.Ix.Ix a => GHC.Internal.Ix.Ix (GHC.Internal.Data.Functor.Identity.Identity a) -- Defined in ‘GHC.Internal.Data.Functor.Identity’
instance GHC.Internal.Ix.Ix GHC.Internal.Int.Int16 -- Defined in ‘GHC.Internal.Int’
instance GHC.Internal.Ix.Ix GHC.Internal.Int.Int32 -- Defined in ‘GHC.Internal.Int’
instance GHC.Internal.Ix.Ix GHC.Internal.Int.Int64 -- Defined in ‘GHC.Internal.Int’
instance GHC.Internal.Ix.Ix GHC.Internal.Int.Int8 -- Defined in ‘GHC.Internal.Int’
instance GHC.Internal.Ix.Ix GHC.Types.Bool -- Defined in ‘GHC.Internal.Ix’
instance GHC.Internal.Ix.Ix GHC.Types.Char -- Defined in ‘GHC.Internal.Ix’
instance GHC.Internal.Ix.Ix GHC.Types.Int -- Defined in ‘GHC.Internal.Ix’
instance GHC.Internal.Ix.Ix GHC.Num.Integer.Integer -- Defined in ‘GHC.Internal.Ix’
instance GHC.Internal.Ix.Ix GHC.Num.Natural.Natural -- Defined in ‘GHC.Internal.Ix’
instance GHC.Internal.Ix.Ix GHC.Types.Ordering -- Defined in ‘GHC.Internal.Ix’
instance forall a. GHC.Internal.Ix.Ix a => GHC.Internal.Ix.Ix (Solo a) -- Defined in ‘GHC.Internal.Ix’
instance forall a1 a2 a3 a4 a5 a6 a7 a8 a9 aA. (GHC.Internal.Ix.Ix a1, GHC.Internal.Ix.Ix a2, GHC.Internal.Ix.Ix a3, GHC.Internal.Ix.Ix a4, GHC.Internal.Ix.Ix a5, GHC.Internal.Ix.Ix a6, GHC.Internal.Ix.Ix a7, GHC.Internal.Ix.Ix a8, GHC.Internal.Ix.Ix a9, GHC.Internal.Ix.Ix aA) => GHC.Internal.Ix.Ix (a1, a2, a3, a4, a5, a6, a7, a8, a9, aA) -- Defined in ‘GHC.Internal.Ix’
instance forall a1 a2 a3 a4 a5 a6 a7 a8 a9 aA aB. (GHC.Internal.Ix.Ix a1, GHC.Internal.Ix.Ix a2, GHC.Internal.Ix.Ix a3, GHC.Internal.Ix.Ix a4, GHC.Internal.Ix.Ix a5, GHC.Internal.Ix.Ix a6, GHC.Internal.Ix.Ix a7, GHC.Internal.Ix.Ix a8, GHC.Internal.Ix.Ix a9, GHC.Internal.Ix.Ix aA, GHC.Internal.Ix.Ix aB) => GHC.Internal.Ix.Ix (a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB) -- Defined in ‘GHC.Internal.Ix’
instance forall a1 a2 a3 a4 a5 a6 a7 a8 a9 aA aB aC. (GHC.Internal.Ix.Ix a1, GHC.Internal.Ix.Ix a2, GHC.Internal.Ix.Ix a3, GHC.Internal.Ix.Ix a4, GHC.Internal.Ix.Ix a5, GHC.Internal.Ix.Ix a6, GHC.Internal.Ix.Ix a7, GHC.Internal.Ix.Ix a8, GHC.Internal.Ix.Ix a9, GHC.Internal.Ix.Ix aA, GHC.Internal.Ix.Ix aB, GHC.Internal.Ix.Ix aC) => GHC.Internal.Ix.Ix (a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC) -- Defined in ‘GHC.Internal.Ix’
instance forall a1 a2 a3 a4 a5 a6 a7 a8 a9 aA aB aC aD. (GHC.Internal.Ix.Ix a1, GHC.Internal.Ix.Ix a2, GHC.Internal.Ix.Ix a3, GHC.Internal.Ix.Ix a4, GHC.Internal.Ix.Ix a5, GHC.Internal.Ix.Ix a6, GHC.Internal.Ix.Ix a7, GHC.Internal.Ix.Ix a8, GHC.Internal.Ix.Ix a9, GHC.Internal.Ix.Ix aA, GHC.Internal.Ix.Ix aB, GHC.Internal.Ix.Ix aC, GHC.Internal.Ix.Ix aD) => GHC.Internal.Ix.Ix (a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC, aD) -- Defined in ‘GHC.Internal.Ix’
instance forall a1 a2 a3 a4 a5 a6 a7 a8 a9 aA aB aC aD aE. (GHC.Internal.Ix.Ix a1, GHC.Internal.Ix.Ix a2, GHC.Internal.Ix.Ix a3, GHC.Internal.Ix.Ix a4, GHC.Internal.Ix.Ix a5, GHC.Internal.Ix.Ix a6, GHC.Internal.Ix.Ix a7, GHC.Internal.Ix.Ix a8, GHC.Internal.Ix.Ix a9, GHC.Internal.Ix.Ix aA, GHC.Internal.Ix.Ix aB, GHC.Internal.Ix.Ix aC, GHC.Internal.Ix.Ix aD, GHC.Internal.Ix.Ix aE) => GHC.Internal.Ix.Ix (a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC, aD, aE) -- Defined in ‘GHC.Internal.Ix’
instance forall a1 a2 a3 a4 a5 a6 a7 a8 a9 aA aB aC aD aE aF. (GHC.Internal.Ix.Ix a1, GHC.Internal.Ix.Ix a2, GHC.Internal.Ix.Ix a3, GHC.Internal.Ix.Ix a4, GHC.Internal.Ix.Ix a5, GHC.Internal.Ix.Ix a6, GHC.Internal.Ix.Ix a7, GHC.Internal.Ix.Ix a8, GHC.Internal.Ix.Ix a9, GHC.Internal.Ix.Ix aA, GHC.Internal.Ix.Ix aB, GHC.Internal.Ix.Ix aC, GHC.Internal.Ix.Ix aD, GHC.Internal.Ix.Ix aE, GHC.Internal.Ix.Ix aF) => GHC.Internal.Ix.Ix (a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC, aD, aE, aF) -- Defined in ‘GHC.Internal.Ix’
instance forall a b. (GHC.Internal.Ix.Ix a, GHC.Internal.Ix.Ix b) => GHC.Internal.Ix.Ix (a, b) -- Defined in ‘GHC.Internal.Ix’
instance forall a1 a2 a3. (GHC.Internal.Ix.Ix a1, GHC.Internal.Ix.Ix a2, GHC.Internal.Ix.Ix a3) => GHC.Internal.Ix.Ix (a1, a2, a3) -- Defined in ‘GHC.Internal.Ix’
instance forall a1 a2 a3 a4. (GHC.Internal.Ix.Ix a1, GHC.Internal.Ix.Ix a2, GHC.Internal.Ix.Ix a3, GHC.Internal.Ix.Ix a4) => GHC.Internal.Ix.Ix (a1, a2, a3, a4) -- Defined in ‘GHC.Internal.Ix’
instance forall a1 a2 a3 a4 a5. (GHC.Internal.Ix.Ix a1, GHC.Internal.Ix.Ix a2, GHC.Internal.Ix.Ix a3, GHC.Internal.Ix.Ix a4, GHC.Internal.Ix.Ix a5) => GHC.Internal.Ix.Ix (a1, a2, a3, a4, a5) -- Defined in ‘GHC.Internal.Ix’
instance forall a1 a2 a3 a4 a5 a6. (GHC.Internal.Ix.Ix a1, GHC.Internal.Ix.Ix a2, GHC.Internal.Ix.Ix a3, GHC.Internal.Ix.Ix a4, GHC.Internal.Ix.Ix a5, GHC.Internal.Ix.Ix a6) => GHC.Internal.Ix.Ix (a1, a2, a3, a4, a5, a6) -- Defined in ‘GHC.Internal.Ix’
instance forall a1 a2 a3 a4 a5 a6 a7. (GHC.Internal.Ix.Ix a1, GHC.Internal.Ix.Ix a2, GHC.Internal.Ix.Ix a3, GHC.Internal.Ix.Ix a4, GHC.Internal.Ix.Ix a5, GHC.Internal.Ix.Ix a6, GHC.Internal.Ix.Ix a7) => GHC.Internal.Ix.Ix (a1, a2, a3, a4, a5, a6, a7) -- Defined in ‘GHC.Internal.Ix’
instance forall a1 a2 a3 a4 a5 a6 a7 a8. (GHC.Internal.Ix.Ix a1, GHC.Internal.Ix.Ix a2, GHC.Internal.Ix.Ix a3, GHC.Internal.Ix.Ix a4, GHC.Internal.Ix.Ix a5, GHC.Internal.Ix.Ix a6, GHC.Internal.Ix.Ix a7, GHC.Internal.Ix.Ix a8) => GHC.Internal.Ix.Ix (a1, a2, a3, a4, a5, a6, a7, a8) -- Defined in ‘GHC.Internal.Ix’
instance forall a1 a2 a3 a4 a5 a6 a7 a8 a9. (GHC.Internal.Ix.Ix a1, GHC.Internal.Ix.Ix a2, GHC.Internal.Ix.Ix a3, GHC.Internal.Ix.Ix a4, GHC.Internal.Ix.Ix a5, GHC.Internal.Ix.Ix a6, GHC.Internal.Ix.Ix a7, GHC.Internal.Ix.Ix a8, GHC.Internal.Ix.Ix a9) => GHC.Internal.Ix.Ix (a1, a2, a3, a4, a5, a6, a7, a8, a9) -- Defined in ‘GHC.Internal.Ix’
instance GHC.Internal.Ix.Ix () -- Defined in ‘GHC.Internal.Ix’
instance GHC.Internal.Ix.Ix GHC.Internal.Base.Void -- Defined in ‘GHC.Internal.Ix’
instance GHC.Internal.Ix.Ix GHC.Types.Word -- Defined in ‘GHC.Internal.Ix’
instance forall a. GHC.Internal.Ix.Ix a => GHC.Internal.Ix.Ix (GHC.Internal.Data.Ord.Down a) -- Defined in ‘GHC.Internal.Data.Ord’
instance GHC.Internal.Ix.Ix GHC.Internal.Word.Word16 -- Defined in ‘GHC.Internal.Word’
instance GHC.Internal.Ix.Ix GHC.Internal.Word.Word32 -- Defined in ‘GHC.Internal.Word’
instance GHC.Internal.Ix.Ix GHC.Internal.Word.Word64 -- Defined in ‘GHC.Internal.Word’
instance GHC.Internal.Ix.Ix GHC.Internal.Word.Word8 -- Defined in ‘GHC.Internal.Word’
instance GHC.Internal.Ix.Ix GHC.Internal.Foreign.Ptr.IntPtr -- Defined in ‘GHC.Internal.Foreign.Ptr’
instance GHC.Internal.Ix.Ix GHC.Internal.Foreign.Ptr.WordPtr -- Defined in ‘GHC.Internal.Foreign.Ptr’
instance GHC.Internal.Ix.Ix GHC.Internal.Foreign.C.Types.CBool -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Ix.Ix GHC.Internal.Foreign.C.Types.CChar -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Ix.Ix GHC.Internal.Foreign.C.Types.CInt -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Ix.Ix GHC.Internal.Foreign.C.Types.CIntMax -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Ix.Ix GHC.Internal.Foreign.C.Types.CIntPtr -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Ix.Ix GHC.Internal.Foreign.C.Types.CLLong -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Ix.Ix GHC.Internal.Foreign.C.Types.CLong -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Ix.Ix GHC.Internal.Foreign.C.Types.CPtrdiff -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Ix.Ix GHC.Internal.Foreign.C.Types.CSChar -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Ix.Ix GHC.Internal.Foreign.C.Types.CShort -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Ix.Ix GHC.Internal.Foreign.C.Types.CSigAtomic -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Ix.Ix GHC.Internal.Foreign.C.Types.CSize -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Ix.Ix GHC.Internal.Foreign.C.Types.CUChar -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Ix.Ix GHC.Internal.Foreign.C.Types.CUInt -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Ix.Ix GHC.Internal.Foreign.C.Types.CUIntMax -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Ix.Ix GHC.Internal.Foreign.C.Types.CUIntPtr -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Ix.Ix GHC.Internal.Foreign.C.Types.CULLong -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Ix.Ix GHC.Internal.Foreign.C.Types.CULong -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Ix.Ix GHC.Internal.Foreign.C.Types.CUShort -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Ix.Ix GHC.Internal.Foreign.C.Types.CWchar -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Ix.Ix GHC.Internal.Generics.Associativity -- Defined in ‘GHC.Internal.Generics’
instance GHC.Internal.Ix.Ix GHC.Internal.Generics.DecidedStrictness -- Defined in ‘GHC.Internal.Generics’
instance GHC.Internal.Ix.Ix GHC.Internal.Generics.SourceStrictness -- Defined in ‘GHC.Internal.Generics’
instance GHC.Internal.Ix.Ix GHC.Internal.Generics.SourceUnpackedness -- Defined in ‘GHC.Internal.Generics’
instance GHC.Internal.Ix.Ix GHC.Internal.IO.Device.SeekMode -- Defined in ‘GHC.Internal.IO.Device’
instance GHC.Internal.Ix.Ix GHC.Internal.IO.IOMode.IOMode -- Defined in ‘GHC.Internal.IO.IOMode’
instance forall a k (b :: k). GHC.Internal.Num.Num a => GHC.Internal.Num.Num (GHC.Internal.Data.Functor.Const.Const a b) -- Defined in ‘GHC.Internal.Data.Functor.Const’
instance forall a. GHC.Internal.Float.RealFloat a => GHC.Internal.Num.Num (Data.Complex.Complex a) -- Defined in ‘Data.Complex’
instance forall k (a :: k). Data.Fixed.HasResolution a => GHC.Internal.Num.Num (Data.Fixed.Fixed a) -- Defined in ‘Data.Fixed’
instance forall k1 k2 (f :: k1 -> *) (g :: k2 -> k1) (a :: k2). GHC.Internal.Num.Num (f (g a)) => GHC.Internal.Num.Num (Data.Functor.Compose.Compose f g a) -- Defined in ‘Data.Functor.Compose’
instance forall a b. GHC.Internal.Num.Num a => GHC.Internal.Num.Num (Data.Functor.Contravariant.Op a b) -- Defined in ‘Data.Functor.Contravariant’
instance forall a. GHC.Internal.Num.Num a => GHC.Internal.Num.Num (GHC.Internal.Data.Functor.Identity.Identity a) -- Defined in ‘GHC.Internal.Data.Functor.Identity’
instance GHC.Internal.Num.Num GHC.Internal.Int.Int16 -- Defined in ‘GHC.Internal.Int’
instance GHC.Internal.Num.Num GHC.Internal.Int.Int32 -- Defined in ‘GHC.Internal.Int’
instance GHC.Internal.Num.Num GHC.Internal.Int.Int64 -- Defined in ‘GHC.Internal.Int’
instance GHC.Internal.Num.Num GHC.Internal.Int.Int8 -- Defined in ‘GHC.Internal.Int’
instance forall k (f :: k -> *) (a :: k). GHC.Internal.Num.Num (f a) => GHC.Internal.Num.Num (GHC.Internal.Data.Semigroup.Internal.Alt f a) -- Defined in ‘GHC.Internal.Data.Semigroup.Internal’
instance forall a. GHC.Internal.Num.Num a => GHC.Internal.Num.Num (GHC.Internal.Data.Semigroup.Internal.Product a) -- Defined in ‘GHC.Internal.Data.Semigroup.Internal’
instance forall a. GHC.Internal.Num.Num a => GHC.Internal.Num.Num (GHC.Internal.Data.Semigroup.Internal.Sum a) -- Defined in ‘GHC.Internal.Data.Semigroup.Internal’
instance forall a. GHC.Internal.Num.Num a => GHC.Internal.Num.Num (GHC.Internal.Data.Ord.Down a) -- Defined in ‘GHC.Internal.Data.Ord’
instance forall a. GHC.Internal.Real.Integral a => GHC.Internal.Num.Num (GHC.Internal.Real.Ratio a) -- Defined in ‘GHC.Internal.Real’
instance forall a. GHC.Internal.Num.Num a => GHC.Internal.Num.Num (Data.Semigroup.Max a) -- Defined in ‘Data.Semigroup’
instance forall a. GHC.Internal.Num.Num a => GHC.Internal.Num.Num (Data.Semigroup.Min a) -- Defined in ‘Data.Semigroup’
instance GHC.Internal.Num.Num GHC.Internal.Word.Word16 -- Defined in ‘GHC.Internal.Word’
instance GHC.Internal.Num.Num GHC.Internal.Word.Word32 -- Defined in ‘GHC.Internal.Word’
instance GHC.Internal.Num.Num GHC.Internal.Word.Word64 -- Defined in ‘GHC.Internal.Word’
instance GHC.Internal.Num.Num GHC.Internal.Word.Word8 -- Defined in ‘GHC.Internal.Word’
instance GHC.Internal.Num.Num GHC.Internal.Foreign.Ptr.IntPtr -- Defined in ‘GHC.Internal.Foreign.Ptr’
instance GHC.Internal.Num.Num GHC.Internal.Foreign.Ptr.WordPtr -- Defined in ‘GHC.Internal.Foreign.Ptr’
instance GHC.Internal.Num.Num GHC.Internal.Foreign.C.Types.CBool -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Num.Num GHC.Internal.Foreign.C.Types.CChar -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Num.Num GHC.Internal.Foreign.C.Types.CClock -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Num.Num GHC.Internal.Foreign.C.Types.CDouble -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Num.Num GHC.Internal.Foreign.C.Types.CFloat -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Num.Num GHC.Internal.Foreign.C.Types.CInt -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Num.Num GHC.Internal.Foreign.C.Types.CIntMax -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Num.Num GHC.Internal.Foreign.C.Types.CIntPtr -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Num.Num GHC.Internal.Foreign.C.Types.CLLong -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Num.Num GHC.Internal.Foreign.C.Types.CLong -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Num.Num GHC.Internal.Foreign.C.Types.CPtrdiff -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Num.Num GHC.Internal.Foreign.C.Types.CSChar -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Num.Num GHC.Internal.Foreign.C.Types.CSUSeconds -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Num.Num GHC.Internal.Foreign.C.Types.CShort -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Num.Num GHC.Internal.Foreign.C.Types.CSigAtomic -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Num.Num GHC.Internal.Foreign.C.Types.CSize -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Num.Num GHC.Internal.Foreign.C.Types.CTime -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Num.Num GHC.Internal.Foreign.C.Types.CUChar -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Num.Num GHC.Internal.Foreign.C.Types.CUInt -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Num.Num GHC.Internal.Foreign.C.Types.CUIntMax -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Num.Num GHC.Internal.Foreign.C.Types.CUIntPtr -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Num.Num GHC.Internal.Foreign.C.Types.CULLong -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Num.Num GHC.Internal.Foreign.C.Types.CULong -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Num.Num GHC.Internal.Foreign.C.Types.CUSeconds -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Num.Num GHC.Internal.Foreign.C.Types.CUShort -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Num.Num GHC.Internal.Foreign.C.Types.CWchar -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Num.Num GHC.Types.Double -- Defined in ‘GHC.Internal.Float’
instance GHC.Internal.Num.Num GHC.Types.Float -- Defined in ‘GHC.Internal.Float’
instance GHC.Internal.Num.Num GHC.Types.Int -- Defined in ‘GHC.Internal.Num’
instance GHC.Internal.Num.Num GHC.Num.Integer.Integer -- Defined in ‘GHC.Internal.Num’
instance GHC.Internal.Num.Num GHC.Num.Natural.Natural -- Defined in ‘GHC.Internal.Num’
instance GHC.Internal.Num.Num GHC.Types.Word -- Defined in ‘GHC.Internal.Num’
instance forall k a (b :: k). GHC.Internal.Read.Read a => GHC.Internal.Read.Read (GHC.Internal.Data.Functor.Const.Const a b) -- Defined in ‘GHC.Internal.Data.Functor.Const’
instance forall a. GHC.Internal.Read.Read a => GHC.Internal.Read.Read (GHC.Internal.Functor.ZipList.ZipList a) -- Defined in ‘GHC.Internal.Functor.ZipList’
instance GHC.Internal.Read.Read GHC.Internal.IO.Exception.ExitCode -- Defined in ‘GHC.Internal.IO.Exception’
instance forall a. GHC.Internal.Read.Read a => GHC.Internal.Read.Read (GHC.Internal.Data.Bits.And a) -- Defined in ‘GHC.Internal.Data.Bits’
instance forall a. GHC.Internal.Read.Read a => GHC.Internal.Read.Read (GHC.Internal.Data.Bits.Iff a) -- Defined in ‘GHC.Internal.Data.Bits’
instance forall a. GHC.Internal.Read.Read a => GHC.Internal.Read.Read (GHC.Internal.Data.Bits.Ior a) -- Defined in ‘GHC.Internal.Data.Bits’
instance forall a. GHC.Internal.Read.Read a => GHC.Internal.Read.Read (GHC.Internal.Data.Bits.Xor a) -- Defined in ‘GHC.Internal.Data.Bits’
instance forall a b. (GHC.Internal.Ix.Ix a, GHC.Internal.Read.Read a, GHC.Internal.Read.Read b) => GHC.Internal.Read.Read (GHC.Internal.Arr.Array a b) -- Defined in ‘GHC.Internal.Read’
instance GHC.Internal.Read.Read GHC.Types.Bool -- Defined in ‘GHC.Internal.Read’
instance GHC.Internal.Read.Read GHC.Types.Char -- Defined in ‘GHC.Internal.Read’
instance GHC.Internal.Read.Read GHC.Types.Double -- Defined in ‘GHC.Internal.Read’
instance GHC.Internal.Read.Read GHC.Types.Float -- Defined in ‘GHC.Internal.Read’
instance GHC.Internal.Read.Read GHC.Internal.Unicode.GeneralCategory -- Defined in ‘GHC.Internal.Read’
instance GHC.Internal.Read.Read GHC.Types.Int -- Defined in ‘GHC.Internal.Read’
instance GHC.Internal.Read.Read GHC.Num.Integer.Integer -- Defined in ‘GHC.Internal.Read’
instance GHC.Internal.Read.Read GHC.Internal.Text.Read.Lex.Lexeme -- Defined in ‘GHC.Internal.Read’
instance forall a. GHC.Internal.Read.Read a => GHC.Internal.Read.Read [a] -- Defined in ‘GHC.Internal.Read’
instance forall a. GHC.Internal.Read.Read a => GHC.Internal.Read.Read (GHC.Internal.Maybe.Maybe a) -- Defined in ‘GHC.Internal.Read’
instance GHC.Internal.Read.Read GHC.Num.Natural.Natural -- Defined in ‘GHC.Internal.Read’
instance forall a. GHC.Internal.Read.Read a => GHC.Internal.Read.Read (GHC.Internal.Base.NonEmpty a) -- Defined in ‘GHC.Internal.Read’
instance GHC.Internal.Read.Read GHC.Types.Ordering -- Defined in ‘GHC.Internal.Read’
instance forall a. (GHC.Internal.Real.Integral a, GHC.Internal.Read.Read a) => GHC.Internal.Read.Read (GHC.Internal.Real.Ratio a) -- Defined in ‘GHC.Internal.Read’
instance forall a. GHC.Internal.Read.Read a => GHC.Internal.Read.Read (Solo a) -- Defined in ‘GHC.Internal.Read’
instance forall a b c d e f g h i j. (GHC.Internal.Read.Read a, GHC.Internal.Read.Read b, GHC.Internal.Read.Read c, GHC.Internal.Read.Read d, GHC.Internal.Read.Read e, GHC.Internal.Read.Read f, GHC.Internal.Read.Read g, GHC.Internal.Read.Read h, GHC.Internal.Read.Read i, GHC.Internal.Read.Read j) => GHC.Internal.Read.Read (a, b, c, d, e, f, g, h, i, j) -- Defined in ‘GHC.Internal.Read’
instance forall a b c d e f g h i j k. (GHC.Internal.Read.Read a, GHC.Internal.Read.Read b, GHC.Internal.Read.Read c, GHC.Internal.Read.Read d, GHC.Internal.Read.Read e, GHC.Internal.Read.Read f, GHC.Internal.Read.Read g, GHC.Internal.Read.Read h, GHC.Internal.Read.Read i, GHC.Internal.Read.Read j, GHC.Internal.Read.Read k) => GHC.Internal.Read.Read (a, b, c, d, e, f, g, h, i, j, k) -- Defined in ‘GHC.Internal.Read’
instance forall a b c d e f g h i j k l. (GHC.Internal.Read.Read a, GHC.Internal.Read.Read b, GHC.Internal.Read.Read c, GHC.Internal.Read.Read d, GHC.Internal.Read.Read e, GHC.Internal.Read.Read f, GHC.Internal.Read.Read g, GHC.Internal.Read.Read h, GHC.Internal.Read.Read i, GHC.Internal.Read.Read j, GHC.Internal.Read.Read k, GHC.Internal.Read.Read l) => GHC.Internal.Read.Read (a, b, c, d, e, f, g, h, i, j, k, l) -- Defined in ‘GHC.Internal.Read’
instance forall a b c d e f g h i j k l m. (GHC.Internal.Read.Read a, GHC.Internal.Read.Read b, GHC.Internal.Read.Read c, GHC.Internal.Read.Read d, GHC.Internal.Read.Read e, GHC.Internal.Read.Read f, GHC.Internal.Read.Read g, GHC.Internal.Read.Read h, GHC.Internal.Read.Read i, GHC.Internal.Read.Read j, GHC.Internal.Read.Read k, GHC.Internal.Read.Read l, GHC.Internal.Read.Read m) => GHC.Internal.Read.Read (a, b, c, d, e, f, g, h, i, j, k, l, m) -- Defined in ‘GHC.Internal.Read’
instance forall a b c d e f g h i j k l m n. (GHC.Internal.Read.Read a, GHC.Internal.Read.Read b, GHC.Internal.Read.Read c, GHC.Internal.Read.Read d, GHC.Internal.Read.Read e, GHC.Internal.Read.Read f, GHC.Internal.Read.Read g, GHC.Internal.Read.Read h, GHC.Internal.Read.Read i, GHC.Internal.Read.Read j, GHC.Internal.Read.Read k, GHC.Internal.Read.Read l, GHC.Internal.Read.Read m, GHC.Internal.Read.Read n) => GHC.Internal.Read.Read (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -- Defined in ‘GHC.Internal.Read’
instance forall a b c d e f g h i j k l m n o. (GHC.Internal.Read.Read a, GHC.Internal.Read.Read b, GHC.Internal.Read.Read c, GHC.Internal.Read.Read d, GHC.Internal.Read.Read e, GHC.Internal.Read.Read f, GHC.Internal.Read.Read g, GHC.Internal.Read.Read h, GHC.Internal.Read.Read i, GHC.Internal.Read.Read j, GHC.Internal.Read.Read k, GHC.Internal.Read.Read l, GHC.Internal.Read.Read m, GHC.Internal.Read.Read n, GHC.Internal.Read.Read o) => GHC.Internal.Read.Read (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -- Defined in ‘GHC.Internal.Read’
instance forall a b. (GHC.Internal.Read.Read a, GHC.Internal.Read.Read b) => GHC.Internal.Read.Read (a, b) -- Defined in ‘GHC.Internal.Read’
instance forall a b c. (GHC.Internal.Read.Read a, GHC.Internal.Read.Read b, GHC.Internal.Read.Read c) => GHC.Internal.Read.Read (a, b, c) -- Defined in ‘GHC.Internal.Read’
instance forall a b c d. (GHC.Internal.Read.Read a, GHC.Internal.Read.Read b, GHC.Internal.Read.Read c, GHC.Internal.Read.Read d) => GHC.Internal.Read.Read (a, b, c, d) -- Defined in ‘GHC.Internal.Read’
instance forall a b c d e. (GHC.Internal.Read.Read a, GHC.Internal.Read.Read b, GHC.Internal.Read.Read c, GHC.Internal.Read.Read d, GHC.Internal.Read.Read e) => GHC.Internal.Read.Read (a, b, c, d, e) -- Defined in ‘GHC.Internal.Read’
instance forall a b c d e f. (GHC.Internal.Read.Read a, GHC.Internal.Read.Read b, GHC.Internal.Read.Read c, GHC.Internal.Read.Read d, GHC.Internal.Read.Read e, GHC.Internal.Read.Read f) => GHC.Internal.Read.Read (a, b, c, d, e, f) -- Defined in ‘GHC.Internal.Read’
instance forall a b c d e f g. (GHC.Internal.Read.Read a, GHC.Internal.Read.Read b, GHC.Internal.Read.Read c, GHC.Internal.Read.Read d, GHC.Internal.Read.Read e, GHC.Internal.Read.Read f, GHC.Internal.Read.Read g) => GHC.Internal.Read.Read (a, b, c, d, e, f, g) -- Defined in ‘GHC.Internal.Read’
instance forall a b c d e f g h. (GHC.Internal.Read.Read a, GHC.Internal.Read.Read b, GHC.Internal.Read.Read c, GHC.Internal.Read.Read d, GHC.Internal.Read.Read e, GHC.Internal.Read.Read f, GHC.Internal.Read.Read g, GHC.Internal.Read.Read h) => GHC.Internal.Read.Read (a, b, c, d, e, f, g, h) -- Defined in ‘GHC.Internal.Read’
instance forall a b c d e f g h i. (GHC.Internal.Read.Read a, GHC.Internal.Read.Read b, GHC.Internal.Read.Read c, GHC.Internal.Read.Read d, GHC.Internal.Read.Read e, GHC.Internal.Read.Read f, GHC.Internal.Read.Read g, GHC.Internal.Read.Read h, GHC.Internal.Read.Read i) => GHC.Internal.Read.Read (a, b, c, d, e, f, g, h, i) -- Defined in ‘GHC.Internal.Read’
instance GHC.Internal.Read.Read () -- Defined in ‘GHC.Internal.Read’
instance GHC.Internal.Read.Read GHC.Internal.Base.Void -- Defined in ‘GHC.Internal.Read’
instance GHC.Internal.Read.Read GHC.Types.Word -- Defined in ‘GHC.Internal.Read’
instance GHC.Internal.Read.Read GHC.Internal.Word.Word16 -- Defined in ‘GHC.Internal.Read’
instance GHC.Internal.Read.Read GHC.Internal.Word.Word32 -- Defined in ‘GHC.Internal.Read’
instance GHC.Internal.Read.Read GHC.Internal.Word.Word64 -- Defined in ‘GHC.Internal.Read’
instance GHC.Internal.Read.Read GHC.Internal.Word.Word8 -- Defined in ‘GHC.Internal.Read’
instance forall a. GHC.Internal.Read.Read a => GHC.Internal.Read.Read (Data.Complex.Complex a) -- Defined in ‘Data.Complex’
instance forall k (a :: k) (b :: k). (a ~ b) => GHC.Internal.Read.Read (a GHC.Internal.Data.Type.Equality.:~: b) -- Defined in ‘GHC.Internal.Data.Type.Equality’
instance forall k1 k2 (a :: k1) (b :: k2). (a ~~ b) => GHC.Internal.Read.Read (a GHC.Internal.Data.Type.Equality.:~~: b) -- Defined in ‘GHC.Internal.Data.Type.Equality’
instance forall k (t :: k). GHC.Internal.Read.Read (GHC.Internal.Data.Proxy.Proxy t) -- Defined in ‘GHC.Internal.Data.Proxy’
instance forall a b. (GHC.Internal.Read.Read a, GHC.Internal.Read.Read b) => GHC.Internal.Read.Read (GHC.Internal.Data.Either.Either a b) -- Defined in ‘GHC.Internal.Data.Either’
instance forall k (a :: k). Data.Fixed.HasResolution a => GHC.Internal.Read.Read (Data.Fixed.Fixed a) -- Defined in ‘Data.Fixed’
instance forall k1 k2 (f :: k1 -> *) (g :: k2 -> k1) (a :: k2). GHC.Internal.Read.Read (f (g a)) => GHC.Internal.Read.Read (Data.Functor.Compose.Compose f g a) -- Defined in ‘Data.Functor.Compose’
instance forall a. GHC.Internal.Read.Read a => GHC.Internal.Read.Read (GHC.Internal.Data.Functor.Identity.Identity a) -- Defined in ‘GHC.Internal.Data.Functor.Identity’
instance [safe] forall k (f :: k -> *) (a :: k) (g :: k -> *). (GHC.Internal.Read.Read (f a), GHC.Internal.Read.Read (g a)) => GHC.Internal.Read.Read (Data.Functor.Product.Product f g a) -- Defined in ‘Data.Functor.Product’
instance [safe] forall k (f :: k -> *) (a :: k) (g :: k -> *). (GHC.Internal.Read.Read (f a), GHC.Internal.Read.Read (g a)) => GHC.Internal.Read.Read (Data.Functor.Sum.Sum f g a) -- Defined in ‘Data.Functor.Sum’
instance GHC.Internal.Read.Read GHC.Internal.Int.Int16 -- Defined in ‘GHC.Internal.Int’
instance GHC.Internal.Read.Read GHC.Internal.Int.Int32 -- Defined in ‘GHC.Internal.Int’
instance GHC.Internal.Read.Read GHC.Internal.Int.Int64 -- Defined in ‘GHC.Internal.Int’
instance GHC.Internal.Read.Read GHC.Internal.Int.Int8 -- Defined in ‘GHC.Internal.Int’
instance GHC.Internal.Read.Read GHC.Internal.Data.Semigroup.Internal.All -- Defined in ‘GHC.Internal.Data.Semigroup.Internal’
instance forall k (f :: k -> *) (a :: k). GHC.Internal.Read.Read (f a) => GHC.Internal.Read.Read (GHC.Internal.Data.Semigroup.Internal.Alt f a) -- Defined in ‘GHC.Internal.Data.Semigroup.Internal’
instance GHC.Internal.Read.Read GHC.Internal.Data.Semigroup.Internal.Any -- Defined in ‘GHC.Internal.Data.Semigroup.Internal’
instance forall a. GHC.Internal.Read.Read a => GHC.Internal.Read.Read (GHC.Internal.Data.Semigroup.Internal.Dual a) -- Defined in ‘GHC.Internal.Data.Semigroup.Internal’
instance forall a. GHC.Internal.Read.Read a => GHC.Internal.Read.Read (GHC.Internal.Data.Semigroup.Internal.Product a) -- Defined in ‘GHC.Internal.Data.Semigroup.Internal’
instance forall a. GHC.Internal.Read.Read a => GHC.Internal.Read.Read (GHC.Internal.Data.Semigroup.Internal.Sum a) -- Defined in ‘GHC.Internal.Data.Semigroup.Internal’
instance forall k (f :: k -> *) (a :: k). GHC.Internal.Read.Read (f a) => GHC.Internal.Read.Read (GHC.Internal.Data.Monoid.Ap f a) -- Defined in ‘GHC.Internal.Data.Monoid’
instance forall a. GHC.Internal.Read.Read a => GHC.Internal.Read.Read (GHC.Internal.Data.Monoid.First a) -- Defined in ‘GHC.Internal.Data.Monoid’
instance forall a. GHC.Internal.Read.Read a => GHC.Internal.Read.Read (GHC.Internal.Data.Monoid.Last a) -- Defined in ‘GHC.Internal.Data.Monoid’
instance forall a. GHC.Internal.Read.Read a => GHC.Internal.Read.Read (GHC.Internal.Data.Ord.Down a) -- Defined in ‘GHC.Internal.Data.Ord’
instance forall a b. (GHC.Internal.Read.Read a, GHC.Internal.Read.Read b) => GHC.Internal.Read.Read (Data.Semigroup.Arg a b) -- Defined in ‘Data.Semigroup’
instance forall a. GHC.Internal.Read.Read a => GHC.Internal.Read.Read (Data.Semigroup.First a) -- Defined in ‘Data.Semigroup’
instance forall a. GHC.Internal.Read.Read a => GHC.Internal.Read.Read (Data.Semigroup.Last a) -- Defined in ‘Data.Semigroup’
instance forall a. GHC.Internal.Read.Read a => GHC.Internal.Read.Read (Data.Semigroup.Max a) -- Defined in ‘Data.Semigroup’
instance forall a. GHC.Internal.Read.Read a => GHC.Internal.Read.Read (Data.Semigroup.Min a) -- Defined in ‘Data.Semigroup’
instance forall m. GHC.Internal.Read.Read m => GHC.Internal.Read.Read (Data.Semigroup.WrappedMonoid m) -- Defined in ‘Data.Semigroup’
instance forall k (a :: k) (b :: k). Coercible a b => GHC.Internal.Read.Read (GHC.Internal.Data.Type.Coercion.Coercion a b) -- Defined in ‘GHC.Internal.Data.Type.Coercion’
instance GHC.Internal.Read.Read GHC.Internal.Data.Version.Version -- Defined in ‘GHC.Internal.Data.Version’
instance GHC.Internal.Read.Read GHC.Internal.Foreign.Ptr.IntPtr -- Defined in ‘GHC.Internal.Foreign.Ptr’
instance GHC.Internal.Read.Read GHC.Internal.Foreign.Ptr.WordPtr -- Defined in ‘GHC.Internal.Foreign.Ptr’
instance GHC.Internal.Read.Read GHC.Internal.Foreign.C.Types.CBool -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Read.Read GHC.Internal.Foreign.C.Types.CChar -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Read.Read GHC.Internal.Foreign.C.Types.CClock -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Read.Read GHC.Internal.Foreign.C.Types.CDouble -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Read.Read GHC.Internal.Foreign.C.Types.CFloat -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Read.Read GHC.Internal.Foreign.C.Types.CInt -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Read.Read GHC.Internal.Foreign.C.Types.CIntMax -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Read.Read GHC.Internal.Foreign.C.Types.CIntPtr -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Read.Read GHC.Internal.Foreign.C.Types.CLLong -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Read.Read GHC.Internal.Foreign.C.Types.CLong -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Read.Read GHC.Internal.Foreign.C.Types.CPtrdiff -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Read.Read GHC.Internal.Foreign.C.Types.CSChar -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Read.Read GHC.Internal.Foreign.C.Types.CSUSeconds -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Read.Read GHC.Internal.Foreign.C.Types.CShort -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Read.Read GHC.Internal.Foreign.C.Types.CSigAtomic -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Read.Read GHC.Internal.Foreign.C.Types.CSize -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Read.Read GHC.Internal.Foreign.C.Types.CTime -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Read.Read GHC.Internal.Foreign.C.Types.CUChar -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Read.Read GHC.Internal.Foreign.C.Types.CUInt -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Read.Read GHC.Internal.Foreign.C.Types.CUIntMax -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Read.Read GHC.Internal.Foreign.C.Types.CUIntPtr -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Read.Read GHC.Internal.Foreign.C.Types.CULLong -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Read.Read GHC.Internal.Foreign.C.Types.CULong -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Read.Read GHC.Internal.Foreign.C.Types.CUSeconds -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Read.Read GHC.Internal.Foreign.C.Types.CUShort -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Read.Read GHC.Internal.Foreign.C.Types.CWchar -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Read.Read GHC.Internal.ByteOrder.ByteOrder -- Defined in ‘GHC.Internal.ByteOrder’
instance forall k (f :: k -> *) (g :: k -> *) (p :: k). (GHC.Internal.Read.Read (f p), GHC.Internal.Read.Read (g p)) => GHC.Internal.Read.Read ((GHC.Internal.Generics.:*:) f g p) -- Defined in ‘GHC.Internal.Generics’
instance forall k (f :: k -> *) (g :: k -> *) (p :: k). (GHC.Internal.Read.Read (f p), GHC.Internal.Read.Read (g p)) => GHC.Internal.Read.Read ((GHC.Internal.Generics.:+:) f g p) -- Defined in ‘GHC.Internal.Generics’
instance forall k2 (f :: k2 -> *) k1 (g :: k1 -> k2) (p :: k1). GHC.Internal.Read.Read (f (g p)) => GHC.Internal.Read.Read ((GHC.Internal.Generics.:.:) f g p) -- Defined in ‘GHC.Internal.Generics’
instance GHC.Internal.Read.Read GHC.Internal.Generics.Associativity -- Defined in ‘GHC.Internal.Generics’
instance GHC.Internal.Read.Read GHC.Internal.Generics.DecidedStrictness -- Defined in ‘GHC.Internal.Generics’
instance GHC.Internal.Read.Read GHC.Internal.Generics.Fixity -- Defined in ‘GHC.Internal.Generics’
instance forall i c k (p :: k). GHC.Internal.Read.Read c => GHC.Internal.Read.Read (GHC.Internal.Generics.K1 i c p) -- Defined in ‘GHC.Internal.Generics’
instance forall i (c :: GHC.Internal.Generics.Meta) k (f :: k -> *) (p :: k). GHC.Internal.Read.Read (f p) => GHC.Internal.Read.Read (GHC.Internal.Generics.M1 i c f p) -- Defined in ‘GHC.Internal.Generics’
instance forall p. GHC.Internal.Read.Read p => GHC.Internal.Read.Read (GHC.Internal.Generics.Par1 p) -- Defined in ‘GHC.Internal.Generics’
instance forall k (f :: k -> *) (p :: k). GHC.Internal.Read.Read (f p) => GHC.Internal.Read.Read (GHC.Internal.Generics.Rec1 f p) -- Defined in ‘GHC.Internal.Generics’
instance GHC.Internal.Read.Read GHC.Internal.Generics.SourceStrictness -- Defined in ‘GHC.Internal.Generics’
instance GHC.Internal.Read.Read GHC.Internal.Generics.SourceUnpackedness -- Defined in ‘GHC.Internal.Generics’
instance forall k (p :: k). GHC.Internal.Read.Read (GHC.Internal.Generics.U1 p) -- Defined in ‘GHC.Internal.Generics’
instance forall k (p :: k). GHC.Internal.Read.Read (GHC.Internal.Generics.V1 p) -- Defined in ‘GHC.Internal.Generics’
instance GHC.Internal.Read.Read GHC.Internal.IO.Device.SeekMode -- Defined in ‘GHC.Internal.IO.Device’
instance GHC.Internal.Read.Read GHC.Internal.IO.Handle.Types.BufferMode -- Defined in ‘GHC.Internal.IO.Handle.Types’
instance GHC.Internal.Read.Read GHC.Internal.IO.Handle.Types.Newline -- Defined in ‘GHC.Internal.IO.Handle.Types’
instance GHC.Internal.Read.Read GHC.Internal.IO.Handle.Types.NewlineMode -- Defined in ‘GHC.Internal.IO.Handle.Types’
instance GHC.Internal.Read.Read GHC.Internal.IO.IOMode.IOMode -- Defined in ‘GHC.Internal.IO.IOMode’
instance GHC.Internal.Read.Read GHC.Internal.Stats.GCDetails -- Defined in ‘GHC.Internal.Stats’
instance GHC.Internal.Read.Read GHC.Internal.Stats.RTSStats -- Defined in ‘GHC.Internal.Stats’
instance GHC.Internal.Read.Read GHC.Internal.TypeNats.SomeNat -- Defined in ‘GHC.Internal.TypeNats’
instance GHC.Internal.Read.Read GHC.Internal.TypeLits.SomeChar -- Defined in ‘GHC.Internal.TypeLits’
instance GHC.Internal.Read.Read GHC.Internal.TypeLits.SomeSymbol -- Defined in ‘GHC.Internal.TypeLits’
instance forall a k (b :: k). GHC.Internal.Real.Fractional a => GHC.Internal.Real.Fractional (GHC.Internal.Data.Functor.Const.Const a b) -- Defined in ‘GHC.Internal.Data.Functor.Const’
instance forall a. GHC.Internal.Float.RealFloat a => GHC.Internal.Real.Fractional (Data.Complex.Complex a) -- Defined in ‘Data.Complex’
instance forall k (a :: k). Data.Fixed.HasResolution a => GHC.Internal.Real.Fractional (Data.Fixed.Fixed a) -- Defined in ‘Data.Fixed’
instance forall k1 k2 (f :: k1 -> *) (g :: k2 -> k1) (a :: k2). GHC.Internal.Real.Fractional (f (g a)) => GHC.Internal.Real.Fractional (Data.Functor.Compose.Compose f g a) -- Defined in ‘Data.Functor.Compose’
instance forall a b. GHC.Internal.Real.Fractional a => GHC.Internal.Real.Fractional (Data.Functor.Contravariant.Op a b) -- Defined in ‘Data.Functor.Contravariant’
instance forall a. GHC.Internal.Real.Fractional a => GHC.Internal.Real.Fractional (GHC.Internal.Data.Functor.Identity.Identity a) -- Defined in ‘GHC.Internal.Data.Functor.Identity’
instance forall a. GHC.Internal.Real.Fractional a => GHC.Internal.Real.Fractional (GHC.Internal.Data.Ord.Down a) -- Defined in ‘GHC.Internal.Data.Ord’
instance forall a. GHC.Internal.Real.Integral a => GHC.Internal.Real.Fractional (GHC.Internal.Real.Ratio a) -- Defined in ‘GHC.Internal.Real’
instance GHC.Internal.Real.Fractional GHC.Internal.Foreign.C.Types.CDouble -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Real.Fractional GHC.Internal.Foreign.C.Types.CFloat -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Real.Fractional GHC.Types.Double -- Defined in ‘GHC.Internal.Float’
instance GHC.Internal.Real.Fractional GHC.Types.Float -- Defined in ‘GHC.Internal.Float’
instance forall a k (b :: k). GHC.Internal.Real.Integral a => GHC.Internal.Real.Integral (GHC.Internal.Data.Functor.Const.Const a b) -- Defined in ‘GHC.Internal.Data.Functor.Const’
instance forall k1 k2 (f :: k1 -> *) (g :: k2 -> k1) (a :: k2). GHC.Internal.Real.Integral (f (g a)) => GHC.Internal.Real.Integral (Data.Functor.Compose.Compose f g a) -- Defined in ‘Data.Functor.Compose’
instance forall a. GHC.Internal.Real.Integral a => GHC.Internal.Real.Integral (GHC.Internal.Data.Functor.Identity.Identity a) -- Defined in ‘GHC.Internal.Data.Functor.Identity’
instance GHC.Internal.Real.Integral GHC.Internal.Int.Int16 -- Defined in ‘GHC.Internal.Int’
instance GHC.Internal.Real.Integral GHC.Internal.Int.Int32 -- Defined in ‘GHC.Internal.Int’
instance GHC.Internal.Real.Integral GHC.Internal.Int.Int64 -- Defined in ‘GHC.Internal.Int’
instance GHC.Internal.Real.Integral GHC.Internal.Int.Int8 -- Defined in ‘GHC.Internal.Int’
instance GHC.Internal.Real.Integral GHC.Types.Int -- Defined in ‘GHC.Internal.Real’
instance GHC.Internal.Real.Integral GHC.Num.Integer.Integer -- Defined in ‘GHC.Internal.Real’
instance GHC.Internal.Real.Integral GHC.Num.Natural.Natural -- Defined in ‘GHC.Internal.Real’
instance GHC.Internal.Real.Integral GHC.Types.Word -- Defined in ‘GHC.Internal.Real’
instance GHC.Internal.Real.Integral GHC.Internal.Word.Word16 -- Defined in ‘GHC.Internal.Word’
instance GHC.Internal.Real.Integral GHC.Internal.Word.Word32 -- Defined in ‘GHC.Internal.Word’
instance GHC.Internal.Real.Integral GHC.Internal.Word.Word64 -- Defined in ‘GHC.Internal.Word’
instance GHC.Internal.Real.Integral GHC.Internal.Word.Word8 -- Defined in ‘GHC.Internal.Word’
instance GHC.Internal.Real.Integral GHC.Internal.Foreign.Ptr.IntPtr -- Defined in ‘GHC.Internal.Foreign.Ptr’
instance GHC.Internal.Real.Integral GHC.Internal.Foreign.Ptr.WordPtr -- Defined in ‘GHC.Internal.Foreign.Ptr’
instance GHC.Internal.Real.Integral GHC.Internal.Foreign.C.Types.CBool -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Real.Integral GHC.Internal.Foreign.C.Types.CChar -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Real.Integral GHC.Internal.Foreign.C.Types.CInt -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Real.Integral GHC.Internal.Foreign.C.Types.CIntMax -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Real.Integral GHC.Internal.Foreign.C.Types.CIntPtr -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Real.Integral GHC.Internal.Foreign.C.Types.CLLong -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Real.Integral GHC.Internal.Foreign.C.Types.CLong -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Real.Integral GHC.Internal.Foreign.C.Types.CPtrdiff -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Real.Integral GHC.Internal.Foreign.C.Types.CSChar -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Real.Integral GHC.Internal.Foreign.C.Types.CShort -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Real.Integral GHC.Internal.Foreign.C.Types.CSigAtomic -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Real.Integral GHC.Internal.Foreign.C.Types.CSize -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Real.Integral GHC.Internal.Foreign.C.Types.CUChar -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Real.Integral GHC.Internal.Foreign.C.Types.CUInt -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Real.Integral GHC.Internal.Foreign.C.Types.CUIntMax -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Real.Integral GHC.Internal.Foreign.C.Types.CUIntPtr -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Real.Integral GHC.Internal.Foreign.C.Types.CULLong -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Real.Integral GHC.Internal.Foreign.C.Types.CULong -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Real.Integral GHC.Internal.Foreign.C.Types.CUShort -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Real.Integral GHC.Internal.Foreign.C.Types.CWchar -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance forall a k (b :: k). GHC.Internal.Real.Real a => GHC.Internal.Real.Real (GHC.Internal.Data.Functor.Const.Const a b) -- Defined in ‘GHC.Internal.Data.Functor.Const’
instance forall k (a :: k). Data.Fixed.HasResolution a => GHC.Internal.Real.Real (Data.Fixed.Fixed a) -- Defined in ‘Data.Fixed’
instance forall k1 k2 (f :: k1 -> *) (g :: k2 -> k1) (a :: k2). GHC.Internal.Real.Real (f (g a)) => GHC.Internal.Real.Real (Data.Functor.Compose.Compose f g a) -- Defined in ‘Data.Functor.Compose’
instance forall a. GHC.Internal.Real.Real a => GHC.Internal.Real.Real (GHC.Internal.Data.Functor.Identity.Identity a) -- Defined in ‘GHC.Internal.Data.Functor.Identity’
instance GHC.Internal.Real.Real GHC.Internal.Int.Int16 -- Defined in ‘GHC.Internal.Int’
instance GHC.Internal.Real.Real GHC.Internal.Int.Int32 -- Defined in ‘GHC.Internal.Int’
instance GHC.Internal.Real.Real GHC.Internal.Int.Int64 -- Defined in ‘GHC.Internal.Int’
instance GHC.Internal.Real.Real GHC.Internal.Int.Int8 -- Defined in ‘GHC.Internal.Int’
instance forall a. GHC.Internal.Real.Real a => GHC.Internal.Real.Real (GHC.Internal.Data.Ord.Down a) -- Defined in ‘GHC.Internal.Data.Ord’
instance GHC.Internal.Real.Real GHC.Types.Int -- Defined in ‘GHC.Internal.Real’
instance GHC.Internal.Real.Real GHC.Num.Integer.Integer -- Defined in ‘GHC.Internal.Real’
instance GHC.Internal.Real.Real GHC.Num.Natural.Natural -- Defined in ‘GHC.Internal.Real’
instance forall a. GHC.Internal.Real.Integral a => GHC.Internal.Real.Real (GHC.Internal.Real.Ratio a) -- Defined in ‘GHC.Internal.Real’
instance GHC.Internal.Real.Real GHC.Types.Word -- Defined in ‘GHC.Internal.Real’
instance GHC.Internal.Real.Real GHC.Internal.Word.Word16 -- Defined in ‘GHC.Internal.Word’
instance GHC.Internal.Real.Real GHC.Internal.Word.Word32 -- Defined in ‘GHC.Internal.Word’
instance GHC.Internal.Real.Real GHC.Internal.Word.Word64 -- Defined in ‘GHC.Internal.Word’
instance GHC.Internal.Real.Real GHC.Internal.Word.Word8 -- Defined in ‘GHC.Internal.Word’
instance GHC.Internal.Real.Real GHC.Internal.Foreign.Ptr.IntPtr -- Defined in ‘GHC.Internal.Foreign.Ptr’
instance GHC.Internal.Real.Real GHC.Internal.Foreign.Ptr.WordPtr -- Defined in ‘GHC.Internal.Foreign.Ptr’
instance GHC.Internal.Real.Real GHC.Internal.Foreign.C.Types.CBool -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Real.Real GHC.Internal.Foreign.C.Types.CChar -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Real.Real GHC.Internal.Foreign.C.Types.CClock -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Real.Real GHC.Internal.Foreign.C.Types.CDouble -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Real.Real GHC.Internal.Foreign.C.Types.CFloat -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Real.Real GHC.Internal.Foreign.C.Types.CInt -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Real.Real GHC.Internal.Foreign.C.Types.CIntMax -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Real.Real GHC.Internal.Foreign.C.Types.CIntPtr -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Real.Real GHC.Internal.Foreign.C.Types.CLLong -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Real.Real GHC.Internal.Foreign.C.Types.CLong -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Real.Real GHC.Internal.Foreign.C.Types.CPtrdiff -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Real.Real GHC.Internal.Foreign.C.Types.CSChar -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Real.Real GHC.Internal.Foreign.C.Types.CSUSeconds -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Real.Real GHC.Internal.Foreign.C.Types.CShort -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Real.Real GHC.Internal.Foreign.C.Types.CSigAtomic -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Real.Real GHC.Internal.Foreign.C.Types.CSize -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Real.Real GHC.Internal.Foreign.C.Types.CTime -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Real.Real GHC.Internal.Foreign.C.Types.CUChar -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Real.Real GHC.Internal.Foreign.C.Types.CUInt -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Real.Real GHC.Internal.Foreign.C.Types.CUIntMax -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Real.Real GHC.Internal.Foreign.C.Types.CUIntPtr -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Real.Real GHC.Internal.Foreign.C.Types.CULLong -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Real.Real GHC.Internal.Foreign.C.Types.CULong -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Real.Real GHC.Internal.Foreign.C.Types.CUSeconds -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Real.Real GHC.Internal.Foreign.C.Types.CUShort -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Real.Real GHC.Internal.Foreign.C.Types.CWchar -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Real.Real GHC.Types.Double -- Defined in ‘GHC.Internal.Float’
instance GHC.Internal.Real.Real GHC.Types.Float -- Defined in ‘GHC.Internal.Float’
instance forall a k (b :: k). GHC.Internal.Real.RealFrac a => GHC.Internal.Real.RealFrac (GHC.Internal.Data.Functor.Const.Const a b) -- Defined in ‘GHC.Internal.Data.Functor.Const’
instance forall k (a :: k). Data.Fixed.HasResolution a => GHC.Internal.Real.RealFrac (Data.Fixed.Fixed a) -- Defined in ‘Data.Fixed’
instance forall k1 k2 (f :: k1 -> *) (g :: k2 -> k1) (a :: k2). GHC.Internal.Real.RealFrac (f (g a)) => GHC.Internal.Real.RealFrac (Data.Functor.Compose.Compose f g a) -- Defined in ‘Data.Functor.Compose’
instance forall a. GHC.Internal.Real.RealFrac a => GHC.Internal.Real.RealFrac (GHC.Internal.Data.Functor.Identity.Identity a) -- Defined in ‘GHC.Internal.Data.Functor.Identity’
instance forall a. GHC.Internal.Real.RealFrac a => GHC.Internal.Real.RealFrac (GHC.Internal.Data.Ord.Down a) -- Defined in ‘GHC.Internal.Data.Ord’
instance forall a. GHC.Internal.Real.Integral a => GHC.Internal.Real.RealFrac (GHC.Internal.Real.Ratio a) -- Defined in ‘GHC.Internal.Real’
instance GHC.Internal.Real.RealFrac GHC.Internal.Foreign.C.Types.CDouble -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Real.RealFrac GHC.Internal.Foreign.C.Types.CFloat -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Real.RealFrac GHC.Types.Double -- Defined in ‘GHC.Internal.Float’
instance GHC.Internal.Real.RealFrac GHC.Types.Float -- Defined in ‘GHC.Internal.Float’
instance forall k a (b :: k). GHC.Internal.Show.Show a => GHC.Internal.Show.Show (GHC.Internal.Data.Functor.Const.Const a b) -- Defined in ‘GHC.Internal.Data.Functor.Const’
instance forall a. GHC.Internal.Show.Show a => GHC.Internal.Show.Show (GHC.Internal.Functor.ZipList.ZipList a) -- Defined in ‘GHC.Internal.Functor.ZipList’
instance GHC.Internal.Show.Show GHC.Internal.Conc.Sync.BlockReason -- Defined in ‘GHC.Internal.Conc.Sync’
instance GHC.Internal.Show.Show GHC.Internal.Conc.Sync.ThreadId -- Defined in ‘GHC.Internal.Conc.Sync’
instance GHC.Internal.Show.Show GHC.Internal.Conc.Sync.ThreadStatus -- Defined in ‘GHC.Internal.Conc.Sync’
instance GHC.Internal.Show.Show GHC.Internal.IO.Exception.AllocationLimitExceeded -- Defined in ‘GHC.Internal.IO.Exception’
instance GHC.Internal.Show.Show GHC.Internal.IO.Exception.ArrayException -- Defined in ‘GHC.Internal.IO.Exception’
instance GHC.Internal.Show.Show GHC.Internal.IO.Exception.AssertionFailed -- Defined in ‘GHC.Internal.IO.Exception’
instance GHC.Internal.Show.Show GHC.Internal.IO.Exception.AsyncException -- Defined in ‘GHC.Internal.IO.Exception’
instance GHC.Internal.Show.Show GHC.Internal.IO.Exception.BlockedIndefinitelyOnMVar -- Defined in ‘GHC.Internal.IO.Exception’
instance GHC.Internal.Show.Show GHC.Internal.IO.Exception.BlockedIndefinitelyOnSTM -- Defined in ‘GHC.Internal.IO.Exception’
instance GHC.Internal.Show.Show GHC.Internal.IO.Exception.CompactionFailed -- Defined in ‘GHC.Internal.IO.Exception’
instance GHC.Internal.Show.Show GHC.Internal.IO.Exception.Deadlock -- Defined in ‘GHC.Internal.IO.Exception’
instance GHC.Internal.Show.Show GHC.Internal.IO.Exception.ExitCode -- Defined in ‘GHC.Internal.IO.Exception’
instance GHC.Internal.Show.Show GHC.Internal.IO.Exception.FixIOException -- Defined in ‘GHC.Internal.IO.Exception’
instance GHC.Internal.Show.Show GHC.Internal.IO.Exception.IOErrorType -- Defined in ‘GHC.Internal.IO.Exception’
instance GHC.Internal.Show.Show GHC.Internal.IO.Exception.IOException -- Defined in ‘GHC.Internal.IO.Exception’
instance GHC.Internal.Show.Show GHC.Internal.IO.Exception.SomeAsyncException -- Defined in ‘GHC.Internal.IO.Exception’
instance GHC.Internal.Show.Show GHC.Internal.Exception.Type.ArithException -- Defined in ‘GHC.Internal.Exception.Type’
instance forall a. GHC.Internal.Show.Show a => GHC.Internal.Show.Show (GHC.Internal.Exception.Type.ExceptionWithContext a) -- Defined in ‘GHC.Internal.Exception.Type’
instance forall e. GHC.Internal.Show.Show e => GHC.Internal.Show.Show (GHC.Internal.Exception.Type.NoBacktrace e) -- Defined in ‘GHC.Internal.Exception.Type’
instance GHC.Internal.Show.Show GHC.Internal.Exception.Type.SomeException -- Defined in ‘GHC.Internal.Exception.Type’
instance GHC.Internal.Show.Show GHC.Internal.Exception.ErrorCall -- Defined in ‘GHC.Internal.Exception’
instance GHC.Internal.Show.Show GHC.Internal.IO.MaskingState -- Defined in ‘GHC.Internal.IO’
instance GHC.Internal.Show.Show GHC.Internal.Control.Exception.Base.NestedAtomically -- Defined in ‘GHC.Internal.Control.Exception.Base’
instance GHC.Internal.Show.Show GHC.Internal.Control.Exception.Base.NoMatchingContinuationPrompt -- Defined in ‘GHC.Internal.Control.Exception.Base’
instance GHC.Internal.Show.Show GHC.Internal.Control.Exception.Base.NoMethodError -- Defined in ‘GHC.Internal.Control.Exception.Base’
instance GHC.Internal.Show.Show GHC.Internal.Control.Exception.Base.NonTermination -- Defined in ‘GHC.Internal.Control.Exception.Base’
instance GHC.Internal.Show.Show GHC.Internal.Control.Exception.Base.PatternMatchFail -- Defined in ‘GHC.Internal.Control.Exception.Base’
instance GHC.Internal.Show.Show GHC.Internal.Control.Exception.Base.RecConError -- Defined in ‘GHC.Internal.Control.Exception.Base’
instance GHC.Internal.Show.Show GHC.Internal.Control.Exception.Base.RecSelError -- Defined in ‘GHC.Internal.Control.Exception.Base’
instance GHC.Internal.Show.Show GHC.Internal.Control.Exception.Base.RecUpdError -- Defined in ‘GHC.Internal.Control.Exception.Base’
instance GHC.Internal.Show.Show GHC.Internal.Control.Exception.Base.TypeError -- Defined in ‘GHC.Internal.Control.Exception.Base’
instance forall s a. GHC.Internal.Show.Show (GHC.Internal.ST.ST s a) -- Defined in ‘GHC.Internal.ST’
instance GHC.Internal.Show.Show Data.Array.Byte.ByteArray -- Defined in ‘Data.Array.Byte’
instance forall a. GHC.Internal.Show.Show a => GHC.Internal.Show.Show (GHC.Internal.Data.Bits.And a) -- Defined in ‘GHC.Internal.Data.Bits’
instance forall a. GHC.Internal.Show.Show a => GHC.Internal.Show.Show (GHC.Internal.Data.Bits.Iff a) -- Defined in ‘GHC.Internal.Data.Bits’
instance forall a. GHC.Internal.Show.Show a => GHC.Internal.Show.Show (GHC.Internal.Data.Bits.Ior a) -- Defined in ‘GHC.Internal.Data.Bits’
instance forall a. GHC.Internal.Show.Show a => GHC.Internal.Show.Show (GHC.Internal.Data.Bits.Xor a) -- Defined in ‘GHC.Internal.Data.Bits’
instance GHC.Internal.Show.Show GHC.Internal.Unicode.GeneralCategory -- Defined in ‘GHC.Internal.Unicode’
instance GHC.Internal.Show.Show GHC.Types.Bool -- Defined in ‘GHC.Internal.Show’
instance GHC.Internal.Show.Show GHC.Internal.Stack.Types.CallStack -- Defined in ‘GHC.Internal.Show’
instance GHC.Internal.Show.Show GHC.Types.Char -- Defined in ‘GHC.Internal.Show’
instance GHC.Internal.Show.Show GHC.Types.Int -- Defined in ‘GHC.Internal.Show’
instance GHC.Internal.Show.Show GHC.Num.Integer.Integer -- Defined in ‘GHC.Internal.Show’
instance GHC.Internal.Show.Show GHC.Types.KindRep -- Defined in ‘GHC.Internal.Show’
instance GHC.Internal.Show.Show GHC.Types.Levity -- Defined in ‘GHC.Internal.Show’
instance forall a. GHC.Internal.Show.Show a => GHC.Internal.Show.Show [a] -- Defined in ‘GHC.Internal.Show’
instance forall a. GHC.Internal.Show.Show a => GHC.Internal.Show.Show (GHC.Internal.Maybe.Maybe a) -- Defined in ‘GHC.Internal.Show’
instance GHC.Internal.Show.Show GHC.Types.Module -- Defined in ‘GHC.Internal.Show’
instance GHC.Internal.Show.Show GHC.Num.Natural.Natural -- Defined in ‘GHC.Internal.Show’
instance forall a. GHC.Internal.Show.Show a => GHC.Internal.Show.Show (GHC.Internal.Base.NonEmpty a) -- Defined in ‘GHC.Internal.Show’
instance GHC.Internal.Show.Show GHC.Types.Ordering -- Defined in ‘GHC.Internal.Show’
instance GHC.Internal.Show.Show GHC.Types.RuntimeRep -- Defined in ‘GHC.Internal.Show’
instance forall a. GHC.Internal.Show.Show a => GHC.Internal.Show.Show (Solo a) -- Defined in ‘GHC.Internal.Show’
instance GHC.Internal.Show.Show GHC.Internal.Stack.Types.SrcLoc -- Defined in ‘GHC.Internal.Show’
instance GHC.Internal.Show.Show GHC.Types.TrName -- Defined in ‘GHC.Internal.Show’
instance forall a b c d e f g h i j. (GHC.Internal.Show.Show a, GHC.Internal.Show.Show b, GHC.Internal.Show.Show c, GHC.Internal.Show.Show d, GHC.Internal.Show.Show e, GHC.Internal.Show.Show f, GHC.Internal.Show.Show g, GHC.Internal.Show.Show h, GHC.Internal.Show.Show i, GHC.Internal.Show.Show j) => GHC.Internal.Show.Show (a, b, c, d, e, f, g, h, i, j) -- Defined in ‘GHC.Internal.Show’
instance forall a b c d e f g h i j k. (GHC.Internal.Show.Show a, GHC.Internal.Show.Show b, GHC.Internal.Show.Show c, GHC.Internal.Show.Show d, GHC.Internal.Show.Show e, GHC.Internal.Show.Show f, GHC.Internal.Show.Show g, GHC.Internal.Show.Show h, GHC.Internal.Show.Show i, GHC.Internal.Show.Show j, GHC.Internal.Show.Show k) => GHC.Internal.Show.Show (a, b, c, d, e, f, g, h, i, j, k) -- Defined in ‘GHC.Internal.Show’
instance forall a b c d e f g h i j k l. (GHC.Internal.Show.Show a, GHC.Internal.Show.Show b, GHC.Internal.Show.Show c, GHC.Internal.Show.Show d, GHC.Internal.Show.Show e, GHC.Internal.Show.Show f, GHC.Internal.Show.Show g, GHC.Internal.Show.Show h, GHC.Internal.Show.Show i, GHC.Internal.Show.Show j, GHC.Internal.Show.Show k, GHC.Internal.Show.Show l) => GHC.Internal.Show.Show (a, b, c, d, e, f, g, h, i, j, k, l) -- Defined in ‘GHC.Internal.Show’
instance forall a b c d e f g h i j k l m. (GHC.Internal.Show.Show a, GHC.Internal.Show.Show b, GHC.Internal.Show.Show c, GHC.Internal.Show.Show d, GHC.Internal.Show.Show e, GHC.Internal.Show.Show f, GHC.Internal.Show.Show g, GHC.Internal.Show.Show h, GHC.Internal.Show.Show i, GHC.Internal.Show.Show j, GHC.Internal.Show.Show k, GHC.Internal.Show.Show l, GHC.Internal.Show.Show m) => GHC.Internal.Show.Show (a, b, c, d, e, f, g, h, i, j, k, l, m) -- Defined in ‘GHC.Internal.Show’
instance forall a b c d e f g h i j k l m n. (GHC.Internal.Show.Show a, GHC.Internal.Show.Show b, GHC.Internal.Show.Show c, GHC.Internal.Show.Show d, GHC.Internal.Show.Show e, GHC.Internal.Show.Show f, GHC.Internal.Show.Show g, GHC.Internal.Show.Show h, GHC.Internal.Show.Show i, GHC.Internal.Show.Show j, GHC.Internal.Show.Show k, GHC.Internal.Show.Show l, GHC.Internal.Show.Show m, GHC.Internal.Show.Show n) => GHC.Internal.Show.Show (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -- Defined in ‘GHC.Internal.Show’
instance forall a b c d e f g h i j k l m n o. (GHC.Internal.Show.Show a, GHC.Internal.Show.Show b, GHC.Internal.Show.Show c, GHC.Internal.Show.Show d, GHC.Internal.Show.Show e, GHC.Internal.Show.Show f, GHC.Internal.Show.Show g, GHC.Internal.Show.Show h, GHC.Internal.Show.Show i, GHC.Internal.Show.Show j, GHC.Internal.Show.Show k, GHC.Internal.Show.Show l, GHC.Internal.Show.Show m, GHC.Internal.Show.Show n, GHC.Internal.Show.Show o) => GHC.Internal.Show.Show (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -- Defined in ‘GHC.Internal.Show’
instance forall a b. (GHC.Internal.Show.Show a, GHC.Internal.Show.Show b) => GHC.Internal.Show.Show (a, b) -- Defined in ‘GHC.Internal.Show’
instance forall a b c. (GHC.Internal.Show.Show a, GHC.Internal.Show.Show b, GHC.Internal.Show.Show c) => GHC.Internal.Show.Show (a, b, c) -- Defined in ‘GHC.Internal.Show’
instance forall a b c d. (GHC.Internal.Show.Show a, GHC.Internal.Show.Show b, GHC.Internal.Show.Show c, GHC.Internal.Show.Show d) => GHC.Internal.Show.Show (a, b, c, d) -- Defined in ‘GHC.Internal.Show’
instance forall a b c d e. (GHC.Internal.Show.Show a, GHC.Internal.Show.Show b, GHC.Internal.Show.Show c, GHC.Internal.Show.Show d, GHC.Internal.Show.Show e) => GHC.Internal.Show.Show (a, b, c, d, e) -- Defined in ‘GHC.Internal.Show’
instance forall a b c d e f. (GHC.Internal.Show.Show a, GHC.Internal.Show.Show b, GHC.Internal.Show.Show c, GHC.Internal.Show.Show d, GHC.Internal.Show.Show e, GHC.Internal.Show.Show f) => GHC.Internal.Show.Show (a, b, c, d, e, f) -- Defined in ‘GHC.Internal.Show’
instance forall a b c d e f g. (GHC.Internal.Show.Show a, GHC.Internal.Show.Show b, GHC.Internal.Show.Show c, GHC.Internal.Show.Show d, GHC.Internal.Show.Show e, GHC.Internal.Show.Show f, GHC.Internal.Show.Show g) => GHC.Internal.Show.Show (a, b, c, d, e, f, g) -- Defined in ‘GHC.Internal.Show’
instance forall a b c d e f g h. (GHC.Internal.Show.Show a, GHC.Internal.Show.Show b, GHC.Internal.Show.Show c, GHC.Internal.Show.Show d, GHC.Internal.Show.Show e, GHC.Internal.Show.Show f, GHC.Internal.Show.Show g, GHC.Internal.Show.Show h) => GHC.Internal.Show.Show (a, b, c, d, e, f, g, h) -- Defined in ‘GHC.Internal.Show’
instance forall a b c d e f g h i. (GHC.Internal.Show.Show a, GHC.Internal.Show.Show b, GHC.Internal.Show.Show c, GHC.Internal.Show.Show d, GHC.Internal.Show.Show e, GHC.Internal.Show.Show f, GHC.Internal.Show.Show g, GHC.Internal.Show.Show h, GHC.Internal.Show.Show i) => GHC.Internal.Show.Show (a, b, c, d, e, f, g, h, i) -- Defined in ‘GHC.Internal.Show’
instance GHC.Internal.Show.Show GHC.Types.TyCon -- Defined in ‘GHC.Internal.Show’
instance GHC.Internal.Show.Show GHC.Types.TypeLitSort -- Defined in ‘GHC.Internal.Show’
instance GHC.Internal.Show.Show () -- Defined in ‘GHC.Internal.Show’
instance GHC.Internal.Show.Show GHC.Types.VecCount -- Defined in ‘GHC.Internal.Show’
instance GHC.Internal.Show.Show GHC.Types.VecElem -- Defined in ‘GHC.Internal.Show’
instance GHC.Internal.Show.Show GHC.Internal.Base.Void -- Defined in ‘GHC.Internal.Show’
instance GHC.Internal.Show.Show GHC.Types.Word -- Defined in ‘GHC.Internal.Show’
instance forall a. GHC.Internal.Show.Show a => GHC.Internal.Show.Show (Data.Complex.Complex a) -- Defined in ‘Data.Complex’
instance forall k (a :: k) (b :: k). GHC.Internal.Show.Show (a GHC.Internal.Data.Type.Equality.:~: b) -- Defined in ‘GHC.Internal.Data.Type.Equality’
instance forall k1 k2 (a :: k1) (b :: k2). GHC.Internal.Show.Show (a GHC.Internal.Data.Type.Equality.:~~: b) -- Defined in ‘GHC.Internal.Data.Type.Equality’
instance GHC.Internal.Show.Show GHC.Internal.Data.Data.Constr -- Defined in ‘GHC.Internal.Data.Data’
instance GHC.Internal.Show.Show GHC.Internal.Data.Data.ConstrRep -- Defined in ‘GHC.Internal.Data.Data’
instance GHC.Internal.Show.Show GHC.Internal.Data.Data.DataRep -- Defined in ‘GHC.Internal.Data.Data’
instance GHC.Internal.Show.Show GHC.Internal.Data.Data.DataType -- Defined in ‘GHC.Internal.Data.Data’
instance GHC.Internal.Show.Show GHC.Internal.Data.Data.Fixity -- Defined in ‘GHC.Internal.Data.Data’
instance forall k (s :: k). GHC.Internal.Show.Show (GHC.Internal.Data.Proxy.Proxy s) -- Defined in ‘GHC.Internal.Data.Proxy’
instance GHC.Internal.Show.Show ghc-internal-0.1.0.0:GHC.Internal.Data.Typeable.Internal.SomeTypeRep -- Defined in ‘ghc-internal-0.1.0.0:GHC.Internal.Data.Typeable.Internal’
instance forall k (a :: k). GHC.Internal.Show.Show (ghc-internal-0.1.0.0:GHC.Internal.Data.Typeable.Internal.TypeRep a) -- Defined in ‘ghc-internal-0.1.0.0:GHC.Internal.Data.Typeable.Internal’
instance GHC.Internal.Show.Show GHC.Internal.Data.Dynamic.Dynamic -- Defined in ‘GHC.Internal.Data.Dynamic’
instance forall a b. (GHC.Internal.Show.Show a, GHC.Internal.Show.Show b) => GHC.Internal.Show.Show (GHC.Internal.Data.Either.Either a b) -- Defined in ‘GHC.Internal.Data.Either’
instance forall k (a :: k). Data.Fixed.HasResolution a => GHC.Internal.Show.Show (Data.Fixed.Fixed a) -- Defined in ‘Data.Fixed’
instance forall k1 k2 (f :: k1 -> *) (g :: k2 -> k1) (a :: k2). GHC.Internal.Show.Show (f (g a)) => GHC.Internal.Show.Show (Data.Functor.Compose.Compose f g a) -- Defined in ‘Data.Functor.Compose’
instance forall a. GHC.Internal.Show.Show a => GHC.Internal.Show.Show (GHC.Internal.Data.Functor.Identity.Identity a) -- Defined in ‘GHC.Internal.Data.Functor.Identity’
instance [safe] forall k (f :: k -> *) (a :: k) (g :: k -> *). (GHC.Internal.Show.Show (f a), GHC.Internal.Show.Show (g a)) => GHC.Internal.Show.Show (Data.Functor.Product.Product f g a) -- Defined in ‘Data.Functor.Product’
instance [safe] forall k (f :: k -> *) (a :: k) (g :: k -> *). (GHC.Internal.Show.Show (f a), GHC.Internal.Show.Show (g a)) => GHC.Internal.Show.Show (Data.Functor.Sum.Sum f g a) -- Defined in ‘Data.Functor.Sum’
instance GHC.Internal.Show.Show GHC.Internal.Int.Int16 -- Defined in ‘GHC.Internal.Int’
instance GHC.Internal.Show.Show GHC.Internal.Int.Int32 -- Defined in ‘GHC.Internal.Int’
instance GHC.Internal.Show.Show GHC.Internal.Int.Int64 -- Defined in ‘GHC.Internal.Int’
instance GHC.Internal.Show.Show GHC.Internal.Int.Int8 -- Defined in ‘GHC.Internal.Int’
instance GHC.Internal.Show.Show GHC.Internal.Data.Semigroup.Internal.All -- Defined in ‘GHC.Internal.Data.Semigroup.Internal’
instance forall k (f :: k -> *) (a :: k). GHC.Internal.Show.Show (f a) => GHC.Internal.Show.Show (GHC.Internal.Data.Semigroup.Internal.Alt f a) -- Defined in ‘GHC.Internal.Data.Semigroup.Internal’
instance GHC.Internal.Show.Show GHC.Internal.Data.Semigroup.Internal.Any -- Defined in ‘GHC.Internal.Data.Semigroup.Internal’
instance forall a. GHC.Internal.Show.Show a => GHC.Internal.Show.Show (GHC.Internal.Data.Semigroup.Internal.Dual a) -- Defined in ‘GHC.Internal.Data.Semigroup.Internal’
instance forall a. GHC.Internal.Show.Show a => GHC.Internal.Show.Show (GHC.Internal.Data.Semigroup.Internal.Product a) -- Defined in ‘GHC.Internal.Data.Semigroup.Internal’
instance forall a. GHC.Internal.Show.Show a => GHC.Internal.Show.Show (GHC.Internal.Data.Semigroup.Internal.Sum a) -- Defined in ‘GHC.Internal.Data.Semigroup.Internal’
instance forall k (f :: k -> *) (a :: k). GHC.Internal.Show.Show (f a) => GHC.Internal.Show.Show (GHC.Internal.Data.Monoid.Ap f a) -- Defined in ‘GHC.Internal.Data.Monoid’
instance forall a. GHC.Internal.Show.Show a => GHC.Internal.Show.Show (GHC.Internal.Data.Monoid.First a) -- Defined in ‘GHC.Internal.Data.Monoid’
instance forall a. GHC.Internal.Show.Show a => GHC.Internal.Show.Show (GHC.Internal.Data.Monoid.Last a) -- Defined in ‘GHC.Internal.Data.Monoid’
instance forall a. GHC.Internal.Show.Show a => GHC.Internal.Show.Show (GHC.Internal.Data.Ord.Down a) -- Defined in ‘GHC.Internal.Data.Ord’
instance GHC.Internal.Show.Show GHC.Internal.Real.FractionalExponentBase -- Defined in ‘GHC.Internal.Real’
instance forall a. GHC.Internal.Show.Show a => GHC.Internal.Show.Show (GHC.Internal.Real.Ratio a) -- Defined in ‘GHC.Internal.Real’
instance forall a b. (GHC.Internal.Show.Show a, GHC.Internal.Show.Show b) => GHC.Internal.Show.Show (Data.Semigroup.Arg a b) -- Defined in ‘Data.Semigroup’
instance forall a. GHC.Internal.Show.Show a => GHC.Internal.Show.Show (Data.Semigroup.First a) -- Defined in ‘Data.Semigroup’
instance forall a. GHC.Internal.Show.Show a => GHC.Internal.Show.Show (Data.Semigroup.Last a) -- Defined in ‘Data.Semigroup’
instance forall a. GHC.Internal.Show.Show a => GHC.Internal.Show.Show (Data.Semigroup.Max a) -- Defined in ‘Data.Semigroup’
instance forall a. GHC.Internal.Show.Show a => GHC.Internal.Show.Show (Data.Semigroup.Min a) -- Defined in ‘Data.Semigroup’
instance forall m. GHC.Internal.Show.Show m => GHC.Internal.Show.Show (Data.Semigroup.WrappedMonoid m) -- Defined in ‘Data.Semigroup’
instance forall k (a :: k) (b :: k). GHC.Internal.Show.Show (GHC.Internal.Data.Type.Coercion.Coercion a b) -- Defined in ‘GHC.Internal.Data.Type.Coercion’
instance forall k (a :: k) (b :: k). GHC.Internal.Show.Show (GHC.Internal.Data.Type.Ord.OrderingI a b) -- Defined in ‘GHC.Internal.Data.Type.Ord’
instance GHC.Internal.Show.Show GHC.Internal.Data.Version.Version -- Defined in ‘GHC.Internal.Data.Version’
instance GHC.Internal.Show.Show GHC.Internal.Word.Word16 -- Defined in ‘GHC.Internal.Word’
instance GHC.Internal.Show.Show GHC.Internal.Word.Word32 -- Defined in ‘GHC.Internal.Word’
instance GHC.Internal.Show.Show GHC.Internal.Word.Word64 -- Defined in ‘GHC.Internal.Word’
instance GHC.Internal.Show.Show GHC.Internal.Word.Word8 -- Defined in ‘GHC.Internal.Word’
instance forall a. GHC.Internal.Show.Show (GHC.Internal.ForeignPtr.ForeignPtr a) -- Defined in ‘GHC.Internal.ForeignPtr’
instance forall a. GHC.Internal.Show.Show (GHC.Internal.Ptr.FunPtr a) -- Defined in ‘GHC.Internal.Ptr’
instance forall a. GHC.Internal.Show.Show (GHC.Internal.Ptr.Ptr a) -- Defined in ‘GHC.Internal.Ptr’
instance GHC.Internal.Show.Show GHC.Internal.Foreign.Ptr.IntPtr -- Defined in ‘GHC.Internal.Foreign.Ptr’
instance GHC.Internal.Show.Show GHC.Internal.Foreign.Ptr.WordPtr -- Defined in ‘GHC.Internal.Foreign.Ptr’
instance GHC.Internal.Show.Show GHC.Internal.Foreign.C.Types.CBool -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Show.Show GHC.Internal.Foreign.C.Types.CChar -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Show.Show GHC.Internal.Foreign.C.Types.CClock -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Show.Show GHC.Internal.Foreign.C.Types.CDouble -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Show.Show GHC.Internal.Foreign.C.Types.CFloat -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Show.Show GHC.Internal.Foreign.C.Types.CInt -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Show.Show GHC.Internal.Foreign.C.Types.CIntMax -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Show.Show GHC.Internal.Foreign.C.Types.CIntPtr -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Show.Show GHC.Internal.Foreign.C.Types.CLLong -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Show.Show GHC.Internal.Foreign.C.Types.CLong -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Show.Show GHC.Internal.Foreign.C.Types.CPtrdiff -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Show.Show GHC.Internal.Foreign.C.Types.CSChar -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Show.Show GHC.Internal.Foreign.C.Types.CSUSeconds -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Show.Show GHC.Internal.Foreign.C.Types.CShort -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Show.Show GHC.Internal.Foreign.C.Types.CSigAtomic -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Show.Show GHC.Internal.Foreign.C.Types.CSize -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Show.Show GHC.Internal.Foreign.C.Types.CTime -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Show.Show GHC.Internal.Foreign.C.Types.CUChar -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Show.Show GHC.Internal.Foreign.C.Types.CUInt -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Show.Show GHC.Internal.Foreign.C.Types.CUIntMax -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Show.Show GHC.Internal.Foreign.C.Types.CUIntPtr -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Show.Show GHC.Internal.Foreign.C.Types.CULLong -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Show.Show GHC.Internal.Foreign.C.Types.CULong -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Show.Show GHC.Internal.Foreign.C.Types.CUSeconds -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Show.Show GHC.Internal.Foreign.C.Types.CUShort -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Internal.Show.Show GHC.Internal.Foreign.C.Types.CWchar -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance forall a. GHC.Internal.Show.Show (GHC.Internal.Foreign.C.ConstPtr.ConstPtr a) -- Defined in ‘GHC.Internal.Foreign.C.ConstPtr’
instance forall a b. (GHC.Internal.Ix.Ix a, GHC.Internal.Show.Show a, GHC.Internal.Show.Show b) => GHC.Internal.Show.Show (GHC.Internal.Arr.Array a b) -- Defined in ‘GHC.Internal.Arr’
instance GHC.Internal.Show.Show GHC.Internal.ByteOrder.ByteOrder -- Defined in ‘GHC.Internal.ByteOrder’
instance GHC.Internal.Show.Show ghc-internal-0.1.0.0:GHC.Internal.Event.Internal.Types.Event -- Defined in ‘ghc-internal-0.1.0.0:GHC.Internal.Event.Internal.Types’
instance GHC.Internal.Show.Show ghc-internal-0.1.0.0:GHC.Internal.Event.Internal.Types.EventLifetime -- Defined in ‘ghc-internal-0.1.0.0:GHC.Internal.Event.Internal.Types’
instance GHC.Internal.Show.Show ghc-internal-0.1.0.0:GHC.Internal.Event.Internal.Types.Lifetime -- Defined in ‘ghc-internal-0.1.0.0:GHC.Internal.Event.Internal.Types’
instance GHC.Internal.Show.Show ghc-internal-0.1.0.0:GHC.Internal.Event.Internal.Types.Timeout -- Defined in ‘ghc-internal-0.1.0.0:GHC.Internal.Event.Internal.Types’
instance GHC.Internal.Show.Show ghc-internal-0.1.0.0:GHC.Internal.Event.Manager.FdKey -- Defined in ‘ghc-internal-0.1.0.0:GHC.Internal.Event.Manager’
instance GHC.Internal.Show.Show ghc-internal-0.1.0.0:GHC.Internal.Event.Manager.State -- Defined in ‘ghc-internal-0.1.0.0:GHC.Internal.Event.Manager’
instance GHC.Internal.Show.Show ghc-internal-0.1.0.0:GHC.Internal.Event.TimerManager.State -- Defined in ‘ghc-internal-0.1.0.0:GHC.Internal.Event.TimerManager’
instance GHC.Internal.Show.Show GHC.Internal.Fingerprint.Type.Fingerprint -- Defined in ‘GHC.Internal.Fingerprint.Type’
instance GHC.Internal.Show.Show GHC.Types.Double -- Defined in ‘GHC.Internal.Float’
instance GHC.Internal.Show.Show GHC.Types.Float -- Defined in ‘GHC.Internal.Float’
instance forall k (f :: k -> *) (g :: k -> *) (p :: k). (GHC.Internal.Show.Show (f p), GHC.Internal.Show.Show (g p)) => GHC.Internal.Show.Show ((GHC.Internal.Generics.:*:) f g p) -- Defined in ‘GHC.Internal.Generics’
instance forall k (f :: k -> *) (g :: k -> *) (p :: k). (GHC.Internal.Show.Show (f p), GHC.Internal.Show.Show (g p)) => GHC.Internal.Show.Show ((GHC.Internal.Generics.:+:) f g p) -- Defined in ‘GHC.Internal.Generics’
instance forall k2 (f :: k2 -> *) k1 (g :: k1 -> k2) (p :: k1). GHC.Internal.Show.Show (f (g p)) => GHC.Internal.Show.Show ((GHC.Internal.Generics.:.:) f g p) -- Defined in ‘GHC.Internal.Generics’
instance GHC.Internal.Show.Show GHC.Internal.Generics.Associativity -- Defined in ‘GHC.Internal.Generics’
instance GHC.Internal.Show.Show GHC.Internal.Generics.DecidedStrictness -- Defined in ‘GHC.Internal.Generics’
instance GHC.Internal.Show.Show GHC.Internal.Generics.Fixity -- Defined in ‘GHC.Internal.Generics’
instance forall i c k (p :: k). GHC.Internal.Show.Show c => GHC.Internal.Show.Show (GHC.Internal.Generics.K1 i c p) -- Defined in ‘GHC.Internal.Generics’
instance forall i (c :: GHC.Internal.Generics.Meta) k (f :: k -> *) (p :: k). GHC.Internal.Show.Show (f p) => GHC.Internal.Show.Show (GHC.Internal.Generics.M1 i c f p) -- Defined in ‘GHC.Internal.Generics’
instance forall p. GHC.Internal.Show.Show p => GHC.Internal.Show.Show (GHC.Internal.Generics.Par1 p) -- Defined in ‘GHC.Internal.Generics’
instance forall k (f :: k -> *) (p :: k). GHC.Internal.Show.Show (f p) => GHC.Internal.Show.Show (GHC.Internal.Generics.Rec1 f p) -- Defined in ‘GHC.Internal.Generics’
instance GHC.Internal.Show.Show GHC.Internal.Generics.SourceStrictness -- Defined in ‘GHC.Internal.Generics’
instance GHC.Internal.Show.Show GHC.Internal.Generics.SourceUnpackedness -- Defined in ‘GHC.Internal.Generics’
instance forall k (p :: k). GHC.Internal.Show.Show (GHC.Internal.Generics.U1 p) -- Defined in ‘GHC.Internal.Generics’
instance forall k (p :: k). GHC.Internal.Show.Show (GHC.Internal.Generics.URec GHC.Types.Char p) -- Defined in ‘GHC.Internal.Generics’
instance forall k (p :: k). GHC.Internal.Show.Show (GHC.Internal.Generics.URec GHC.Types.Double p) -- Defined in ‘GHC.Internal.Generics’
instance forall k (p :: k). GHC.Internal.Show.Show (GHC.Internal.Generics.URec GHC.Types.Float p) -- Defined in ‘GHC.Internal.Generics’
instance forall k (p :: k). GHC.Internal.Show.Show (GHC.Internal.Generics.URec GHC.Types.Int p) -- Defined in ‘GHC.Internal.Generics’
instance forall k (p :: k). GHC.Internal.Show.Show (GHC.Internal.Generics.URec GHC.Types.Word p) -- Defined in ‘GHC.Internal.Generics’
instance forall k (p :: k). GHC.Internal.Show.Show (GHC.Internal.Generics.V1 p) -- Defined in ‘GHC.Internal.Generics’
instance GHC.Internal.Show.Show GHC.Internal.IO.Device.SeekMode -- Defined in ‘GHC.Internal.IO.Device’
instance GHC.Internal.Show.Show GHC.Internal.IO.Encoding.Types.CodingProgress -- Defined in ‘GHC.Internal.IO.Encoding.Types’
instance GHC.Internal.Show.Show GHC.Internal.IO.Encoding.Types.TextEncoding -- Defined in ‘GHC.Internal.IO.Encoding.Types’
instance GHC.Internal.Show.Show GHC.Internal.IO.Encoding.Failure.CodingFailureMode -- Defined in ‘GHC.Internal.IO.Encoding.Failure’
instance GHC.Internal.Show.Show GHC.Internal.IO.FD.FD -- Defined in ‘GHC.Internal.IO.FD’
instance GHC.Internal.Show.Show GHC.Internal.IO.Handle.Types.BufferMode -- Defined in ‘GHC.Internal.IO.Handle.Types’
instance GHC.Internal.Show.Show GHC.Internal.IO.Handle.Types.Handle -- Defined in ‘GHC.Internal.IO.Handle.Types’
instance GHC.Internal.Show.Show GHC.Internal.IO.Handle.Types.HandleType -- Defined in ‘GHC.Internal.IO.Handle.Types’
instance GHC.Internal.Show.Show GHC.Internal.IO.Handle.Types.Newline -- Defined in ‘GHC.Internal.IO.Handle.Types’
instance GHC.Internal.Show.Show GHC.Internal.IO.Handle.Types.NewlineMode -- Defined in ‘GHC.Internal.IO.Handle.Types’
instance [safe] GHC.Internal.Show.Show ghc-internal-0.1.0.0:GHC.Internal.IO.Handle.Lock.Common.FileLockingNotSupported -- Defined in ‘ghc-internal-0.1.0.0:GHC.Internal.IO.Handle.Lock.Common’
instance GHC.Internal.Show.Show GHC.Internal.IO.Handle.HandlePosn -- Defined in ‘GHC.Internal.IO.Handle’
instance GHC.Internal.Show.Show GHC.Internal.IO.IOMode.IOMode -- Defined in ‘GHC.Internal.IO.IOMode’
instance GHC.Internal.Show.Show GHC.Internal.RTS.Flags.CCFlags -- Defined in ‘GHC.Internal.RTS.Flags’
instance GHC.Internal.Show.Show GHC.Internal.RTS.Flags.ConcFlags -- Defined in ‘GHC.Internal.RTS.Flags’
instance GHC.Internal.Show.Show GHC.Internal.RTS.Flags.DebugFlags -- Defined in ‘GHC.Internal.RTS.Flags’
instance GHC.Internal.Show.Show GHC.Internal.RTS.Flags.DoCostCentres -- Defined in ‘GHC.Internal.RTS.Flags’
instance GHC.Internal.Show.Show GHC.Internal.RTS.Flags.DoHeapProfile -- Defined in ‘GHC.Internal.RTS.Flags’
instance GHC.Internal.Show.Show GHC.Internal.RTS.Flags.DoTrace -- Defined in ‘GHC.Internal.RTS.Flags’
instance GHC.Internal.Show.Show GHC.Internal.RTS.Flags.GCFlags -- Defined in ‘GHC.Internal.RTS.Flags’
instance GHC.Internal.Show.Show GHC.Internal.RTS.Flags.GiveGCStats -- Defined in ‘GHC.Internal.RTS.Flags’
instance GHC.Internal.Show.Show GHC.Internal.RTS.Flags.HpcFlags -- Defined in ‘GHC.Internal.RTS.Flags’
instance GHC.Internal.Show.Show GHC.Internal.RTS.Flags.IoSubSystem -- Defined in ‘GHC.Internal.RTS.Flags’
instance GHC.Internal.Show.Show GHC.Internal.RTS.Flags.MiscFlags -- Defined in ‘GHC.Internal.RTS.Flags’
instance GHC.Internal.Show.Show GHC.Internal.RTS.Flags.ParFlags -- Defined in ‘GHC.Internal.RTS.Flags’
instance GHC.Internal.Show.Show GHC.Internal.RTS.Flags.ProfFlags -- Defined in ‘GHC.Internal.RTS.Flags’
instance GHC.Internal.Show.Show GHC.Internal.RTS.Flags.RTSFlags -- Defined in ‘GHC.Internal.RTS.Flags’
instance GHC.Internal.Show.Show GHC.Internal.RTS.Flags.TickyFlags -- Defined in ‘GHC.Internal.RTS.Flags’
instance GHC.Internal.Show.Show GHC.Internal.RTS.Flags.TraceFlags -- Defined in ‘GHC.Internal.RTS.Flags’
instance GHC.Internal.Show.Show GHC.Internal.IOPort.IOPortException -- Defined in ‘GHC.Internal.IOPort’
instance GHC.Internal.Show.Show GHC.Internal.InfoProv.InfoProv -- Defined in ‘GHC.Internal.InfoProv’
instance GHC.Internal.Show.Show GHC.Internal.Stack.CloneStack.StackEntry -- Defined in ‘GHC.Internal.Stack.CloneStack’
instance GHC.Internal.Show.Show GHC.Internal.StaticPtr.StaticPtrInfo -- Defined in ‘GHC.Internal.StaticPtr’
instance GHC.Internal.Show.Show GHC.Internal.Stats.GCDetails -- Defined in ‘GHC.Internal.Stats’
instance GHC.Internal.Show.Show GHC.Internal.Stats.RTSStats -- Defined in ‘GHC.Internal.Stats’
instance forall (n :: GHC.Internal.TypeNats.Nat). GHC.Internal.Show.Show (GHC.Internal.TypeNats.SNat n) -- Defined in ‘GHC.Internal.TypeNats’
instance GHC.Internal.Show.Show GHC.Internal.TypeNats.SomeNat -- Defined in ‘GHC.Internal.TypeNats’
instance forall (c :: GHC.Types.Char). GHC.Internal.Show.Show (GHC.Internal.TypeLits.SChar c) -- Defined in ‘GHC.Internal.TypeLits’
instance forall (s :: GHC.Types.Symbol). GHC.Internal.Show.Show (GHC.Internal.TypeLits.SSymbol s) -- Defined in ‘GHC.Internal.TypeLits’
instance GHC.Internal.Show.Show GHC.Internal.TypeLits.SomeChar -- Defined in ‘GHC.Internal.TypeLits’
instance GHC.Internal.Show.Show GHC.Internal.TypeLits.SomeSymbol -- Defined in ‘GHC.Internal.TypeLits’
instance [safe] GHC.Internal.Show.Show System.Timeout.Timeout -- Defined in ‘System.Timeout’
instance GHC.Internal.Show.Show GHC.Internal.Text.Read.Lex.Lexeme -- Defined in ‘GHC.Internal.Text.Read.Lex’
instance GHC.Internal.Show.Show GHC.Internal.Text.Read.Lex.Number -- Defined in ‘GHC.Internal.Text.Read.Lex’
instance GHC.Internal.StaticPtr.IsStatic GHC.Internal.StaticPtr.StaticPtr -- Defined in ‘GHC.Internal.StaticPtr’
instance forall a. GHC.Classes.Eq a => GHC.Classes.Eq (GHC.Internal.Base.NonEmpty a) -- Defined in ‘GHC.Internal.Base’
instance GHC.Classes.Eq GHC.Internal.Base.Void -- Defined in ‘GHC.Internal.Base’
instance forall a k (b :: k). GHC.Classes.Eq a => GHC.Classes.Eq (GHC.Internal.Data.Functor.Const.Const a b) -- Defined in ‘GHC.Internal.Data.Functor.Const’
instance forall a. GHC.Classes.Eq a => GHC.Classes.Eq (GHC.Internal.Functor.ZipList.ZipList a) -- Defined in ‘GHC.Internal.Functor.ZipList’
instance forall a. GHC.Classes.Eq (Control.Concurrent.Chan.Chan a) -- Defined in ‘Control.Concurrent.Chan’
instance forall a. GHC.Classes.Eq (GHC.Internal.MVar.MVar a) -- Defined in ‘GHC.Internal.MVar’
instance GHC.Classes.Eq GHC.Internal.Conc.Sync.BlockReason -- Defined in ‘GHC.Internal.Conc.Sync’
instance forall a. GHC.Classes.Eq (GHC.Internal.Conc.Sync.TVar a) -- Defined in ‘GHC.Internal.Conc.Sync’
instance GHC.Classes.Eq GHC.Internal.Conc.Sync.ThreadId -- Defined in ‘GHC.Internal.Conc.Sync’
instance GHC.Classes.Eq GHC.Internal.Conc.Sync.ThreadStatus -- Defined in ‘GHC.Internal.Conc.Sync’
instance GHC.Classes.Eq GHC.Internal.IO.Exception.ArrayException -- Defined in ‘GHC.Internal.IO.Exception’
instance GHC.Classes.Eq GHC.Internal.IO.Exception.AsyncException -- Defined in ‘GHC.Internal.IO.Exception’
instance GHC.Classes.Eq GHC.Internal.IO.Exception.ExitCode -- Defined in ‘GHC.Internal.IO.Exception’
instance GHC.Classes.Eq GHC.Internal.IO.Exception.IOErrorType -- Defined in ‘GHC.Internal.IO.Exception’
instance GHC.Classes.Eq GHC.Internal.IO.Exception.IOException -- Defined in ‘GHC.Internal.IO.Exception’
instance GHC.Classes.Eq GHC.Internal.Exception.Type.ArithException -- Defined in ‘GHC.Internal.Exception.Type’
instance GHC.Classes.Eq GHC.Internal.Exception.ErrorCall -- Defined in ‘GHC.Internal.Exception’
instance GHC.Classes.Eq GHC.Internal.IO.MaskingState -- Defined in ‘GHC.Internal.IO’
instance GHC.Classes.Eq Data.Array.Byte.ByteArray -- Defined in ‘Data.Array.Byte’
instance forall s. GHC.Classes.Eq (Data.Array.Byte.MutableByteArray s) -- Defined in ‘Data.Array.Byte’
instance forall a. GHC.Classes.Eq a => GHC.Classes.Eq (GHC.Internal.Data.Bits.And a) -- Defined in ‘GHC.Internal.Data.Bits’
instance forall a. GHC.Classes.Eq a => GHC.Classes.Eq (GHC.Internal.Data.Bits.Iff a) -- Defined in ‘GHC.Internal.Data.Bits’
instance forall a. GHC.Classes.Eq a => GHC.Classes.Eq (GHC.Internal.Data.Bits.Ior a) -- Defined in ‘GHC.Internal.Data.Bits’
instance forall a. GHC.Classes.Eq a => GHC.Classes.Eq (GHC.Internal.Data.Bits.Xor a) -- Defined in ‘GHC.Internal.Data.Bits’
instance GHC.Classes.Eq GHC.Types.Bool -- Defined in ‘GHC.Classes’
instance GHC.Classes.Eq GHC.Types.Char -- Defined in ‘GHC.Classes’
instance GHC.Classes.Eq GHC.Types.Double -- Defined in ‘GHC.Classes’
instance GHC.Classes.Eq GHC.Types.Float -- Defined in ‘GHC.Classes’
instance GHC.Classes.Eq GHC.Types.Int -- Defined in ‘GHC.Classes’
instance forall a. GHC.Classes.Eq a => GHC.Classes.Eq [a] -- Defined in ‘GHC.Classes’
instance GHC.Classes.Eq GHC.Types.Module -- Defined in ‘GHC.Classes’
instance GHC.Classes.Eq GHC.Types.Ordering -- Defined in ‘GHC.Classes’
instance forall a. GHC.Classes.Eq a => GHC.Classes.Eq (Solo a) -- Defined in ‘GHC.Classes’
instance GHC.Classes.Eq GHC.Types.TrName -- Defined in ‘GHC.Classes’
instance forall a b c d e f g h i j. (GHC.Classes.Eq a, GHC.Classes.Eq b, GHC.Classes.Eq c, GHC.Classes.Eq d, GHC.Classes.Eq e, GHC.Classes.Eq f, GHC.Classes.Eq g, GHC.Classes.Eq h, GHC.Classes.Eq i, GHC.Classes.Eq j) => GHC.Classes.Eq (a, b, c, d, e, f, g, h, i, j) -- Defined in ‘GHC.Classes’
instance forall a b c d e f g h i j k. (GHC.Classes.Eq a, GHC.Classes.Eq b, GHC.Classes.Eq c, GHC.Classes.Eq d, GHC.Classes.Eq e, GHC.Classes.Eq f, GHC.Classes.Eq g, GHC.Classes.Eq h, GHC.Classes.Eq i, GHC.Classes.Eq j, GHC.Classes.Eq k) => GHC.Classes.Eq (a, b, c, d, e, f, g, h, i, j, k) -- Defined in ‘GHC.Classes’
instance forall a b c d e f g h i j k l. (GHC.Classes.Eq a, GHC.Classes.Eq b, GHC.Classes.Eq c, GHC.Classes.Eq d, GHC.Classes.Eq e, GHC.Classes.Eq f, GHC.Classes.Eq g, GHC.Classes.Eq h, GHC.Classes.Eq i, GHC.Classes.Eq j, GHC.Classes.Eq k, GHC.Classes.Eq l) => GHC.Classes.Eq (a, b, c, d, e, f, g, h, i, j, k, l) -- Defined in ‘GHC.Classes’
instance forall a b c d e f g h i j k l m. (GHC.Classes.Eq a, GHC.Classes.Eq b, GHC.Classes.Eq c, GHC.Classes.Eq d, GHC.Classes.Eq e, GHC.Classes.Eq f, GHC.Classes.Eq g, GHC.Classes.Eq h, GHC.Classes.Eq i, GHC.Classes.Eq j, GHC.Classes.Eq k, GHC.Classes.Eq l, GHC.Classes.Eq m) => GHC.Classes.Eq (a, b, c, d, e, f, g, h, i, j, k, l, m) -- Defined in ‘GHC.Classes’
instance forall a b c d e f g h i j k l m n. (GHC.Classes.Eq a, GHC.Classes.Eq b, GHC.Classes.Eq c, GHC.Classes.Eq d, GHC.Classes.Eq e, GHC.Classes.Eq f, GHC.Classes.Eq g, GHC.Classes.Eq h, GHC.Classes.Eq i, GHC.Classes.Eq j, GHC.Classes.Eq k, GHC.Classes.Eq l, GHC.Classes.Eq m, GHC.Classes.Eq n) => GHC.Classes.Eq (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -- Defined in ‘GHC.Classes’
instance forall a b c d e f g h i j k l m n o. (GHC.Classes.Eq a, GHC.Classes.Eq b, GHC.Classes.Eq c, GHC.Classes.Eq d, GHC.Classes.Eq e, GHC.Classes.Eq f, GHC.Classes.Eq g, GHC.Classes.Eq h, GHC.Classes.Eq i, GHC.Classes.Eq j, GHC.Classes.Eq k, GHC.Classes.Eq l, GHC.Classes.Eq m, GHC.Classes.Eq n, GHC.Classes.Eq o) => GHC.Classes.Eq (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -- Defined in ‘GHC.Classes’
instance forall a b. (GHC.Classes.Eq a, GHC.Classes.Eq b) => GHC.Classes.Eq (a, b) -- Defined in ‘GHC.Classes’
instance forall a b c. (GHC.Classes.Eq a, GHC.Classes.Eq b, GHC.Classes.Eq c) => GHC.Classes.Eq (a, b, c) -- Defined in ‘GHC.Classes’
instance forall a b c d. (GHC.Classes.Eq a, GHC.Classes.Eq b, GHC.Classes.Eq c, GHC.Classes.Eq d) => GHC.Classes.Eq (a, b, c, d) -- Defined in ‘GHC.Classes’
instance forall a b c d e. (GHC.Classes.Eq a, GHC.Classes.Eq b, GHC.Classes.Eq c, GHC.Classes.Eq d, GHC.Classes.Eq e) => GHC.Classes.Eq (a, b, c, d, e) -- Defined in ‘GHC.Classes’
instance forall a b c d e f. (GHC.Classes.Eq a, GHC.Classes.Eq b, GHC.Classes.Eq c, GHC.Classes.Eq d, GHC.Classes.Eq e, GHC.Classes.Eq f) => GHC.Classes.Eq (a, b, c, d, e, f) -- Defined in ‘GHC.Classes’
instance forall a b c d e f g. (GHC.Classes.Eq a, GHC.Classes.Eq b, GHC.Classes.Eq c, GHC.Classes.Eq d, GHC.Classes.Eq e, GHC.Classes.Eq f, GHC.Classes.Eq g) => GHC.Classes.Eq (a, b, c, d, e, f, g) -- Defined in ‘GHC.Classes’
instance forall a b c d e f g h. (GHC.Classes.Eq a, GHC.Classes.Eq b, GHC.Classes.Eq c, GHC.Classes.Eq d, GHC.Classes.Eq e, GHC.Classes.Eq f, GHC.Classes.Eq g, GHC.Classes.Eq h) => GHC.Classes.Eq (a, b, c, d, e, f, g, h) -- Defined in ‘GHC.Classes’
instance forall a b c d e f g h i. (GHC.Classes.Eq a, GHC.Classes.Eq b, GHC.Classes.Eq c, GHC.Classes.Eq d, GHC.Classes.Eq e, GHC.Classes.Eq f, GHC.Classes.Eq g, GHC.Classes.Eq h, GHC.Classes.Eq i) => GHC.Classes.Eq (a, b, c, d, e, f, g, h, i) -- Defined in ‘GHC.Classes’
instance GHC.Classes.Eq GHC.Types.TyCon -- Defined in ‘GHC.Classes’
instance GHC.Classes.Eq () -- Defined in ‘GHC.Classes’
instance GHC.Classes.Eq GHC.Types.Word -- Defined in ‘GHC.Classes’
instance GHC.Classes.Eq GHC.Internal.Unicode.GeneralCategory -- Defined in ‘GHC.Internal.Unicode’
instance forall a. GHC.Classes.Eq a => GHC.Classes.Eq (Data.Complex.Complex a) -- Defined in ‘Data.Complex’
instance forall k (a :: k) (b :: k). GHC.Classes.Eq (a GHC.Internal.Data.Type.Equality.:~: b) -- Defined in ‘GHC.Internal.Data.Type.Equality’
instance forall k1 k2 (a :: k1) (b :: k2). GHC.Classes.Eq (a GHC.Internal.Data.Type.Equality.:~~: b) -- Defined in ‘GHC.Internal.Data.Type.Equality’
instance GHC.Classes.Eq GHC.Internal.Data.Data.Constr -- Defined in ‘GHC.Internal.Data.Data’
instance GHC.Classes.Eq GHC.Internal.Data.Data.ConstrRep -- Defined in ‘GHC.Internal.Data.Data’
instance GHC.Classes.Eq GHC.Internal.Data.Data.DataRep -- Defined in ‘GHC.Internal.Data.Data’
instance GHC.Classes.Eq GHC.Internal.Data.Data.Fixity -- Defined in ‘GHC.Internal.Data.Data’
instance forall k (s :: k). GHC.Classes.Eq (GHC.Internal.Data.Proxy.Proxy s) -- Defined in ‘GHC.Internal.Data.Proxy’
instance GHC.Classes.Eq ghc-internal-0.1.0.0:GHC.Internal.Data.Typeable.Internal.SomeTypeRep -- Defined in ‘ghc-internal-0.1.0.0:GHC.Internal.Data.Typeable.Internal’
instance forall k (a :: k). GHC.Classes.Eq (ghc-internal-0.1.0.0:GHC.Internal.Data.Typeable.Internal.TypeRep a) -- Defined in ‘ghc-internal-0.1.0.0:GHC.Internal.Data.Typeable.Internal’
instance forall a b. (GHC.Classes.Eq a, GHC.Classes.Eq b) => GHC.Classes.Eq (GHC.Internal.Data.Either.Either a b) -- Defined in ‘GHC.Internal.Data.Either’
instance forall k (a :: k). GHC.Classes.Eq (Data.Fixed.Fixed a) -- Defined in ‘Data.Fixed’
instance forall k1 k2 (f :: k1 -> *) (g :: k2 -> k1) (a :: k2). GHC.Classes.Eq (f (g a)) => GHC.Classes.Eq (Data.Functor.Compose.Compose f g a) -- Defined in ‘Data.Functor.Compose’
instance forall a. GHC.Classes.Eq a => GHC.Classes.Eq (GHC.Internal.Data.Functor.Identity.Identity a) -- Defined in ‘GHC.Internal.Data.Functor.Identity’
instance [safe] forall k (f :: k -> *) (a :: k) (g :: k -> *). (GHC.Classes.Eq (f a), GHC.Classes.Eq (g a)) => GHC.Classes.Eq (Data.Functor.Product.Product f g a) -- Defined in ‘Data.Functor.Product’
instance [safe] forall k (f :: k -> *) (a :: k) (g :: k -> *). (GHC.Classes.Eq (f a), GHC.Classes.Eq (g a)) => GHC.Classes.Eq (Data.Functor.Sum.Sum f g a) -- Defined in ‘Data.Functor.Sum’
instance forall a. GHC.Classes.Eq (GHC.Internal.IORef.IORef a) -- Defined in ‘GHC.Internal.IORef’
instance GHC.Classes.Eq GHC.Internal.Int.Int16 -- Defined in ‘GHC.Internal.Int’
instance GHC.Classes.Eq GHC.Internal.Int.Int32 -- Defined in ‘GHC.Internal.Int’
instance GHC.Classes.Eq GHC.Internal.Int.Int64 -- Defined in ‘GHC.Internal.Int’
instance GHC.Classes.Eq GHC.Internal.Int.Int8 -- Defined in ‘GHC.Internal.Int’
instance forall a. GHC.Classes.Eq a => GHC.Classes.Eq (GHC.Internal.Maybe.Maybe a) -- Defined in ‘GHC.Internal.Maybe’
instance GHC.Classes.Eq GHC.Internal.Data.Semigroup.Internal.All -- Defined in ‘GHC.Internal.Data.Semigroup.Internal’
instance forall k (f :: k -> *) (a :: k). GHC.Classes.Eq (f a) => GHC.Classes.Eq (GHC.Internal.Data.Semigroup.Internal.Alt f a) -- Defined in ‘GHC.Internal.Data.Semigroup.Internal’
instance GHC.Classes.Eq GHC.Internal.Data.Semigroup.Internal.Any -- Defined in ‘GHC.Internal.Data.Semigroup.Internal’
instance forall a. GHC.Classes.Eq a => GHC.Classes.Eq (GHC.Internal.Data.Semigroup.Internal.Dual a) -- Defined in ‘GHC.Internal.Data.Semigroup.Internal’
instance forall a. GHC.Classes.Eq a => GHC.Classes.Eq (GHC.Internal.Data.Semigroup.Internal.Product a) -- Defined in ‘GHC.Internal.Data.Semigroup.Internal’
instance forall a. GHC.Classes.Eq a => GHC.Classes.Eq (GHC.Internal.Data.Semigroup.Internal.Sum a) -- Defined in ‘GHC.Internal.Data.Semigroup.Internal’
instance forall k (f :: k -> *) (a :: k). GHC.Classes.Eq (f a) => GHC.Classes.Eq (GHC.Internal.Data.Monoid.Ap f a) -- Defined in ‘GHC.Internal.Data.Monoid’
instance forall a. GHC.Classes.Eq a => GHC.Classes.Eq (GHC.Internal.Data.Monoid.First a) -- Defined in ‘GHC.Internal.Data.Monoid’
instance forall a. GHC.Classes.Eq a => GHC.Classes.Eq (GHC.Internal.Data.Monoid.Last a) -- Defined in ‘GHC.Internal.Data.Monoid’
instance forall a. GHC.Classes.Eq a => GHC.Classes.Eq (GHC.Internal.Data.Ord.Down a) -- Defined in ‘GHC.Internal.Data.Ord’
instance forall a. GHC.Classes.Eq a => GHC.Classes.Eq (GHC.Internal.Real.Ratio a) -- Defined in ‘GHC.Internal.Real’
instance forall s a. GHC.Classes.Eq (GHC.Internal.STRef.STRef s a) -- Defined in ‘GHC.Internal.STRef’
instance forall a b. GHC.Classes.Eq a => GHC.Classes.Eq (Data.Semigroup.Arg a b) -- Defined in ‘Data.Semigroup’
instance forall a. GHC.Classes.Eq a => GHC.Classes.Eq (Data.Semigroup.First a) -- Defined in ‘Data.Semigroup’
instance forall a. GHC.Classes.Eq a => GHC.Classes.Eq (Data.Semigroup.Last a) -- Defined in ‘Data.Semigroup’
instance forall a. GHC.Classes.Eq a => GHC.Classes.Eq (Data.Semigroup.Max a) -- Defined in ‘Data.Semigroup’
instance forall a. GHC.Classes.Eq a => GHC.Classes.Eq (Data.Semigroup.Min a) -- Defined in ‘Data.Semigroup’
instance forall m. GHC.Classes.Eq m => GHC.Classes.Eq (Data.Semigroup.WrappedMonoid m) -- Defined in ‘Data.Semigroup’
instance forall k (a :: k) (b :: k). GHC.Classes.Eq (GHC.Internal.Data.Type.Coercion.Coercion a b) -- Defined in ‘GHC.Internal.Data.Type.Coercion’
instance forall k (a :: k) (b :: k). GHC.Classes.Eq (GHC.Internal.Data.Type.Ord.OrderingI a b) -- Defined in ‘GHC.Internal.Data.Type.Ord’
instance GHC.Classes.Eq GHC.Internal.Data.Unique.Unique -- Defined in ‘GHC.Internal.Data.Unique’
instance GHC.Classes.Eq GHC.Internal.Data.Version.Version -- Defined in ‘GHC.Internal.Data.Version’
instance GHC.Classes.Eq GHC.Internal.Word.Word16 -- Defined in ‘GHC.Internal.Word’
instance GHC.Classes.Eq GHC.Internal.Word.Word32 -- Defined in ‘GHC.Internal.Word’
instance GHC.Classes.Eq GHC.Internal.Word.Word64 -- Defined in ‘GHC.Internal.Word’
instance GHC.Classes.Eq GHC.Internal.Word.Word8 -- Defined in ‘GHC.Internal.Word’
instance forall a. GHC.Classes.Eq (GHC.Internal.ForeignPtr.ForeignPtr a) -- Defined in ‘GHC.Internal.ForeignPtr’
instance forall a. GHC.Classes.Eq (GHC.Internal.Ptr.FunPtr a) -- Defined in ‘GHC.Internal.Ptr’
instance forall a. GHC.Classes.Eq (GHC.Internal.Ptr.Ptr a) -- Defined in ‘GHC.Internal.Ptr’
instance GHC.Classes.Eq GHC.Internal.Foreign.Ptr.IntPtr -- Defined in ‘GHC.Internal.Foreign.Ptr’
instance GHC.Classes.Eq GHC.Internal.Foreign.Ptr.WordPtr -- Defined in ‘GHC.Internal.Foreign.Ptr’
instance forall a. GHC.Classes.Eq (GHC.Internal.Stable.StablePtr a) -- Defined in ‘GHC.Internal.Stable’
instance GHC.Classes.Eq GHC.Internal.Foreign.C.Types.CBool -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Classes.Eq GHC.Internal.Foreign.C.Types.CChar -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Classes.Eq GHC.Internal.Foreign.C.Types.CClock -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Classes.Eq GHC.Internal.Foreign.C.Types.CDouble -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Classes.Eq GHC.Internal.Foreign.C.Types.CFloat -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Classes.Eq GHC.Internal.Foreign.C.Types.CInt -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Classes.Eq GHC.Internal.Foreign.C.Types.CIntMax -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Classes.Eq GHC.Internal.Foreign.C.Types.CIntPtr -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Classes.Eq GHC.Internal.Foreign.C.Types.CLLong -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Classes.Eq GHC.Internal.Foreign.C.Types.CLong -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Classes.Eq GHC.Internal.Foreign.C.Types.CPtrdiff -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Classes.Eq GHC.Internal.Foreign.C.Types.CSChar -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Classes.Eq GHC.Internal.Foreign.C.Types.CSUSeconds -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Classes.Eq GHC.Internal.Foreign.C.Types.CShort -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Classes.Eq GHC.Internal.Foreign.C.Types.CSigAtomic -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Classes.Eq GHC.Internal.Foreign.C.Types.CSize -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Classes.Eq GHC.Internal.Foreign.C.Types.CTime -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Classes.Eq GHC.Internal.Foreign.C.Types.CUChar -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Classes.Eq GHC.Internal.Foreign.C.Types.CUInt -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Classes.Eq GHC.Internal.Foreign.C.Types.CUIntMax -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Classes.Eq GHC.Internal.Foreign.C.Types.CUIntPtr -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Classes.Eq GHC.Internal.Foreign.C.Types.CULLong -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Classes.Eq GHC.Internal.Foreign.C.Types.CULong -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Classes.Eq GHC.Internal.Foreign.C.Types.CUSeconds -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Classes.Eq GHC.Internal.Foreign.C.Types.CUShort -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Classes.Eq GHC.Internal.Foreign.C.Types.CWchar -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Classes.Eq GHC.Internal.Foreign.C.Error.Errno -- Defined in ‘GHC.Internal.Foreign.C.Error’
instance forall a. GHC.Classes.Eq (GHC.Internal.Foreign.C.ConstPtr.ConstPtr a) -- Defined in ‘GHC.Internal.Foreign.C.ConstPtr’
instance forall i e. (GHC.Internal.Ix.Ix i, GHC.Classes.Eq e) => GHC.Classes.Eq (GHC.Internal.Arr.Array i e) -- Defined in ‘GHC.Internal.Arr’
instance forall s i e. GHC.Classes.Eq (GHC.Internal.Arr.STArray s i e) -- Defined in ‘GHC.Internal.Arr’
instance GHC.Classes.Eq GHC.Internal.ByteOrder.ByteOrder -- Defined in ‘GHC.Internal.ByteOrder’
instance GHC.Classes.Eq ghc-internal-0.1.0.0:GHC.Internal.Event.Internal.Types.Event -- Defined in ‘ghc-internal-0.1.0.0:GHC.Internal.Event.Internal.Types’
instance GHC.Classes.Eq ghc-internal-0.1.0.0:GHC.Internal.Event.Internal.Types.EventLifetime -- Defined in ‘ghc-internal-0.1.0.0:GHC.Internal.Event.Internal.Types’
instance GHC.Classes.Eq ghc-internal-0.1.0.0:GHC.Internal.Event.Internal.Types.Lifetime -- Defined in ‘ghc-internal-0.1.0.0:GHC.Internal.Event.Internal.Types’
instance GHC.Classes.Eq ghc-internal-0.1.0.0:GHC.Internal.Event.Manager.FdKey -- Defined in ‘ghc-internal-0.1.0.0:GHC.Internal.Event.Manager’
instance GHC.Classes.Eq ghc-internal-0.1.0.0:GHC.Internal.Event.Manager.State -- Defined in ‘ghc-internal-0.1.0.0:GHC.Internal.Event.Manager’
instance GHC.Classes.Eq GHC.Internal.Event.TimeOut.TimeoutKey -- Defined in ‘GHC.Internal.Event.TimeOut’
instance GHC.Classes.Eq ghc-internal-0.1.0.0:GHC.Internal.Event.TimerManager.State -- Defined in ‘ghc-internal-0.1.0.0:GHC.Internal.Event.TimerManager’
instance GHC.Classes.Eq GHC.Internal.Stack.Types.SrcLoc -- Defined in ‘GHC.Internal.Stack.Types’
instance GHC.Classes.Eq GHC.Internal.Exts.SpecConstrAnnotation -- Defined in ‘GHC.Internal.Exts’
instance GHC.Classes.Eq GHC.Internal.Fingerprint.Type.Fingerprint -- Defined in ‘GHC.Internal.Fingerprint.Type’
instance forall k (f :: k -> *) (g :: k -> *) (p :: k). (GHC.Classes.Eq (f p), GHC.Classes.Eq (g p)) => GHC.Classes.Eq ((GHC.Internal.Generics.:*:) f g p) -- Defined in ‘GHC.Internal.Generics’
instance forall k (f :: k -> *) (g :: k -> *) (p :: k). (GHC.Classes.Eq (f p), GHC.Classes.Eq (g p)) => GHC.Classes.Eq ((GHC.Internal.Generics.:+:) f g p) -- Defined in ‘GHC.Internal.Generics’
instance forall k2 (f :: k2 -> *) k1 (g :: k1 -> k2) (p :: k1). GHC.Classes.Eq (f (g p)) => GHC.Classes.Eq ((GHC.Internal.Generics.:.:) f g p) -- Defined in ‘GHC.Internal.Generics’
instance GHC.Classes.Eq GHC.Internal.Generics.Associativity -- Defined in ‘GHC.Internal.Generics’
instance GHC.Classes.Eq GHC.Internal.Generics.DecidedStrictness -- Defined in ‘GHC.Internal.Generics’
instance GHC.Classes.Eq GHC.Internal.Generics.Fixity -- Defined in ‘GHC.Internal.Generics’
instance forall k (f :: k -> *) (a :: k). (GHC.Internal.Generics.Generic1 f, GHC.Classes.Eq (GHC.Internal.Generics.Rep1 f a)) => GHC.Classes.Eq (GHC.Internal.Generics.Generically1 f a) -- Defined in ‘GHC.Internal.Generics’
instance forall i c k (p :: k). GHC.Classes.Eq c => GHC.Classes.Eq (GHC.Internal.Generics.K1 i c p) -- Defined in ‘GHC.Internal.Generics’
instance forall i (c :: GHC.Internal.Generics.Meta) k (f :: k -> *) (p :: k). GHC.Classes.Eq (f p) => GHC.Classes.Eq (GHC.Internal.Generics.M1 i c f p) -- Defined in ‘GHC.Internal.Generics’
instance forall p. GHC.Classes.Eq p => GHC.Classes.Eq (GHC.Internal.Generics.Par1 p) -- Defined in ‘GHC.Internal.Generics’
instance forall k (f :: k -> *) (p :: k). GHC.Classes.Eq (f p) => GHC.Classes.Eq (GHC.Internal.Generics.Rec1 f p) -- Defined in ‘GHC.Internal.Generics’
instance GHC.Classes.Eq GHC.Internal.Generics.SourceStrictness -- Defined in ‘GHC.Internal.Generics’
instance GHC.Classes.Eq GHC.Internal.Generics.SourceUnpackedness -- Defined in ‘GHC.Internal.Generics’
instance forall k (p :: k). GHC.Classes.Eq (GHC.Internal.Generics.U1 p) -- Defined in ‘GHC.Internal.Generics’
instance forall k (p :: k). GHC.Classes.Eq (GHC.Internal.Generics.URec (GHC.Internal.Ptr.Ptr ()) p) -- Defined in ‘GHC.Internal.Generics’
instance forall k (p :: k). GHC.Classes.Eq (GHC.Internal.Generics.URec GHC.Types.Char p) -- Defined in ‘GHC.Internal.Generics’
instance forall k (p :: k). GHC.Classes.Eq (GHC.Internal.Generics.URec GHC.Types.Double p) -- Defined in ‘GHC.Internal.Generics’
instance forall k (p :: k). GHC.Classes.Eq (GHC.Internal.Generics.URec GHC.Types.Float p) -- Defined in ‘GHC.Internal.Generics’
instance forall k (p :: k). GHC.Classes.Eq (GHC.Internal.Generics.URec GHC.Types.Int p) -- Defined in ‘GHC.Internal.Generics’
instance forall k (p :: k). GHC.Classes.Eq (GHC.Internal.Generics.URec GHC.Types.Word p) -- Defined in ‘GHC.Internal.Generics’
instance forall k (p :: k). GHC.Classes.Eq (GHC.Internal.Generics.V1 p) -- Defined in ‘GHC.Internal.Generics’
instance GHC.Classes.Eq GHC.Internal.IO.Buffer.BufferState -- Defined in ‘GHC.Internal.IO.Buffer’
instance GHC.Classes.Eq GHC.Internal.IO.Device.IODeviceType -- Defined in ‘GHC.Internal.IO.Device’
instance GHC.Classes.Eq GHC.Internal.IO.Device.SeekMode -- Defined in ‘GHC.Internal.IO.Device’
instance GHC.Classes.Eq GHC.Internal.IO.Encoding.Types.CodingProgress -- Defined in ‘GHC.Internal.IO.Encoding.Types’
instance GHC.Classes.Eq GHC.Internal.IO.Handle.Types.BufferMode -- Defined in ‘GHC.Internal.IO.Handle.Types’
instance GHC.Classes.Eq GHC.Internal.IO.Handle.Types.Handle -- Defined in ‘GHC.Internal.IO.Handle.Types’
instance GHC.Classes.Eq GHC.Internal.IO.Handle.Types.Newline -- Defined in ‘GHC.Internal.IO.Handle.Types’
instance GHC.Classes.Eq GHC.Internal.IO.Handle.Types.NewlineMode -- Defined in ‘GHC.Internal.IO.Handle.Types’
instance GHC.Classes.Eq GHC.Internal.IO.Handle.HandlePosn -- Defined in ‘GHC.Internal.IO.Handle’
instance GHC.Classes.Eq GHC.Internal.IO.IOMode.IOMode -- Defined in ‘GHC.Internal.IO.IOMode’
instance GHC.Classes.Eq GHC.Internal.RTS.Flags.IoSubSystem -- Defined in ‘GHC.Internal.RTS.Flags’
instance forall i e. GHC.Classes.Eq (GHC.Internal.IOArray.IOArray i e) -- Defined in ‘GHC.Internal.IOArray’
instance forall a. GHC.Classes.Eq (GHC.Internal.IOPort.IOPort a) -- Defined in ‘GHC.Internal.IOPort’
instance GHC.Classes.Eq GHC.Internal.InfoProv.InfoProv -- Defined in ‘GHC.Internal.InfoProv’
instance GHC.Classes.Eq GHC.Num.Integer.Integer -- Defined in ‘GHC.Num.Integer’
instance GHC.Classes.Eq GHC.Num.BigNat.BigNat -- Defined in ‘GHC.Num.BigNat’
instance GHC.Classes.Eq GHC.Num.Natural.Natural -- Defined in ‘GHC.Num.Natural’
instance forall a. GHC.Classes.Eq (GHC.Internal.StableName.StableName a) -- Defined in ‘GHC.Internal.StableName’
instance GHC.Classes.Eq GHC.Internal.Stack.CloneStack.StackEntry -- Defined in ‘GHC.Internal.Stack.CloneStack’
instance forall (n :: GHC.Internal.TypeNats.Nat). GHC.Classes.Eq (GHC.Internal.TypeNats.SNat n) -- Defined in ‘GHC.Internal.TypeNats’
instance GHC.Classes.Eq GHC.Internal.TypeNats.SomeNat -- Defined in ‘GHC.Internal.TypeNats’
instance forall (c :: GHC.Types.Char). GHC.Classes.Eq (GHC.Internal.TypeLits.SChar c) -- Defined in ‘GHC.Internal.TypeLits’
instance forall (s :: GHC.Types.Symbol). GHC.Classes.Eq (GHC.Internal.TypeLits.SSymbol s) -- Defined in ‘GHC.Internal.TypeLits’
instance GHC.Classes.Eq GHC.Internal.TypeLits.SomeChar -- Defined in ‘GHC.Internal.TypeLits’
instance GHC.Classes.Eq GHC.Internal.TypeLits.SomeSymbol -- Defined in ‘GHC.Internal.TypeLits’
instance [safe] GHC.Classes.Eq System.Timeout.Timeout -- Defined in ‘System.Timeout’
instance GHC.Classes.Eq GHC.Internal.Text.Read.Lex.Lexeme -- Defined in ‘GHC.Internal.Text.Read.Lex’
instance GHC.Classes.Eq GHC.Internal.Text.Read.Lex.Number -- Defined in ‘GHC.Internal.Text.Read.Lex’
instance forall a. GHC.Classes.Ord a => GHC.Classes.Ord (GHC.Internal.Base.NonEmpty a) -- Defined in ‘GHC.Internal.Base’
instance GHC.Classes.Ord GHC.Internal.Base.Void -- Defined in ‘GHC.Internal.Base’
instance forall a k (b :: k). GHC.Classes.Ord a => GHC.Classes.Ord (GHC.Internal.Data.Functor.Const.Const a b) -- Defined in ‘GHC.Internal.Data.Functor.Const’
instance forall a. GHC.Classes.Ord a => GHC.Classes.Ord (GHC.Internal.Functor.ZipList.ZipList a) -- Defined in ‘GHC.Internal.Functor.ZipList’
instance GHC.Classes.Ord GHC.Internal.Conc.Sync.BlockReason -- Defined in ‘GHC.Internal.Conc.Sync’
instance GHC.Classes.Ord GHC.Internal.Conc.Sync.ThreadId -- Defined in ‘GHC.Internal.Conc.Sync’
instance GHC.Classes.Ord GHC.Internal.Conc.Sync.ThreadStatus -- Defined in ‘GHC.Internal.Conc.Sync’
instance GHC.Classes.Ord GHC.Internal.IO.Exception.ArrayException -- Defined in ‘GHC.Internal.IO.Exception’
instance GHC.Classes.Ord GHC.Internal.IO.Exception.AsyncException -- Defined in ‘GHC.Internal.IO.Exception’
instance GHC.Classes.Ord GHC.Internal.IO.Exception.ExitCode -- Defined in ‘GHC.Internal.IO.Exception’
instance GHC.Classes.Ord GHC.Internal.Exception.Type.ArithException -- Defined in ‘GHC.Internal.Exception.Type’
instance GHC.Classes.Ord GHC.Internal.Exception.ErrorCall -- Defined in ‘GHC.Internal.Exception’
instance GHC.Classes.Ord Data.Array.Byte.ByteArray -- Defined in ‘Data.Array.Byte’
instance GHC.Classes.Ord GHC.Types.Bool -- Defined in ‘GHC.Classes’
instance GHC.Classes.Ord GHC.Types.Char -- Defined in ‘GHC.Classes’
instance GHC.Classes.Ord GHC.Types.Double -- Defined in ‘GHC.Classes’
instance GHC.Classes.Ord GHC.Types.Float -- Defined in ‘GHC.Classes’
instance GHC.Classes.Ord GHC.Types.Int -- Defined in ‘GHC.Classes’
instance forall a. GHC.Classes.Ord a => GHC.Classes.Ord [a] -- Defined in ‘GHC.Classes’
instance GHC.Classes.Ord GHC.Types.Ordering -- Defined in ‘GHC.Classes’
instance forall a. GHC.Classes.Ord a => GHC.Classes.Ord (Solo a) -- Defined in ‘GHC.Classes’
instance forall a b c d e f g h i j. (GHC.Classes.Ord a, GHC.Classes.Ord b, GHC.Classes.Ord c, GHC.Classes.Ord d, GHC.Classes.Ord e, GHC.Classes.Ord f, GHC.Classes.Ord g, GHC.Classes.Ord h, GHC.Classes.Ord i, GHC.Classes.Ord j) => GHC.Classes.Ord (a, b, c, d, e, f, g, h, i, j) -- Defined in ‘GHC.Classes’
instance forall a b c d e f g h i j k. (GHC.Classes.Ord a, GHC.Classes.Ord b, GHC.Classes.Ord c, GHC.Classes.Ord d, GHC.Classes.Ord e, GHC.Classes.Ord f, GHC.Classes.Ord g, GHC.Classes.Ord h, GHC.Classes.Ord i, GHC.Classes.Ord j, GHC.Classes.Ord k) => GHC.Classes.Ord (a, b, c, d, e, f, g, h, i, j, k) -- Defined in ‘GHC.Classes’
instance forall a b c d e f g h i j k l. (GHC.Classes.Ord a, GHC.Classes.Ord b, GHC.Classes.Ord c, GHC.Classes.Ord d, GHC.Classes.Ord e, GHC.Classes.Ord f, GHC.Classes.Ord g, GHC.Classes.Ord h, GHC.Classes.Ord i, GHC.Classes.Ord j, GHC.Classes.Ord k, GHC.Classes.Ord l) => GHC.Classes.Ord (a, b, c, d, e, f, g, h, i, j, k, l) -- Defined in ‘GHC.Classes’
instance forall a b c d e f g h i j k l m. (GHC.Classes.Ord a, GHC.Classes.Ord b, GHC.Classes.Ord c, GHC.Classes.Ord d, GHC.Classes.Ord e, GHC.Classes.Ord f, GHC.Classes.Ord g, GHC.Classes.Ord h, GHC.Classes.Ord i, GHC.Classes.Ord j, GHC.Classes.Ord k, GHC.Classes.Ord l, GHC.Classes.Ord m) => GHC.Classes.Ord (a, b, c, d, e, f, g, h, i, j, k, l, m) -- Defined in ‘GHC.Classes’
instance forall a b c d e f g h i j k l m n. (GHC.Classes.Ord a, GHC.Classes.Ord b, GHC.Classes.Ord c, GHC.Classes.Ord d, GHC.Classes.Ord e, GHC.Classes.Ord f, GHC.Classes.Ord g, GHC.Classes.Ord h, GHC.Classes.Ord i, GHC.Classes.Ord j, GHC.Classes.Ord k, GHC.Classes.Ord l, GHC.Classes.Ord m, GHC.Classes.Ord n) => GHC.Classes.Ord (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -- Defined in ‘GHC.Classes’
instance forall a b c d e f g h i j k l m n o. (GHC.Classes.Ord a, GHC.Classes.Ord b, GHC.Classes.Ord c, GHC.Classes.Ord d, GHC.Classes.Ord e, GHC.Classes.Ord f, GHC.Classes.Ord g, GHC.Classes.Ord h, GHC.Classes.Ord i, GHC.Classes.Ord j, GHC.Classes.Ord k, GHC.Classes.Ord l, GHC.Classes.Ord m, GHC.Classes.Ord n, GHC.Classes.Ord o) => GHC.Classes.Ord (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -- Defined in ‘GHC.Classes’
instance forall a b. (GHC.Classes.Ord a, GHC.Classes.Ord b) => GHC.Classes.Ord (a, b) -- Defined in ‘GHC.Classes’
instance forall a b c. (GHC.Classes.Ord a, GHC.Classes.Ord b, GHC.Classes.Ord c) => GHC.Classes.Ord (a, b, c) -- Defined in ‘GHC.Classes’
instance forall a b c d. (GHC.Classes.Ord a, GHC.Classes.Ord b, GHC.Classes.Ord c, GHC.Classes.Ord d) => GHC.Classes.Ord (a, b, c, d) -- Defined in ‘GHC.Classes’
instance forall a b c d e. (GHC.Classes.Ord a, GHC.Classes.Ord b, GHC.Classes.Ord c, GHC.Classes.Ord d, GHC.Classes.Ord e) => GHC.Classes.Ord (a, b, c, d, e) -- Defined in ‘GHC.Classes’
instance forall a b c d e f. (GHC.Classes.Ord a, GHC.Classes.Ord b, GHC.Classes.Ord c, GHC.Classes.Ord d, GHC.Classes.Ord e, GHC.Classes.Ord f) => GHC.Classes.Ord (a, b, c, d, e, f) -- Defined in ‘GHC.Classes’
instance forall a b c d e f g. (GHC.Classes.Ord a, GHC.Classes.Ord b, GHC.Classes.Ord c, GHC.Classes.Ord d, GHC.Classes.Ord e, GHC.Classes.Ord f, GHC.Classes.Ord g) => GHC.Classes.Ord (a, b, c, d, e, f, g) -- Defined in ‘GHC.Classes’
instance forall a b c d e f g h. (GHC.Classes.Ord a, GHC.Classes.Ord b, GHC.Classes.Ord c, GHC.Classes.Ord d, GHC.Classes.Ord e, GHC.Classes.Ord f, GHC.Classes.Ord g, GHC.Classes.Ord h) => GHC.Classes.Ord (a, b, c, d, e, f, g, h) -- Defined in ‘GHC.Classes’
instance forall a b c d e f g h i. (GHC.Classes.Ord a, GHC.Classes.Ord b, GHC.Classes.Ord c, GHC.Classes.Ord d, GHC.Classes.Ord e, GHC.Classes.Ord f, GHC.Classes.Ord g, GHC.Classes.Ord h, GHC.Classes.Ord i) => GHC.Classes.Ord (a, b, c, d, e, f, g, h, i) -- Defined in ‘GHC.Classes’
instance GHC.Classes.Ord GHC.Types.TyCon -- Defined in ‘GHC.Classes’
instance GHC.Classes.Ord () -- Defined in ‘GHC.Classes’
instance GHC.Classes.Ord GHC.Types.Word -- Defined in ‘GHC.Classes’
instance GHC.Classes.Ord GHC.Internal.Unicode.GeneralCategory -- Defined in ‘GHC.Internal.Unicode’
instance forall k (a :: k) (b :: k). GHC.Classes.Ord (a GHC.Internal.Data.Type.Equality.:~: b) -- Defined in ‘GHC.Internal.Data.Type.Equality’
instance forall k1 k2 (a :: k1) (b :: k2). GHC.Classes.Ord (a GHC.Internal.Data.Type.Equality.:~~: b) -- Defined in ‘GHC.Internal.Data.Type.Equality’
instance forall k (s :: k). GHC.Classes.Ord (GHC.Internal.Data.Proxy.Proxy s) -- Defined in ‘GHC.Internal.Data.Proxy’
instance GHC.Classes.Ord ghc-internal-0.1.0.0:GHC.Internal.Data.Typeable.Internal.SomeTypeRep -- Defined in ‘ghc-internal-0.1.0.0:GHC.Internal.Data.Typeable.Internal’
instance forall k (a :: k). GHC.Classes.Ord (ghc-internal-0.1.0.0:GHC.Internal.Data.Typeable.Internal.TypeRep a) -- Defined in ‘ghc-internal-0.1.0.0:GHC.Internal.Data.Typeable.Internal’
instance forall a b. (GHC.Classes.Ord a, GHC.Classes.Ord b) => GHC.Classes.Ord (GHC.Internal.Data.Either.Either a b) -- Defined in ‘GHC.Internal.Data.Either’
instance forall k (a :: k). GHC.Classes.Ord (Data.Fixed.Fixed a) -- Defined in ‘Data.Fixed’
instance forall k1 k2 (f :: k1 -> *) (g :: k2 -> k1) (a :: k2). GHC.Classes.Ord (f (g a)) => GHC.Classes.Ord (Data.Functor.Compose.Compose f g a) -- Defined in ‘Data.Functor.Compose’
instance forall a. GHC.Classes.Ord a => GHC.Classes.Ord (GHC.Internal.Data.Functor.Identity.Identity a) -- Defined in ‘GHC.Internal.Data.Functor.Identity’
instance [safe] forall k (f :: k -> *) (a :: k) (g :: k -> *). (GHC.Classes.Ord (f a), GHC.Classes.Ord (g a)) => GHC.Classes.Ord (Data.Functor.Product.Product f g a) -- Defined in ‘Data.Functor.Product’
instance [safe] forall k (f :: k -> *) (a :: k) (g :: k -> *). (GHC.Classes.Ord (f a), GHC.Classes.Ord (g a)) => GHC.Classes.Ord (Data.Functor.Sum.Sum f g a) -- Defined in ‘Data.Functor.Sum’
instance GHC.Classes.Ord GHC.Internal.Int.Int16 -- Defined in ‘GHC.Internal.Int’
instance GHC.Classes.Ord GHC.Internal.Int.Int32 -- Defined in ‘GHC.Internal.Int’
instance GHC.Classes.Ord GHC.Internal.Int.Int64 -- Defined in ‘GHC.Internal.Int’
instance GHC.Classes.Ord GHC.Internal.Int.Int8 -- Defined in ‘GHC.Internal.Int’
instance forall a. GHC.Classes.Ord a => GHC.Classes.Ord (GHC.Internal.Maybe.Maybe a) -- Defined in ‘GHC.Internal.Maybe’
instance GHC.Classes.Ord GHC.Internal.Data.Semigroup.Internal.All -- Defined in ‘GHC.Internal.Data.Semigroup.Internal’
instance forall k (f :: k -> *) (a :: k). GHC.Classes.Ord (f a) => GHC.Classes.Ord (GHC.Internal.Data.Semigroup.Internal.Alt f a) -- Defined in ‘GHC.Internal.Data.Semigroup.Internal’
instance GHC.Classes.Ord GHC.Internal.Data.Semigroup.Internal.Any -- Defined in ‘GHC.Internal.Data.Semigroup.Internal’
instance forall a. GHC.Classes.Ord a => GHC.Classes.Ord (GHC.Internal.Data.Semigroup.Internal.Dual a) -- Defined in ‘GHC.Internal.Data.Semigroup.Internal’
instance forall a. GHC.Classes.Ord a => GHC.Classes.Ord (GHC.Internal.Data.Semigroup.Internal.Product a) -- Defined in ‘GHC.Internal.Data.Semigroup.Internal’
instance forall a. GHC.Classes.Ord a => GHC.Classes.Ord (GHC.Internal.Data.Semigroup.Internal.Sum a) -- Defined in ‘GHC.Internal.Data.Semigroup.Internal’
instance forall k (f :: k -> *) (a :: k). GHC.Classes.Ord (f a) => GHC.Classes.Ord (GHC.Internal.Data.Monoid.Ap f a) -- Defined in ‘GHC.Internal.Data.Monoid’
instance forall a. GHC.Classes.Ord a => GHC.Classes.Ord (GHC.Internal.Data.Monoid.First a) -- Defined in ‘GHC.Internal.Data.Monoid’
instance forall a. GHC.Classes.Ord a => GHC.Classes.Ord (GHC.Internal.Data.Monoid.Last a) -- Defined in ‘GHC.Internal.Data.Monoid’
instance forall a. GHC.Classes.Ord a => GHC.Classes.Ord (GHC.Internal.Data.Ord.Down a) -- Defined in ‘GHC.Internal.Data.Ord’
instance forall a. GHC.Internal.Real.Integral a => GHC.Classes.Ord (GHC.Internal.Real.Ratio a) -- Defined in ‘GHC.Internal.Real’
instance forall a b. GHC.Classes.Ord a => GHC.Classes.Ord (Data.Semigroup.Arg a b) -- Defined in ‘Data.Semigroup’
instance forall a. GHC.Classes.Ord a => GHC.Classes.Ord (Data.Semigroup.First a) -- Defined in ‘Data.Semigroup’
instance forall a. GHC.Classes.Ord a => GHC.Classes.Ord (Data.Semigroup.Last a) -- Defined in ‘Data.Semigroup’
instance forall a. GHC.Classes.Ord a => GHC.Classes.Ord (Data.Semigroup.Max a) -- Defined in ‘Data.Semigroup’
instance forall a. GHC.Classes.Ord a => GHC.Classes.Ord (Data.Semigroup.Min a) -- Defined in ‘Data.Semigroup’
instance forall m. GHC.Classes.Ord m => GHC.Classes.Ord (Data.Semigroup.WrappedMonoid m) -- Defined in ‘Data.Semigroup’
instance forall k (a :: k) (b :: k). GHC.Classes.Ord (GHC.Internal.Data.Type.Coercion.Coercion a b) -- Defined in ‘GHC.Internal.Data.Type.Coercion’
instance GHC.Classes.Ord GHC.Internal.Data.Unique.Unique -- Defined in ‘GHC.Internal.Data.Unique’
instance GHC.Classes.Ord GHC.Internal.Data.Version.Version -- Defined in ‘GHC.Internal.Data.Version’
instance GHC.Classes.Ord GHC.Internal.Word.Word16 -- Defined in ‘GHC.Internal.Word’
instance GHC.Classes.Ord GHC.Internal.Word.Word32 -- Defined in ‘GHC.Internal.Word’
instance GHC.Classes.Ord GHC.Internal.Word.Word64 -- Defined in ‘GHC.Internal.Word’
instance GHC.Classes.Ord GHC.Internal.Word.Word8 -- Defined in ‘GHC.Internal.Word’
instance forall a. GHC.Classes.Ord (GHC.Internal.ForeignPtr.ForeignPtr a) -- Defined in ‘GHC.Internal.ForeignPtr’
instance forall a. GHC.Classes.Ord (GHC.Internal.Ptr.FunPtr a) -- Defined in ‘GHC.Internal.Ptr’
instance forall a. GHC.Classes.Ord (GHC.Internal.Ptr.Ptr a) -- Defined in ‘GHC.Internal.Ptr’
instance GHC.Classes.Ord GHC.Internal.Foreign.Ptr.IntPtr -- Defined in ‘GHC.Internal.Foreign.Ptr’
instance GHC.Classes.Ord GHC.Internal.Foreign.Ptr.WordPtr -- Defined in ‘GHC.Internal.Foreign.Ptr’
instance GHC.Classes.Ord GHC.Internal.Foreign.C.Types.CBool -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Classes.Ord GHC.Internal.Foreign.C.Types.CChar -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Classes.Ord GHC.Internal.Foreign.C.Types.CClock -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Classes.Ord GHC.Internal.Foreign.C.Types.CDouble -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Classes.Ord GHC.Internal.Foreign.C.Types.CFloat -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Classes.Ord GHC.Internal.Foreign.C.Types.CInt -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Classes.Ord GHC.Internal.Foreign.C.Types.CIntMax -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Classes.Ord GHC.Internal.Foreign.C.Types.CIntPtr -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Classes.Ord GHC.Internal.Foreign.C.Types.CLLong -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Classes.Ord GHC.Internal.Foreign.C.Types.CLong -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Classes.Ord GHC.Internal.Foreign.C.Types.CPtrdiff -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Classes.Ord GHC.Internal.Foreign.C.Types.CSChar -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Classes.Ord GHC.Internal.Foreign.C.Types.CSUSeconds -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Classes.Ord GHC.Internal.Foreign.C.Types.CShort -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Classes.Ord GHC.Internal.Foreign.C.Types.CSigAtomic -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Classes.Ord GHC.Internal.Foreign.C.Types.CSize -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Classes.Ord GHC.Internal.Foreign.C.Types.CTime -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Classes.Ord GHC.Internal.Foreign.C.Types.CUChar -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Classes.Ord GHC.Internal.Foreign.C.Types.CUInt -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Classes.Ord GHC.Internal.Foreign.C.Types.CUIntMax -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Classes.Ord GHC.Internal.Foreign.C.Types.CUIntPtr -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Classes.Ord GHC.Internal.Foreign.C.Types.CULLong -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Classes.Ord GHC.Internal.Foreign.C.Types.CULong -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Classes.Ord GHC.Internal.Foreign.C.Types.CUSeconds -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Classes.Ord GHC.Internal.Foreign.C.Types.CUShort -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance GHC.Classes.Ord GHC.Internal.Foreign.C.Types.CWchar -- Defined in ‘GHC.Internal.Foreign.C.Types’
instance forall a. GHC.Classes.Ord (GHC.Internal.Foreign.C.ConstPtr.ConstPtr a) -- Defined in ‘GHC.Internal.Foreign.C.ConstPtr’
instance forall i e. (GHC.Internal.Ix.Ix i, GHC.Classes.Ord e) => GHC.Classes.Ord (GHC.Internal.Arr.Array i e) -- Defined in ‘GHC.Internal.Arr’
instance GHC.Classes.Ord GHC.Internal.ByteOrder.ByteOrder -- Defined in ‘GHC.Internal.ByteOrder’
instance GHC.Classes.Ord GHC.Internal.Event.TimeOut.TimeoutKey -- Defined in ‘GHC.Internal.Event.TimeOut’
instance GHC.Classes.Ord GHC.Internal.Fingerprint.Type.Fingerprint -- Defined in ‘GHC.Internal.Fingerprint.Type’
instance forall k (f :: k -> *) (g :: k -> *) (p :: k). (GHC.Classes.Ord (f p), GHC.Classes.Ord (g p)) => GHC.Classes.Ord ((GHC.Internal.Generics.:*:) f g p) -- Defined in ‘GHC.Internal.Generics’
instance forall k (f :: k -> *) (g :: k -> *) (p :: k). (GHC.Classes.Ord (f p), GHC.Classes.Ord (g p)) => GHC.Classes.Ord ((GHC.Internal.Generics.:+:) f g p) -- Defined in ‘GHC.Internal.Generics’
instance forall k2 (f :: k2 -> *) k1 (g :: k1 -> k2) (p :: k1). GHC.Classes.Ord (f (g p)) => GHC.Classes.Ord ((GHC.Internal.Generics.:.:) f g p) -- Defined in ‘GHC.Internal.Generics’
instance GHC.Classes.Ord GHC.Internal.Generics.Associativity -- Defined in ‘GHC.Internal.Generics’
instance GHC.Classes.Ord GHC.Internal.Generics.DecidedStrictness -- Defined in ‘GHC.Internal.Generics’
instance GHC.Classes.Ord GHC.Internal.Generics.Fixity -- Defined in ‘GHC.Internal.Generics’
instance forall k (f :: k -> *) (a :: k). (GHC.Internal.Generics.Generic1 f, GHC.Classes.Ord (GHC.Internal.Generics.Rep1 f a)) => GHC.Classes.Ord (GHC.Internal.Generics.Generically1 f a) -- Defined in ‘GHC.Internal.Generics’
instance forall i c k (p :: k). GHC.Classes.Ord c => GHC.Classes.Ord (GHC.Internal.Generics.K1 i c p) -- Defined in ‘GHC.Internal.Generics’
instance forall i (c :: GHC.Internal.Generics.Meta) k (f :: k -> *) (p :: k). GHC.Classes.Ord (f p) => GHC.Classes.Ord (GHC.Internal.Generics.M1 i c f p) -- Defined in ‘GHC.Internal.Generics’
instance forall p. GHC.Classes.Ord p => GHC.Classes.Ord (GHC.Internal.Generics.Par1 p) -- Defined in ‘GHC.Internal.Generics’
instance forall k (f :: k -> *) (p :: k). GHC.Classes.Ord (f p) => GHC.Classes.Ord (GHC.Internal.Generics.Rec1 f p) -- Defined in ‘GHC.Internal.Generics’
instance GHC.Classes.Ord GHC.Internal.Generics.SourceStrictness -- Defined in ‘GHC.Internal.Generics’
instance GHC.Classes.Ord GHC.Internal.Generics.SourceUnpackedness -- Defined in ‘GHC.Internal.Generics’
instance forall k (p :: k). GHC.Classes.Ord (GHC.Internal.Generics.U1 p) -- Defined in ‘GHC.Internal.Generics’
instance forall k (p :: k). GHC.Classes.Ord (GHC.Internal.Generics.URec (GHC.Internal.Ptr.Ptr ()) p) -- Defined in ‘GHC.Internal.Generics’
instance forall k (p :: k). GHC.Classes.Ord (GHC.Internal.Generics.URec GHC.Types.Char p) -- Defined in ‘GHC.Internal.Generics’
instance forall k (p :: k). GHC.Classes.Ord (GHC.Internal.Generics.URec GHC.Types.Double p) -- Defined in ‘GHC.Internal.Generics’
instance forall k (p :: k). GHC.Classes.Ord (GHC.Internal.Generics.URec GHC.Types.Float p) -- Defined in ‘GHC.Internal.Generics’
instance forall k (p :: k). GHC.Classes.Ord (GHC.Internal.Generics.URec GHC.Types.Int p) -- Defined in ‘GHC.Internal.Generics’
instance forall k (p :: k). GHC.Classes.Ord (GHC.Internal.Generics.URec GHC.Types.Word p) -- Defined in ‘GHC.Internal.Generics’
instance forall k (p :: k). GHC.Classes.Ord (GHC.Internal.Generics.V1 p) -- Defined in ‘GHC.Internal.Generics’
instance GHC.Classes.Ord GHC.Internal.IO.Device.SeekMode -- Defined in ‘GHC.Internal.IO.Device’
instance GHC.Classes.Ord GHC.Internal.IO.Handle.Types.BufferMode -- Defined in ‘GHC.Internal.IO.Handle.Types’
instance GHC.Classes.Ord GHC.Internal.IO.Handle.Types.Newline -- Defined in ‘GHC.Internal.IO.Handle.Types’
instance GHC.Classes.Ord GHC.Internal.IO.Handle.Types.NewlineMode -- Defined in ‘GHC.Internal.IO.Handle.Types’
instance GHC.Classes.Ord GHC.Internal.IO.IOMode.IOMode -- Defined in ‘GHC.Internal.IO.IOMode’
instance GHC.Classes.Ord GHC.Num.Integer.Integer -- Defined in ‘GHC.Num.Integer’
instance GHC.Classes.Ord GHC.Num.BigNat.BigNat -- Defined in ‘GHC.Num.BigNat’
instance GHC.Classes.Ord GHC.Num.Natural.Natural -- Defined in ‘GHC.Num.Natural’
instance forall (n :: GHC.Internal.TypeNats.Nat). GHC.Classes.Ord (GHC.Internal.TypeNats.SNat n) -- Defined in ‘GHC.Internal.TypeNats’
instance GHC.Classes.Ord GHC.Internal.TypeNats.SomeNat -- Defined in ‘GHC.Internal.TypeNats’
instance forall (c :: GHC.Types.Char). GHC.Classes.Ord (GHC.Internal.TypeLits.SChar c) -- Defined in ‘GHC.Internal.TypeLits’
instance forall (s :: GHC.Types.Symbol). GHC.Classes.Ord (GHC.Internal.TypeLits.SSymbol s) -- Defined in ‘GHC.Internal.TypeLits’
instance GHC.Classes.Ord GHC.Internal.TypeLits.SomeChar -- Defined in ‘GHC.Internal.TypeLits’
instance GHC.Classes.Ord GHC.Internal.TypeLits.SomeSymbol -- Defined in ‘GHC.Internal.TypeLits’