base-exports.stdout-mingw32

    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 ConsoleEvent :: *
  data ConsoleEvent = ControlC | Break | Close | Logoff | Shutdown
  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
  asyncDoProc :: forall a. GHC.Internal.Ptr.FunPtr (GHC.Internal.Ptr.Ptr a -> GHC.Types.IO GHC.Types.Int) -> GHC.Internal.Ptr.Ptr a -> GHC.Types.IO GHC.Types.Int
  asyncRead :: forall a. GHC.Types.Int -> GHC.Types.Int -> GHC.Types.Int -> GHC.Internal.Ptr.Ptr a -> GHC.Types.IO (GHC.Types.Int, GHC.Types.Int)
  asyncReadBA :: GHC.Types.Int -> GHC.Types.Int -> GHC.Types.Int -> GHC.Types.Int -> GHC.Prim.MutableByteArray# GHC.Prim.RealWorld -> GHC.Types.IO (GHC.Types.Int, GHC.Types.Int)
  asyncWrite :: forall a. GHC.Types.Int -> GHC.Types.Int -> GHC.Types.Int -> GHC.Internal.Ptr.Ptr a -> GHC.Types.IO (GHC.Types.Int, GHC.Types.Int)
  asyncWriteBA :: GHC.Types.Int -> GHC.Types.Int -> GHC.Types.Int -> GHC.Types.Int -> GHC.Prim.MutableByteArray# GHC.Prim.RealWorld -> GHC.Types.IO (GHC.Types.Int, GHC.Types.Int)
  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
  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 ()
  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 ()
  toWin32ConsoleEvent :: forall a. (GHC.Classes.Eq a, GHC.Internal.Num.Num a) => a -> GHC.Internal.Maybe.Maybe ConsoleEvent
  unsafeIOToSTM :: forall a. GHC.Types.IO a -> STM a
  win32ConsoleHandler :: GHC.Internal.MVar.MVar (ConsoleEvent -> GHC.Types.IO ())
  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.POSIX where

-- ignored


module GHC.Conc.POSIX.Const where
  -- Safety: Safe-Inferred
  io_MANAGER_DIE :: GHC.Internal.Word.Word32
  io_MANAGER_WAKEUP :: GHC.Internal.Word.Word32

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.Conc.WinIO where
  -- Safety: None
  ensureIOManagerIsRunning :: GHC.Types.IO ()
  interruptIOManager :: GHC.Types.IO ()
  registerDelay :: GHC.Types.Int -> GHC.Types.IO (GHC.Internal.Conc.Sync.TVar GHC.Types.Bool)
  threadDelay :: GHC.Types.Int -> GHC.Types.IO ()

module GHC.Conc.Windows where
  -- Safety: Safe
  type ConsoleEvent :: *
  data ConsoleEvent = ControlC | Break | Close | Logoff | Shutdown
  asyncDoProc :: forall a. GHC.Internal.Ptr.FunPtr (GHC.Internal.Ptr.Ptr a -> GHC.Types.IO GHC.Types.Int) -> GHC.Internal.Ptr.Ptr a -> GHC.Types.IO GHC.Types.Int
  asyncRead :: forall a. GHC.Types.Int -> GHC.Types.Int -> GHC.Types.Int -> GHC.Internal.Ptr.Ptr a -> GHC.Types.IO (GHC.Types.Int, GHC.Types.Int)
  asyncReadBA :: GHC.Types.Int -> GHC.Types.Int -> GHC.Types.Int -> GHC.Types.Int -> GHC.Prim.MutableByteArray# GHC.Prim.RealWorld -> GHC.Types.IO (GHC.Types.Int, GHC.Types.Int)
  asyncWrite :: forall a. GHC.Types.Int -> GHC.Types.Int -> GHC.Types.Int -> GHC.Internal.Ptr.Ptr a -> GHC.Types.IO (GHC.Types.Int, GHC.Types.Int)
  asyncWriteBA :: GHC.Types.Int -> GHC.Types.Int -> GHC.Types.Int -> GHC.Types.Int -> GHC.Prim.MutableByteArray# GHC.Prim.RealWorld -> GHC.Types.IO (GHC.Types.Int, GHC.Types.Int)
  ensureIOManagerIsRunning :: GHC.Types.IO ()
  interruptIOManager :: GHC.Types.IO ()
  registerDelay :: GHC.Types.Int -> GHC.Types.IO (GHC.Internal.Conc.Sync.TVar GHC.Types.Bool)
  start_console_handler :: GHC.Internal.Word.Word32 -> GHC.Types.IO ()
  threadDelay :: GHC.Types.Int -> GHC.Types.IO ()
  toWin32ConsoleEvent :: forall a. (GHC.Classes.Eq a, GHC.Internal.Num.Num a) => a -> GHC.Internal.Maybe.Maybe ConsoleEvent
  win32ConsoleHandler :: GHC.Internal.MVar.MVar (ConsoleEvent -> GHC.Types.IO ())

module GHC.ConsoleHandler where
  -- Safety: Safe
  type ConsoleEvent :: *
  data ConsoleEvent = ControlC | Break | Close | Logoff | Shutdown
  type Handler :: *
  data Handler = Default | Ignore | Catch (ConsoleEvent -> GHC.Types.IO ())
  installHandler :: Handler -> GHC.Types.IO Handler

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.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.Event.Windows where
  -- Safety: None
  type CbResult :: * -> *
  data CbResult a = CbDone (GHC.Internal.Maybe.Maybe GHC.Internal.Windows.DWORD) | CbPending | CbIncomplete | CbError a | CbNone GHC.Types.Bool
  type CompletionCallback :: * -> *
  type CompletionCallback a = GHC.Internal.Windows.ErrCode -> GHC.Internal.Windows.DWORD -> GHC.Types.IO a
  type ConsoleEvent :: *
  data ConsoleEvent = ControlC | Break | Close | Logoff | Shutdown
  type HandleData :: *
  data HandleData = HandleData {tokenKey :: {-# UNPACK #-}HandleKey, tokenEvents :: ! {-# UNPACK #-}(ghc-internal-0.1.0.0:GHC.Internal.Event.Internal.Types.N:EventLifetime[0])ghc-internal-0.1.0.0:GHC.Internal.Event.Internal.Types.EventLifetime, _handleCallback :: !GHC.Internal.Event.Windows.EventCallback}
  type HandleKey :: *
  data HandleKey = GHC.Internal.Event.Windows.HandleKey {handleValue :: {-# UNPACK #-}GHC.Internal.Windows.HANDLE, ...}
  type IOResult :: * -> *
  data IOResult a = IOSuccess {ioValue :: a} | IOFailed {ioErrCode :: GHC.Internal.Maybe.Maybe GHC.Types.Int}
  type LPOVERLAPPED :: *
  type LPOVERLAPPED = GHC.Internal.Ptr.Ptr GHC.Internal.Event.Windows.FFI.OVERLAPPED
  type Manager :: *
  data Manager = ...
  type Seconds :: *
  type Seconds = GHC.Types.Double
  type StartCallback :: * -> *
  type StartCallback a = LPOVERLAPPED -> GHC.Types.IO a
  type StartIOCallback :: * -> *
  type StartIOCallback a = StartCallback (CbResult a)
  type TimeoutCallback :: *
  type TimeoutCallback = GHC.Types.IO ()
  type TimeoutKey :: *
  newtype TimeoutKey = ...
  associateHandle :: Manager -> GHC.Internal.Windows.HANDLE -> GHC.Types.IO ()
  associateHandle' :: GHC.Internal.Windows.HANDLE -> GHC.Types.IO ()
  getLastError :: GHC.Types.IO GHC.Internal.Windows.ErrCode
  getSystemManager :: GHC.Types.IO Manager
  interruptSystemManager :: GHC.Types.IO ()
  ioFailed :: forall a. GHC.Internal.Real.Integral a => a -> GHC.Types.IO (IOResult a)
  ioFailedAny :: forall a b. GHC.Internal.Real.Integral a => a -> GHC.Types.IO (IOResult b)
  ioSuccess :: forall a. a -> GHC.Types.IO (IOResult a)
  processRemoteCompletion :: GHC.Types.IO ()
  registerHandle :: Manager -> GHC.Internal.Event.Windows.EventCallback -> GHC.Internal.Windows.HANDLE -> ghc-internal-0.1.0.0:GHC.Internal.Event.Internal.Types.Event -> ghc-internal-0.1.0.0:GHC.Internal.Event.Internal.Types.Lifetime -> GHC.Types.IO HandleKey
  registerTimeout :: Manager -> GHC.Types.Int -> TimeoutCallback -> GHC.Types.IO TimeoutKey
  start_console_handler :: GHC.Internal.Word.Word32 -> GHC.Types.IO ()
  toWin32ConsoleEvent :: forall a. (GHC.Classes.Eq a, GHC.Internal.Num.Num a) => a -> GHC.Internal.Maybe.Maybe ConsoleEvent
  unregisterHandle :: Manager -> HandleKey -> GHC.Types.IO ()
  unregisterTimeout :: Manager -> TimeoutKey -> GHC.Types.IO ()
  updateTimeout :: Manager -> TimeoutKey -> Seconds -> GHC.Types.IO ()
  wakeupIOManager :: GHC.Types.IO ()
  win32ConsoleHandler :: GHC.Internal.MVar.MVar (ConsoleEvent -> GHC.Types.IO ())
  withException :: forall a. GHC.Internal.Base.String -> GHC.Types.IO (IOResult a) -> GHC.Types.IO a
  withOverlapped :: forall a. GHC.Internal.Base.String -> GHC.Internal.Windows.HANDLE -> GHC.Internal.Word.Word64 -> StartIOCallback GHC.Types.Int -> CompletionCallback (IOResult a) -> GHC.Types.IO (IOResult a)
  withOverlappedEx :: forall a. Manager -> GHC.Internal.Base.String -> GHC.Internal.Windows.HANDLE -> GHC.Types.Bool -> GHC.Internal.Word.Word64 -> StartIOCallback GHC.Types.Int -> CompletionCallback (IOResult a) -> GHC.Types.IO (IOResult a)

module GHC.Event.Windows.Clock where
  -- Safety: None
  type Clock :: *
  newtype Clock = ...
  type Seconds :: *
  type Seconds = GHC.Types.Double
  getClock :: GHC.Types.IO Clock
  getTickCount64 :: GHC.Types.IO Clock
  getTime :: Clock -> GHC.Types.IO Seconds
  queryPerformanceCounter :: GHC.Types.IO (GHC.Internal.Maybe.Maybe Clock)

module GHC.Event.Windows.ConsoleEvent where
  -- Safety: Safe-Inferred
  type ConsoleEvent :: *
  data ConsoleEvent = ControlC | Break | Close | Logoff | Shutdown
  start_console_handler :: GHC.Internal.Word.Word32 -> GHC.Types.IO ()
  toWin32ConsoleEvent :: forall a. (GHC.Classes.Eq a, GHC.Internal.Num.Num a) => a -> GHC.Internal.Maybe.Maybe ConsoleEvent
  win32ConsoleHandler :: GHC.Internal.MVar.MVar (ConsoleEvent -> GHC.Types.IO ())

module GHC.Event.Windows.FFI where
  -- Safety: None
  type CompletionCallback :: * -> *
  type CompletionCallback a = GHC.Internal.Windows.ErrCode -> GHC.Internal.Windows.DWORD -> GHC.Types.IO a
  type CompletionData :: *
  data CompletionData = CompletionData {cdHandle :: {-# UNPACK #-}GHC.Internal.Windows.HANDLE, cdCallback :: {-# UNPACK #-}(GHC.Internal.Stable.StablePtr GHC.Internal.Event.Windows.FFI.IOCallback)}
  type CompletionKey :: *
  type CompletionKey = GHC.Internal.Event.Windows.FFI.ULONG_PTR
  type HASKELL_OVERLAPPED :: *
  data HASKELL_OVERLAPPED
  type IOCP :: *
  newtype IOCP = IOCP GHC.Internal.Windows.HANDLE
  type LPHASKELL_OVERLAPPED :: *
  type LPHASKELL_OVERLAPPED = GHC.Internal.Ptr.Ptr HASKELL_OVERLAPPED
  type LPOVERLAPPED :: *
  type LPOVERLAPPED = GHC.Internal.Ptr.Ptr OVERLAPPED
  type LPOVERLAPPED_ENTRY :: *
  type LPOVERLAPPED_ENTRY = GHC.Internal.Ptr.Ptr OVERLAPPED_ENTRY
  type OVERLAPPED :: *
  data OVERLAPPED
  type OVERLAPPED_ENTRY :: *
  data OVERLAPPED_ENTRY = OVERLAPPED_ENTRY {lpCompletionKey :: GHC.Internal.Event.Windows.FFI.ULONG_PTR, lpOverlapped :: LPOVERLAPPED, dwNumberOfBytesTransferred :: GHC.Internal.Windows.DWORD}
  allocOverlapped :: GHC.Internal.Word.Word64 -> GHC.Types.IO (GHC.Internal.Ptr.Ptr HASKELL_OVERLAPPED)
  associateHandleWithIOCP :: IOCP -> GHC.Internal.Windows.HANDLE -> CompletionKey -> GHC.Types.IO ()
  cancelIoEx :: GHC.Internal.Windows.HANDLE -> LPOVERLAPPED -> GHC.Types.IO ()
  cancelIoEx' :: GHC.Internal.Windows.HANDLE -> LPOVERLAPPED -> GHC.Types.IO GHC.Types.Bool
  getOverlappedResult :: GHC.Internal.Windows.HANDLE -> GHC.Internal.Ptr.Ptr OVERLAPPED -> GHC.Internal.Windows.BOOL -> GHC.Types.IO (GHC.Internal.Maybe.Maybe GHC.Internal.Windows.DWORD)
  getQueuedCompletionStatusEx :: IOCP -> ghc-internal-0.1.0.0:GHC.Internal.Event.Array.Array OVERLAPPED_ENTRY -> GHC.Internal.Windows.DWORD -> GHC.Types.IO GHC.Types.Int
  getTickCount64 :: GHC.Types.IO GHC.Internal.Word.Word64
  newIOCP :: GHC.Types.IO IOCP
  overlappedIONumBytes :: LPOVERLAPPED -> GHC.Types.IO GHC.Internal.Event.Windows.FFI.ULONG_PTR
  overlappedIOStatus :: LPOVERLAPPED -> GHC.Types.IO GHC.Internal.Windows.NTSTATUS
  pokeOffsetOverlapped :: LPOVERLAPPED -> GHC.Internal.Word.Word64 -> GHC.Types.IO ()
  postQueuedCompletionStatus :: IOCP -> GHC.Internal.Windows.DWORD -> CompletionKey -> LPOVERLAPPED -> GHC.Types.IO ()
  queryPerformanceCounter :: GHC.Types.IO GHC.Internal.Int.Int64
  queryPerformanceFrequency :: GHC.Types.IO (GHC.Internal.Maybe.Maybe GHC.Internal.Int.Int64)
  setLastError :: GHC.Internal.Windows.ErrCode -> GHC.Types.IO ()
  throwWinErr :: forall a. GHC.Internal.Base.String -> GHC.Internal.Windows.ErrCode -> GHC.Types.IO a
  withRequest :: forall a. GHC.Types.Bool -> GHC.Internal.Word.Word64 -> GHC.Internal.Windows.HANDLE -> GHC.Internal.Event.Windows.FFI.IOCallback -> (GHC.Internal.Ptr.Ptr HASKELL_OVERLAPPED -> GHC.Internal.Ptr.Ptr CompletionData -> GHC.Types.IO a) -> GHC.Types.IO a
  zeroOverlapped :: LPHASKELL_OVERLAPPED -> GHC.Types.IO ()

module GHC.Event.Windows.ManagedThreadPool where
  -- Safety: None
  type ThreadPool :: *
  data ThreadPool
    = ThreadPool {thrMainThread :: GHC.Internal.Maybe.Maybe GHC.Internal.Conc.Sync.ThreadId,
                  thrMaxThreads :: {-# UNPACK #-}GHC.Types.Int,
                  thrMinThreads :: {-# UNPACK #-}GHC.Types.Int,
                  thrCurThreads :: {-# UNPACK #-}GHC.Types.Int,
                  thrCallBack :: GHC.Internal.Event.Windows.ManagedThreadPool.WorkerJob,
                  thrActiveThreads :: GHC.Internal.MVar.MVar GHC.Types.Int,
                  thrMonitor :: GHC.Internal.MVar.MVar (),
                  thrThreadIds :: ! {-# UNPACK #-}(ghc-internal-0.1.0.0:GHC.Internal.Event.Array.N:Array[0] <GHC.Internal.Conc.Sync.ThreadId>_P
                                                   ; GHC.Internal.IORef.N:IORef[0] <ghc-internal-0.1.0.0:GHC.Internal.Event.Array.AC GHC.Internal.Conc.Sync.ThreadId>_N)(ghc-internal-0.1.0.0:GHC.Internal.Event.Array.Array GHC.Internal.Conc.Sync.ThreadId)}
  monitorThreadPool :: GHC.Internal.MVar.MVar () -> GHC.Types.IO ()
  notifyRunning :: GHC.Internal.Maybe.Maybe ThreadPool -> GHC.Types.IO ()
  notifyWaiting :: GHC.Internal.Maybe.Maybe ThreadPool -> GHC.Types.IO ()
  startThreadPool :: GHC.Internal.Event.Windows.ManagedThreadPool.WorkerJob -> GHC.Types.IO ThreadPool

module GHC.Event.Windows.Thread where
  -- Safety: None
  ensureIOManagerIsRunning :: GHC.Types.IO ()
  interruptIOManager :: GHC.Types.IO ()
  registerDelay :: GHC.Types.Int -> GHC.Types.IO (GHC.Internal.Conc.Sync.TVar GHC.Types.Bool)
  threadDelay :: GHC.Types.Int -> GHC.Types.IO ()

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. (GHC.Internal.Stack.Types.HasCallStack, 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#
  asyncDoProc# :: Addr# -> Addr# -> State# RealWorld -> (# State# RealWorld, Int#, Int# #)
  asyncRead# :: Int# -> Int# -> Int# -> Addr# -> State# RealWorld -> (# State# RealWorld, Int#, Int# #)
  asyncWrite# :: Int# -> Int# -> Int# -> Addr# -> State# RealWorld -> (# State# RealWorld, Int#, Int# #)
  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#