base-exports.stdout-mingw32

  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
  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
  type CodePage :: *
  type CodePage = GHC.Internal.Windows.DWORD
  codePageEncoding :: GHC.Internal.Word.Word32 -> GHC.Internal.IO.Encoding.Types.TextEncoding
  getCurrentCodePage :: GHC.Types.IO CodePage
  localeEncoding :: GHC.Internal.IO.Encoding.Types.TextEncoding
  mkCodePageEncoding :: GHC.Internal.IO.Encoding.Failure.CodingFailureMode -> GHC.Internal.Word.Word32 -> GHC.Internal.IO.Encoding.Types.TextEncoding
  mkLocaleEncoding :: GHC.Internal.IO.Encoding.Failure.CodingFailureMode -> GHC.Internal.IO.Encoding.Types.TextEncoding

module GHC.IO.Encoding.CodePage.API where
  -- Safety: Safe
  mkCodePageEncoding :: GHC.Internal.IO.Encoding.Failure.CodingFailureMode -> GHC.Internal.Word.Word32 -> GHC.Internal.IO.Encoding.Types.TextEncoding

module GHC.IO.Encoding.CodePage.Table where
  -- Safety: Trustworthy
  type CodePageArrays :: *
  data CodePageArrays = SingleByteCP {decoderArray :: {-# UNPACK #-}(ConvArray GHC.Types.Char), encoderArray :: !(CompactArray GHC.Types.Char GHC.Internal.Word.Word8)}
  type role CompactArray representational phantom
  type CompactArray :: * -> * -> *
  data CompactArray a b = CompactArray {encoderMax :: !a, encoderIndices :: {-# UNPACK #-}(ConvArray GHC.Types.Int), encoderValues :: {-# UNPACK #-}(ConvArray b)}
  type role ConvArray phantom
  type ConvArray :: * -> *
  data ConvArray a = ConvArray GHC.Prim.Addr#
  blockBitSize :: GHC.Types.Int
  codePageMap :: [(GHC.Internal.Word.Word32, CodePageArrays)]

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

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, fdIsSocket_ :: {-# 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.Internal.Foreign.C.Types.CInt
  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.Internal.Foreign.C.Types.CInt
  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 :: *