[Git][ghc/ghc][master] ghc-experimental: Expose primops and ghc extensions via GHC.PrimOps

[Marge Bot (@marge-bot)]

Marge Bot pushed to branch master at Glasgow Haskell Compiler / GHC


Commits:
39497eed by Andreas Klebinger at 2024-10-02T22:19:24-04:00
ghc-experimental: Expose primops and ghc extensions via GHC.PrimOps

This will be the new place for functions that would have gone into
GHC.Exts in the past but are not stable enough to do so now.

Addresses #25242

- - - - -


6 changed files:

- libraries/base/src/GHC/Exts.hs
- libraries/ghc-experimental/ghc-experimental.cabal.in
- + libraries/ghc-experimental/src/GHC/PrimOps.hs
- libraries/ghc-internal/src/GHC/Internal/Exts.hs
- testsuite/tests/interface-stability/ghc-experimental-exports.stdout
- + testsuite/tests/interface-stability/ghc-experimental-exports.stdout-mingw32


Changes:

=====================================
libraries/base/src/GHC/Exts.hs
=====================================
@@ -14,6 +14,9 @@
 --
 -- Note: no other @base@ module should import this module.
 
+-- See Note [Where do we export PrimOps] for details about how to expose primops
+-- to users.
+
 module GHC.Exts
     (-- **  Pointer types
      Ptr(..),


=====================================
libraries/ghc-experimental/ghc-experimental.cabal.in
=====================================
@@ -29,6 +29,7 @@ library
     exposed-modules:
       Data.Sum.Experimental
       Data.Tuple.Experimental
+      GHC.PrimOps
       GHC.Profiling.Eras
       GHC.TypeLits.Experimental
       GHC.TypeNats.Experimental


=====================================
libraries/ghc-experimental/src/GHC/PrimOps.hs
=====================================
@@ -0,0 +1,33 @@
+{-# LANGUAGE FlexibleInstances #-}
+{-# LANGUAGE MagicHash #-}
+{-# LANGUAGE MultiParamTypeClasses #-}
+{-# LANGUAGE NoImplicitPrelude #-}
+{-# LANGUAGE TypeFamilies #-}
+{-# LANGUAGE UnboxedTuples #-}
+{-# LANGUAGE Unsafe #-}
+{-# LANGUAGE DeriveDataTypeable #-}
+{-# OPTIONS_HADDOCK print-explicit-runtime-reps #-}
+
+-----------------------------------------------------------------------------
+-- |
+-- Module      :  GHC.PrimOps
+-- Copyright   :  Andreas Klebinger 2024
+-- License     :  see libraries/ghc-experimental/LICENSE
+--
+-- Maintainer  :  ghc-devs at haskell.org
+-- Stability   :  internal
+-- Portability :  non-portable (GHC Extensions)
+--
+-- GHC Extensions: This is the Approved Way to get at GHC-specific extensions
+-- without relying on the ghc-internal package.
+-----------------------------------------------------------------------------
+
+-- See Note [Where do we export PrimOps] for the purpose of this module.
+
+module GHC.PrimOps
+       (
+        module GHC.Internal.Exts,
+       ) where
+
+import GHC.Internal.Exts
+


=====================================
libraries/ghc-internal/src/GHC/Internal/Exts.hs
=====================================
@@ -18,11 +18,43 @@
 -- Stability   :  internal
 -- Portability :  non-portable (GHC Extensions)
 --
--- GHC Extensions: this is the Approved Way to get at GHC-specific extensions.
+-- GHC Extensions: This is a unstable way to get at GHC-specific extensions.
+--                 If possible prefer using GHC.PrimOps from ghc-experimental
+--                 or GHC.Exts from base.
 --
--- Note: no other base module should import this module.
+-- Note: no other ghc-internal module should import this module.
 -----------------------------------------------------------------------------
 
+{- Note [Where do we export PrimOps]
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+Built in primops are automatically exported via the magical module
+GHC.Prim (See Note [GHC.Prim]).
+However we don't want users to use GHC.Prim directly. Among other reasons that
+would prevent us from giving those primops a regular haskell or cmm
+implementation in the future.
+
+So instead we provide a hirarchy of Modules through which we expose PrimOps.
+* ghc-internal:GHC.Exts.Internal re-exports GHC.Prim along with some other
+  builtin functionality. It gives zero stability guarantee and is mostly inteded
+  for ghc internal use.
+* ghc-experimental:GHC.PrimOps contains a more stable subset of GHC.Exts.Internal.
+  This module does not offer any more stability *guarantees* than ghc-internal,
+  but we try to keep things slightly more stable there and be backwards compatible
+  if it's easy to do. For example an export from ghc-experimental is likely to get
+  deprecated before being removed. While exports from ghc-internal could be removed
+  without advanced notice between ghc versions!
+* base:GHC.Exts: Contains all kinds of re-exports from ghc-internal:GHC.Exts.Internal
+  which have been grandfathered into this module from pre ghc-9.10.
+  Starting with 9.10.1 only definitions with a fairly high level of expected
+  stability should be exposed through GHC.Exts and changing the API provided by
+  this module now follows the CLC process.
+
+If there is a desire to create a module for a specific group of primitives they
+should still be exported by the catch-all modules GHC.Exts.Internal and GHC.PrimOps,
+with their specific module being placed under ghc-experimental:GHC.PrimOps
+in the module structure.
+-}
+
 module GHC.Internal.Exts
        (
         -- ** Pointer types


=====================================
testsuite/tests/interface-stability/ghc-experimental-exports.stdout
=====================================
@@ -4316,6 +4316,1839 @@ module Data.Tuple.Experimental where
   data Unit# = ...
   getSolo :: forall a. Solo a -> a
 
+module GHC.PrimOps where
+  -- Safety: Unsafe
+  (*#) :: Int# -> Int# -> Int#
+  (*##) :: Double# -> Double# -> Double#
+  (**##) :: Double# -> Double# -> Double#
+  (+#) :: Int# -> Int# -> Int#
+  (+##) :: Double# -> Double# -> Double#
+  (-#) :: Int# -> Int# -> Int#
+  (-##) :: Double# -> Double# -> Double#
+  (/##) :: Double# -> Double# -> Double#
+  (/=#) :: Int# -> Int# -> Int#
+  (/=##) :: Double# -> Double# -> Int#
+  (<#) :: Int# -> Int# -> Int#
+  (<##) :: Double# -> Double# -> Int#
+  (<=#) :: Int# -> Int# -> Int#
+  (<=##) :: Double# -> Double# -> Int#
+  (==#) :: Int# -> Int# -> Int#
+  (==##) :: Double# -> Double# -> Int#
+  (>#) :: Int# -> Int# -> Int#
+  (>##) :: Double# -> Double# -> Int#
+  (>=#) :: Int# -> Int# -> Int#
+  (>=##) :: Double# -> Double# -> Int#
+  type Addr# :: TYPE AddrRep
+  data Addr#
+  type Any :: forall k. k
+  type family Any where
+  type Array# :: forall {l :: Levity}. TYPE (BoxedRep l) -> UnliftedType
+  data Array# a
+  type ArrayArray# :: UnliftedType
+  newtype ArrayArray# = ArrayArray# (Array# ByteArray#)
+  type BCO :: *
+  data BCO
+  type Bool :: *
+  data Bool = False | True
+  type ByteArray# :: UnliftedType
+  data ByteArray#
+  type role CONSTRAINT nominal
+  type CONSTRAINT :: RuntimeRep -> *
+  data CONSTRAINT a
+  type Char :: *
+  data Char = C# Char#
+  type Char# :: TYPE WordRep
+  data Char#
+  type role Coercible representational representational
+  type Coercible :: forall k. k -> k -> Constraint
+  class Coercible a b => Coercible a b
+    {-# MINIMAL #-}
+  type Compact# :: UnliftedType
+  data Compact#
+  type Constraint :: *
+  type Constraint = CONSTRAINT LiftedRep
+  type DataToTag :: forall {lev :: Levity}. TYPE (BoxedRep lev) -> Constraint
+  class DataToTag a where
+    dataToTag# :: a -> Int#
+    {-# MINIMAL dataToTag# #-}
+  type DictBox :: Constraint -> *
+  data DictBox a = a => MkDictBox
+  type Double :: *
+  data Double = D# Double#
+  type Double# :: TYPE DoubleRep
+  data Double#
+  type DoubleBox :: TYPE DoubleRep -> *
+  data DoubleBox a = MkDoubleBox a
+  type DoubleX2# :: TYPE (VecRep Vec2 DoubleElemRep)
+  data DoubleX2#
+  type DoubleX4# :: TYPE (VecRep Vec4 DoubleElemRep)
+  data DoubleX4#
+  type DoubleX8# :: TYPE (VecRep Vec8 DoubleElemRep)
+  data DoubleX8#
+  type Down :: * -> *
+  newtype Down a = Down {getDown :: a}
+  type role FUN nominal representational representational
+  type FUN :: forall (n :: Multiplicity) -> forall {q :: RuntimeRep} {r :: RuntimeRep}. TYPE q -> TYPE r -> *
+  data FUN n a b
+  type Float :: *
+  data Float = F# Float#
+  type Float# :: TYPE FloatRep
+  data Float#
+  type FloatBox :: TYPE FloatRep -> *
+  data FloatBox a = MkFloatBox a
+  type FloatX16# :: TYPE (VecRep Vec16 FloatElemRep)
+  data FloatX16#
+  type FloatX4# :: TYPE (VecRep Vec4 FloatElemRep)
+  data FloatX4#
+  type FloatX8# :: TYPE (VecRep Vec8 FloatElemRep)
+  data FloatX8#
+  type role FunPtr phantom
+  type FunPtr :: * -> *
+  data FunPtr a = FunPtr Addr#
+  type role IOPort# nominal representational
+  type IOPort# :: forall {l :: Levity}. * -> TYPE (BoxedRep l) -> UnliftedType
+  data IOPort# a b
+  type Int :: *
+  data Int = I# Int#
+  type Int# :: TYPE IntRep
+  data Int#
+  type Int16# :: TYPE Int16Rep
+  data Int16#
+  type Int16X16# :: TYPE (VecRep Vec16 Int16ElemRep)
+  data Int16X16#
+  type Int16X32# :: TYPE (VecRep Vec32 Int16ElemRep)
+  data Int16X32#
+  type Int16X8# :: TYPE (VecRep Vec8 Int16ElemRep)
+  data Int16X8#
+  type Int32# :: TYPE Int32Rep
+  data Int32#
+  type Int32X16# :: TYPE (VecRep Vec16 Int32ElemRep)
+  data Int32X16#
+  type Int32X4# :: TYPE (VecRep Vec4 Int32ElemRep)
+  data Int32X4#
+  type Int32X8# :: TYPE (VecRep Vec8 Int32ElemRep)
+  data Int32X8#
+  type Int64# :: TYPE Int64Rep
+  data Int64#
+  type Int64X2# :: TYPE (VecRep Vec2 Int64ElemRep)
+  data Int64X2#
+  type Int64X4# :: TYPE (VecRep Vec4 Int64ElemRep)
+  data Int64X4#
+  type Int64X8# :: TYPE (VecRep Vec8 Int64ElemRep)
+  data Int64X8#
+  type Int8# :: TYPE Int8Rep
+  data Int8#
+  type Int8X16# :: TYPE (VecRep Vec16 Int8ElemRep)
+  data Int8X16#
+  type Int8X32# :: TYPE (VecRep Vec32 Int8ElemRep)
+  data Int8X32#
+  type Int8X64# :: TYPE (VecRep Vec64 Int8ElemRep)
+  data Int8X64#
+  type IntBox :: TYPE IntRep -> *
+  data IntBox a = MkIntBox a
+  type IsList :: * -> Constraint
+  class IsList l where
+    type Item :: * -> *
+    type family Item l
+    fromList :: [Item l] -> l
+    fromListN :: Int -> [Item l] -> l
+    toList :: l -> [Item l]
+    {-# MINIMAL fromList, toList #-}
+  type IsString :: * -> Constraint
+  class IsString a where
+    fromString :: GHC.Internal.Base.String -> a
+    {-# MINIMAL fromString #-}
+  KindRepApp :: GHC.Types.KindRep -> GHC.Types.KindRep -> GHC.Types.KindRep
+  KindRepFun :: GHC.Types.KindRep -> GHC.Types.KindRep -> GHC.Types.KindRep
+  KindRepTYPE :: RuntimeRep -> GHC.Types.KindRep
+  KindRepTyConApp :: GHC.Types.TyCon -> [GHC.Types.KindRep] -> GHC.Types.KindRep
+  KindRepTypeLitD :: GHC.Types.TypeLitSort -> [Char] -> GHC.Types.KindRep
+  KindRepTypeLitS :: GHC.Types.TypeLitSort -> Addr# -> GHC.Types.KindRep
+  KindRepVar :: GHC.Types.KindBndr -> GHC.Types.KindRep
+  type Levity :: *
+  data Levity = Lifted | Unlifted
+  type LiftedRep :: RuntimeRep
+  type LiftedRep = BoxedRep Lifted :: RuntimeRep
+  type List :: * -> *
+  data List a = ...
+  type role MVar# nominal representational
+  type MVar# :: forall {l :: Levity}. * -> TYPE (BoxedRep l) -> UnliftedType
+  data MVar# a b
+  type MultMul :: Multiplicity -> Multiplicity -> Multiplicity
+  type family MultMul a b where
+    forall (x :: Multiplicity). MultMul One x = x
+    forall (x :: Multiplicity). MultMul x One = x
+    forall (x :: Multiplicity). MultMul Many x = Many
+    forall (x :: Multiplicity). MultMul x Many = Many
+  type Multiplicity :: *
+  data Multiplicity = One | Many
+  type role MutVar# nominal representational
+  type MutVar# :: forall {l :: Levity}. * -> TYPE (BoxedRep l) -> UnliftedType
+  data MutVar# a b
+  type role MutableArray# nominal representational
+  type MutableArray# :: forall {l :: Levity}. * -> TYPE (BoxedRep l) -> UnliftedType
+  data MutableArray# a b
+  type role MutableArrayArray# nominal
+  type MutableArrayArray# :: * -> UnliftedType
+  newtype MutableArrayArray# s = MutableArrayArray# (MutableArray# s ByteArray#)
+  type role MutableByteArray# nominal
+  type MutableByteArray# :: * -> UnliftedType
+  data MutableByteArray# a
+  type Ordering :: *
+  data Ordering = LT | EQ | GT
+  type PromptTag# :: * -> UnliftedType
+  data PromptTag# a
+  type role Proxy# phantom
+  type Proxy# :: forall k. k -> ZeroBitType
+  data Proxy# a
+  type role Ptr phantom
+  type Ptr :: * -> *
+  data Ptr a = Ptr Addr#
+  type RealWorld :: *
+  data RealWorld
+  type RuntimeRep :: *
+  data RuntimeRep = VecRep VecCount VecElem | TupleRep [RuntimeRep] | SumRep [RuntimeRep] | BoxedRep Levity | IntRep | Int8Rep | Int16Rep | Int32Rep | Int64Rep | WordRep | Word8Rep | Word16Rep | Word32Rep | Word64Rep | AddrRep | FloatRep | DoubleRep
+  type SPEC :: *
+  data SPEC = SPEC | SPEC2
+  type SmallArray# :: forall {l :: Levity}. TYPE (BoxedRep l) -> UnliftedType
+  data SmallArray# a
+  type role SmallMutableArray# nominal representational
+  type SmallMutableArray# :: forall {l :: Levity}. * -> TYPE (BoxedRep l) -> UnliftedType
+  data SmallMutableArray# a b
+  type SpecConstrAnnotation :: *
+  data SpecConstrAnnotation = NoSpecConstr | ForceSpecConstr
+  type role StableName# phantom
+  type StableName# :: forall {l :: Levity}. TYPE (BoxedRep l) -> UnliftedType
+  data StableName# a
+  type StablePtr# :: forall {l :: Levity}. TYPE (BoxedRep l) -> TYPE AddrRep
+  data StablePtr# a
+  type StackSnapshot# :: UnliftedType
+  data StackSnapshot#
+  type role State# nominal
+  type State# :: * -> ZeroBitType
+  data State# a
+  type Symbol :: *
+  data Symbol
+  type role TVar# nominal representational
+  type TVar# :: forall {l :: Levity}. * -> TYPE (BoxedRep l) -> UnliftedType
+  data TVar# a b
+  type role TYPE nominal
+  type TYPE :: RuntimeRep -> *
+  data TYPE a
+  type ThreadId# :: UnliftedType
+  data ThreadId#
+  TrNameD :: [Char] -> GHC.Types.TrName
+  TrNameS :: Addr# -> GHC.Types.TrName
+  TypeLitChar :: GHC.Types.TypeLitSort
+  TypeLitNat :: GHC.Types.TypeLitSort
+  TypeLitSymbol :: GHC.Types.TypeLitSort
+  type UnliftedRep :: RuntimeRep
+  type UnliftedRep = BoxedRep Unlifted :: RuntimeRep
+  type UnliftedType :: *
+  type UnliftedType = TYPE UnliftedRep
+  type VecCount :: *
+  data VecCount = Vec2 | Vec4 | Vec8 | Vec16 | Vec32 | Vec64
+  type VecElem :: *
+  data VecElem = Int8ElemRep | Int16ElemRep | Int32ElemRep | Int64ElemRep | Word8ElemRep | Word16ElemRep | Word32ElemRep | Word64ElemRep | FloatElemRep | DoubleElemRep
+  type Void# :: ZeroBitType
+  type Void# = (# #) :: ZeroBitType
+  type Weak# :: forall {l :: Levity}. TYPE (BoxedRep l) -> UnliftedType
+  data Weak# a
+  type WithDict :: Constraint -> * -> Constraint
+  class WithDict cls meth where
+    withDict :: forall {rr :: RuntimeRep} (r :: TYPE rr). meth -> (cls => r) -> r
+    {-# MINIMAL withDict #-}
+  type Word :: *
+  data Word = W# Word#
+  type Word# :: TYPE WordRep
+  data Word#
+  type Word16# :: TYPE Word16Rep
+  data Word16#
+  type Word16X16# :: TYPE (VecRep Vec16 Word16ElemRep)
+  data Word16X16#
+  type Word16X32# :: TYPE (VecRep Vec32 Word16ElemRep)
+  data Word16X32#
+  type Word16X8# :: TYPE (VecRep Vec8 Word16ElemRep)
+  data Word16X8#
+  type Word32# :: TYPE Word32Rep
+  data Word32#
+  type Word32X16# :: TYPE (VecRep Vec16 Word32ElemRep)
+  data Word32X16#
+  type Word32X4# :: TYPE (VecRep Vec4 Word32ElemRep)
+  data Word32X4#
+  type Word32X8# :: TYPE (VecRep Vec8 Word32ElemRep)
+  data Word32X8#
+  type Word64# :: TYPE Word64Rep
+  data Word64#
+  type Word64X2# :: TYPE (VecRep Vec2 Word64ElemRep)
+  data Word64X2#
+  type Word64X4# :: TYPE (VecRep Vec4 Word64ElemRep)
+  data Word64X4#
+  type Word64X8# :: TYPE (VecRep Vec8 Word64ElemRep)
+  data Word64X8#
+  type Word8# :: TYPE Word8Rep
+  data Word8#
+  type Word8X16# :: TYPE (VecRep Vec16 Word8ElemRep)
+  data Word8X16#
+  type Word8X32# :: TYPE (VecRep Vec32 Word8ElemRep)
+  data Word8X32#
+  type Word8X64# :: TYPE (VecRep Vec64 Word8ElemRep)
+  data Word8X64#
+  type WordBox :: TYPE WordRep -> *
+  data WordBox a = MkWordBox a
+  type ZeroBitRep :: RuntimeRep
+  type ZeroBitRep = TupleRep '[] :: RuntimeRep
+  type ZeroBitType :: *
+  type ZeroBitType = TYPE ZeroBitRep
+  acosDouble# :: Double# -> Double#
+  acosFloat# :: Float# -> Float#
+  acoshDouble# :: Double# -> Double#
+  acoshFloat# :: Float# -> Float#
+  addCFinalizerToWeak# :: forall {k :: Levity} (b :: TYPE (BoxedRep k)). Addr# -> Addr# -> Int# -> Addr# -> Weak# b -> State# RealWorld -> (# State# RealWorld, Int# #)
+  addIntC# :: Int# -> Int# -> (# Int#, Int# #)
+  addWordC# :: Word# -> Word# -> (# Word#, Int# #)
+  addr2Int# :: Addr# -> Int#
+  addrToAny# :: forall {l :: Levity} (a :: TYPE (BoxedRep l)). Addr# -> (# a #)
+  and# :: Word# -> Word# -> Word#
+  and64# :: Word64# -> Word64# -> Word64#
+  andI# :: Int# -> Int# -> Int#
+  andWord16# :: Word16# -> Word16# -> Word16#
+  andWord32# :: Word32# -> Word32# -> Word32#
+  andWord8# :: Word8# -> Word8# -> Word8#
+  anyToAddr# :: forall a. a -> State# RealWorld -> (# State# RealWorld, Addr# #)
+  asinDouble# :: Double# -> Double#
+  asinFloat# :: Float# -> Float#
+  asinhDouble# :: Double# -> Double#
+  asinhFloat# :: Float# -> Float#
+  atanDouble# :: Double# -> Double#
+  atanFloat# :: Float# -> Float#
+  atanhDouble# :: Double# -> Double#
+  atanhFloat# :: Float# -> Float#
+  atomicCasAddrAddr# :: forall d. Addr# -> Addr# -> Addr# -> State# d -> (# State# d, Addr# #)
+  atomicCasWord16Addr# :: forall d. Addr# -> Word16# -> Word16# -> State# d -> (# State# d, Word16# #)
+  atomicCasWord32Addr# :: forall d. Addr# -> Word32# -> Word32# -> State# d -> (# State# d, Word32# #)
+  atomicCasWord64Addr# :: forall d. Addr# -> Word64# -> Word64# -> State# d -> (# State# d, Word64# #)
+  atomicCasWord8Addr# :: forall d. Addr# -> Word8# -> Word8# -> State# d -> (# State# d, Word8# #)
+  atomicCasWordAddr# :: forall d. Addr# -> Word# -> Word# -> State# d -> (# State# d, Word# #)
+  atomicExchangeAddrAddr# :: forall d. Addr# -> Addr# -> State# d -> (# State# d, Addr# #)
+  atomicExchangeWordAddr# :: forall d. Addr# -> Word# -> State# d -> (# State# d, Word# #)
+  atomicModifyMutVar# :: forall s a b c. MutVar# s a -> (a -> b) -> State# s -> (# State# s, c #)
+  atomicModifyMutVar2# :: forall d a c. MutVar# d a -> (a -> c) -> State# d -> (# State# d, a, c #)
+  atomicModifyMutVar_# :: forall d a. MutVar# d a -> (a -> a) -> State# d -> (# State# d, a, a #)
+  atomicReadIntArray# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Int# #)
+  atomicReadWordAddr# :: forall d. Addr# -> State# d -> (# State# d, Word# #)
+  atomicSwapMutVar# :: forall {l :: Levity} d (a :: TYPE (BoxedRep l)). MutVar# d a -> a -> State# d -> (# State# d, a #)
+  atomicWriteIntArray# :: forall d. MutableByteArray# d -> Int# -> Int# -> State# d -> State# d
+  atomicWriteWordAddr# :: forall d. Addr# -> Word# -> State# d -> State# d
+  atomically# :: forall {l :: Levity} (a :: TYPE (BoxedRep l)). (State# RealWorld -> (# State# RealWorld, a #)) -> State# RealWorld -> (# State# RealWorld, a #)
+  augment :: forall a. (forall b. (a -> b -> b) -> b -> b) -> [a] -> [a]
+  bitReverse# :: Word# -> Word#
+  bitReverse16# :: Word# -> Word#
+  bitReverse32# :: Word# -> Word#
+  bitReverse64# :: Word64# -> Word64#
+  bitReverse8# :: Word# -> Word#
+  breakpoint :: forall a. a -> a
+  breakpointCond :: forall a. Bool -> a -> a
+  broadcastDoubleX2# :: Double# -> DoubleX2#
+  broadcastDoubleX4# :: Double# -> DoubleX4#
+  broadcastDoubleX8# :: Double# -> DoubleX8#
+  broadcastFloatX16# :: Float# -> FloatX16#
+  broadcastFloatX4# :: Float# -> FloatX4#
+  broadcastFloatX8# :: Float# -> FloatX8#
+  broadcastInt16X16# :: Int16# -> Int16X16#
+  broadcastInt16X32# :: Int16# -> Int16X32#
+  broadcastInt16X8# :: Int16# -> Int16X8#
+  broadcastInt32X16# :: Int32# -> Int32X16#
+  broadcastInt32X4# :: Int32# -> Int32X4#
+  broadcastInt32X8# :: Int32# -> Int32X8#
+  broadcastInt64X2# :: Int64# -> Int64X2#
+  broadcastInt64X4# :: Int64# -> Int64X4#
+  broadcastInt64X8# :: Int64# -> Int64X8#
+  broadcastInt8X16# :: Int8# -> Int8X16#
+  broadcastInt8X32# :: Int8# -> Int8X32#
+  broadcastInt8X64# :: Int8# -> Int8X64#
+  broadcastWord16X16# :: Word16# -> Word16X16#
+  broadcastWord16X32# :: Word16# -> Word16X32#
+  broadcastWord16X8# :: Word16# -> Word16X8#
+  broadcastWord32X16# :: Word32# -> Word32X16#
+  broadcastWord32X4# :: Word32# -> Word32X4#
+  broadcastWord32X8# :: Word32# -> Word32X8#
+  broadcastWord64X2# :: Word64# -> Word64X2#
+  broadcastWord64X4# :: Word64# -> Word64X4#
+  broadcastWord64X8# :: Word64# -> Word64X8#
+  broadcastWord8X16# :: Word8# -> Word8X16#
+  broadcastWord8X32# :: Word8# -> Word8X32#
+  broadcastWord8X64# :: Word8# -> Word8X64#
+  build :: forall a. (forall b. (a -> b -> b) -> b -> b) -> [a]
+  byteArrayContents# :: ByteArray# -> Addr#
+  byteSwap# :: Word# -> Word#
+  byteSwap16# :: Word# -> Word#
+  byteSwap32# :: Word# -> Word#
+  byteSwap64# :: Word64# -> Word64#
+  casArray# :: forall {l :: Levity} d (a :: TYPE (BoxedRep l)). MutableArray# d a -> Int# -> a -> a -> State# d -> (# State# d, Int#, a #)
+  casInt16Array# :: forall d. MutableByteArray# d -> Int# -> Int16# -> Int16# -> State# d -> (# State# d, Int16# #)
+  casInt32Array# :: forall d. MutableByteArray# d -> Int# -> Int32# -> Int32# -> State# d -> (# State# d, Int32# #)
+  casInt64Array# :: forall d. MutableByteArray# d -> Int# -> Int64# -> Int64# -> State# d -> (# State# d, Int64# #)
+  casInt8Array# :: forall d. MutableByteArray# d -> Int# -> Int8# -> Int8# -> State# d -> (# State# d, Int8# #)
+  casIntArray# :: forall d. MutableByteArray# d -> Int# -> Int# -> Int# -> State# d -> (# State# d, Int# #)
+  casMutVar# :: forall {l :: Levity} d (a :: TYPE (BoxedRep l)). MutVar# d a -> a -> a -> State# d -> (# State# d, Int#, a #)
+  casSmallArray# :: forall {l :: Levity} d (a :: TYPE (BoxedRep l)). SmallMutableArray# d a -> Int# -> a -> a -> State# d -> (# State# d, Int#, a #)
+  castDoubleToWord64# :: Double# -> Word64#
+  castFloatToWord32# :: Float# -> Word32#
+  castWord32ToFloat# :: Word32# -> Float#
+  castWord64ToDouble# :: Word64# -> Double#
+  catch# :: forall {q :: RuntimeRep} {k :: Levity} (a :: TYPE q) (b :: TYPE (BoxedRep k)). (State# RealWorld -> (# State# RealWorld, a #)) -> (b -> State# RealWorld -> (# State# RealWorld, a #)) -> State# RealWorld -> (# State# RealWorld, a #)
+  catchRetry# :: forall {l :: Levity} (a :: TYPE (BoxedRep l)). (State# RealWorld -> (# State# RealWorld, a #)) -> (State# RealWorld -> (# State# RealWorld, a #)) -> State# RealWorld -> (# State# RealWorld, a #)
+  catchSTM# :: forall {l :: Levity} (a :: TYPE (BoxedRep l)) b. (State# RealWorld -> (# State# RealWorld, a #)) -> (b -> State# RealWorld -> (# State# RealWorld, a #)) -> State# RealWorld -> (# State# RealWorld, a #)
+  chr# :: Int# -> Char#
+  clearCCS# :: forall d a. (State# d -> (# State# d, a #)) -> State# d -> (# State# d, a #)
+  cloneArray# :: forall {l :: Levity} (a :: TYPE (BoxedRep l)). Array# a -> Int# -> Int# -> Array# a
+  cloneMutableArray# :: forall {l :: Levity} d (a :: TYPE (BoxedRep l)). MutableArray# d a -> Int# -> Int# -> State# d -> (# State# d, MutableArray# d a #)
+  cloneSmallArray# :: forall {l :: Levity} (a :: TYPE (BoxedRep l)). SmallArray# a -> Int# -> Int# -> SmallArray# a
+  cloneSmallMutableArray# :: forall {l :: Levity} d (a :: TYPE (BoxedRep l)). SmallMutableArray# d a -> Int# -> Int# -> State# d -> (# State# d, SmallMutableArray# d a #)
+  closureSize# :: forall a. a -> Int#
+  clz# :: Word# -> Word#
+  clz16# :: Word# -> Word#
+  clz32# :: Word# -> Word#
+  clz64# :: Word64# -> Word#
+  clz8# :: Word# -> Word#
+  coerce :: forall {k :: RuntimeRep} (a :: TYPE k) (b :: TYPE k). Coercible a b => a -> b
+  compactAdd# :: forall a. Compact# -> a -> State# RealWorld -> (# State# RealWorld, a #)
+  compactAddWithSharing# :: forall a. Compact# -> a -> State# RealWorld -> (# State# RealWorld, a #)
+  compactAllocateBlock# :: Word# -> Addr# -> State# RealWorld -> (# State# RealWorld, Addr# #)
+  compactContains# :: forall a. Compact# -> a -> State# RealWorld -> (# State# RealWorld, Int# #)
+  compactContainsAny# :: forall a. a -> State# RealWorld -> (# State# RealWorld, Int# #)
+  compactFixupPointers# :: Addr# -> Addr# -> State# RealWorld -> (# State# RealWorld, Compact#, Addr# #)
+  compactGetFirstBlock# :: Compact# -> State# RealWorld -> (# State# RealWorld, Addr#, Word# #)
+  compactGetNextBlock# :: Compact# -> Addr# -> State# RealWorld -> (# State# RealWorld, Addr#, Word# #)
+  compactNew# :: Word# -> State# RealWorld -> (# State# RealWorld, Compact# #)
+  compactResize# :: Compact# -> Word# -> State# RealWorld -> State# RealWorld
+  compactSize# :: Compact# -> State# RealWorld -> (# State# RealWorld, Word# #)
+  compareByteArrays# :: ByteArray# -> Int# -> ByteArray# -> Int# -> Int# -> Int#
+  considerAccessible :: Bool
+  control0# :: forall {r :: RuntimeRep} a (b :: TYPE r). PromptTag# a -> (((State# RealWorld -> (# State# RealWorld, b #)) -> State# RealWorld -> (# State# RealWorld, a #)) -> State# RealWorld -> (# State# RealWorld, a #)) -> State# RealWorld -> (# State# RealWorld, b #)
+  copyAddrToAddr# :: Addr# -> Addr# -> Int# -> State# RealWorld -> State# RealWorld
+  copyAddrToAddrNonOverlapping# :: Addr# -> Addr# -> Int# -> State# RealWorld -> State# RealWorld
+  copyAddrToByteArray# :: forall d. Addr# -> MutableByteArray# d -> Int# -> Int# -> State# d -> State# d
+  copyArray# :: forall {l :: Levity} (a :: TYPE (BoxedRep l)) d. Array# a -> Int# -> MutableArray# d a -> Int# -> Int# -> State# d -> State# d
+  copyArrayArray# :: forall s. ArrayArray# -> Int# -> MutableArrayArray# s -> Int# -> Int# -> State# s -> State# s
+  copyByteArray# :: forall d. ByteArray# -> Int# -> MutableByteArray# d -> Int# -> Int# -> State# d -> State# d
+  copyByteArrayToAddr# :: forall d. ByteArray# -> Int# -> Addr# -> Int# -> State# d -> State# d
+  copyMutableArray# :: forall {l :: Levity} d (a :: TYPE (BoxedRep l)). MutableArray# d a -> Int# -> MutableArray# d a -> Int# -> Int# -> State# d -> State# d
+  copyMutableArrayArray# :: forall s. MutableArrayArray# s -> Int# -> MutableArrayArray# s -> Int# -> Int# -> State# s -> State# s
+  copyMutableByteArray# :: forall d. MutableByteArray# d -> Int# -> MutableByteArray# d -> Int# -> Int# -> State# d -> State# d
+  copyMutableByteArrayNonOverlapping# :: forall d. MutableByteArray# d -> Int# -> MutableByteArray# d -> Int# -> Int# -> State# d -> State# d
+  copyMutableByteArrayToAddr# :: forall d. MutableByteArray# d -> Int# -> Addr# -> Int# -> State# d -> State# d
+  copySmallArray# :: forall {l :: Levity} (a :: TYPE (BoxedRep l)) d. SmallArray# a -> Int# -> SmallMutableArray# d a -> Int# -> Int# -> State# d -> State# d
+  copySmallMutableArray# :: forall {l :: Levity} d (a :: TYPE (BoxedRep l)). SmallMutableArray# d a -> Int# -> SmallMutableArray# d a -> Int# -> Int# -> State# d -> State# d
+  cosDouble# :: Double# -> Double#
+  cosFloat# :: Float# -> Float#
+  coshDouble# :: Double# -> Double#
+  coshFloat# :: Float# -> Float#
+  cstringLength# :: Addr# -> Int#
+  ctz# :: Word# -> Word#
+  ctz16# :: Word# -> Word#
+  ctz32# :: Word# -> Word#
+  ctz64# :: Word64# -> Word#
+  ctz8# :: Word# -> Word#
+  currentCallStack :: GHC.Types.IO [GHC.Internal.Base.String]
+  deRefStablePtr# :: forall {l :: Levity} (a :: TYPE (BoxedRep l)). StablePtr# a -> State# RealWorld -> (# State# RealWorld, a #)
+  deRefWeak# :: forall {l :: Levity} (a :: TYPE (BoxedRep l)). Weak# a -> State# RealWorld -> (# State# RealWorld, Int#, a #)
+  decodeDouble_2Int# :: Double# -> (# Int#, Word#, Word#, Int# #)
+  decodeDouble_Int64# :: Double# -> (# Int64#, Int# #)
+  decodeFloat_Int# :: Float# -> (# Int#, Int# #)
+  delay# :: forall d. Int# -> State# d -> State# d
+  divideDoubleX2# :: DoubleX2# -> DoubleX2# -> DoubleX2#
+  divideDoubleX4# :: DoubleX4# -> DoubleX4# -> DoubleX4#
+  divideDoubleX8# :: DoubleX8# -> DoubleX8# -> DoubleX8#
+  divideFloat# :: Float# -> Float# -> Float#
+  divideFloatX16# :: FloatX16# -> FloatX16# -> FloatX16#
+  divideFloatX4# :: FloatX4# -> FloatX4# -> FloatX4#
+  divideFloatX8# :: FloatX8# -> FloatX8# -> FloatX8#
+  double2Float# :: Double# -> Float#
+  double2Int# :: Double# -> Int#
+  eqAddr# :: Addr# -> Addr# -> Int#
+  eqChar# :: Char# -> Char# -> Int#
+  eqFloat# :: Float# -> Float# -> Int#
+  eqInt16# :: Int16# -> Int16# -> Int#
+  eqInt32# :: Int32# -> Int32# -> Int#
+  eqInt64# :: Int64# -> Int64# -> Int#
+  eqInt8# :: Int8# -> Int8# -> Int#
+  eqStableName# :: forall {k :: Levity} {l :: Levity} (a :: TYPE (BoxedRep k)) (b :: TYPE (BoxedRep l)). StableName# a -> StableName# b -> Int#
+  eqStablePtr# :: forall {l :: Levity} (a :: TYPE (BoxedRep l)). StablePtr# a -> StablePtr# a -> Int#
+  eqWord# :: Word# -> Word# -> Int#
+  eqWord16# :: Word16# -> Word16# -> Int#
+  eqWord32# :: Word32# -> Word32# -> Int#
+  eqWord64# :: Word64# -> Word64# -> Int#
+  eqWord8# :: Word8# -> Word8# -> Int#
+  expDouble# :: Double# -> Double#
+  expFloat# :: Float# -> Float#
+  expm1Double# :: Double# -> Double#
+  expm1Float# :: Float# -> Float#
+  fabsDouble# :: Double# -> Double#
+  fabsFloat# :: Float# -> Float#
+  fetchAddIntArray# :: forall d. MutableByteArray# d -> Int# -> Int# -> State# d -> (# State# d, Int# #)
+  fetchAddWordAddr# :: forall d. Addr# -> Word# -> State# d -> (# State# d, Word# #)
+  fetchAndIntArray# :: forall d. MutableByteArray# d -> Int# -> Int# -> State# d -> (# State# d, Int# #)
+  fetchAndWordAddr# :: forall d. Addr# -> Word# -> State# d -> (# State# d, Word# #)
+  fetchNandIntArray# :: forall d. MutableByteArray# d -> Int# -> Int# -> State# d -> (# State# d, Int# #)
+  fetchNandWordAddr# :: forall d. Addr# -> Word# -> State# d -> (# State# d, Word# #)
+  fetchOrIntArray# :: forall d. MutableByteArray# d -> Int# -> Int# -> State# d -> (# State# d, Int# #)
+  fetchOrWordAddr# :: forall d. Addr# -> Word# -> State# d -> (# State# d, Word# #)
+  fetchSubIntArray# :: forall d. MutableByteArray# d -> Int# -> Int# -> State# d -> (# State# d, Int# #)
+  fetchSubWordAddr# :: forall d. Addr# -> Word# -> State# d -> (# State# d, Word# #)
+  fetchXorIntArray# :: forall d. MutableByteArray# d -> Int# -> Int# -> State# d -> (# State# d, Int# #)
+  fetchXorWordAddr# :: forall d. Addr# -> Word# -> State# d -> (# State# d, Word# #)
+  finalizeWeak# :: forall {l :: Levity} (a :: TYPE (BoxedRep l)) b. Weak# a -> State# RealWorld -> (# State# RealWorld, Int#, State# RealWorld -> (# State# RealWorld, b #) #)
+  float2Double# :: Float# -> Double#
+  float2Int# :: Float# -> Int#
+  fmaddDouble# :: Double# -> Double# -> Double# -> Double#
+  fmaddDoubleX2# :: DoubleX2# -> DoubleX2# -> DoubleX2# -> DoubleX2#
+  fmaddDoubleX4# :: DoubleX4# -> DoubleX4# -> DoubleX4# -> DoubleX4#
+  fmaddDoubleX8# :: DoubleX8# -> DoubleX8# -> DoubleX8# -> DoubleX8#
+  fmaddFloat# :: Float# -> Float# -> Float# -> Float#
+  fmaddFloatX16# :: FloatX16# -> FloatX16# -> FloatX16# -> FloatX16#
+  fmaddFloatX4# :: FloatX4# -> FloatX4# -> FloatX4# -> FloatX4#
+  fmaddFloatX8# :: FloatX8# -> FloatX8# -> FloatX8# -> FloatX8#
+  fmsubDouble# :: Double# -> Double# -> Double# -> Double#
+  fmsubDoubleX2# :: DoubleX2# -> DoubleX2# -> DoubleX2# -> DoubleX2#
+  fmsubDoubleX4# :: DoubleX4# -> DoubleX4# -> DoubleX4# -> DoubleX4#
+  fmsubDoubleX8# :: DoubleX8# -> DoubleX8# -> DoubleX8# -> DoubleX8#
+  fmsubFloat# :: Float# -> Float# -> Float# -> Float#
+  fmsubFloatX16# :: FloatX16# -> FloatX16# -> FloatX16# -> FloatX16#
+  fmsubFloatX4# :: FloatX4# -> FloatX4# -> FloatX4# -> FloatX4#
+  fmsubFloatX8# :: FloatX8# -> FloatX8# -> FloatX8# -> FloatX8#
+  fnmaddDouble# :: Double# -> Double# -> Double# -> Double#
+  fnmaddDoubleX2# :: DoubleX2# -> DoubleX2# -> DoubleX2# -> DoubleX2#
+  fnmaddDoubleX4# :: DoubleX4# -> DoubleX4# -> DoubleX4# -> DoubleX4#
+  fnmaddDoubleX8# :: DoubleX8# -> DoubleX8# -> DoubleX8# -> DoubleX8#
+  fnmaddFloat# :: Float# -> Float# -> Float# -> Float#
+  fnmaddFloatX16# :: FloatX16# -> FloatX16# -> FloatX16# -> FloatX16#
+  fnmaddFloatX4# :: FloatX4# -> FloatX4# -> FloatX4# -> FloatX4#
+  fnmaddFloatX8# :: FloatX8# -> FloatX8# -> FloatX8# -> FloatX8#
+  fnmsubDouble# :: Double# -> Double# -> Double# -> Double#
+  fnmsubDoubleX2# :: DoubleX2# -> DoubleX2# -> DoubleX2# -> DoubleX2#
+  fnmsubDoubleX4# :: DoubleX4# -> DoubleX4# -> DoubleX4# -> DoubleX4#
+  fnmsubDoubleX8# :: DoubleX8# -> DoubleX8# -> DoubleX8# -> DoubleX8#
+  fnmsubFloat# :: Float# -> Float# -> Float# -> Float#
+  fnmsubFloatX16# :: FloatX16# -> FloatX16# -> FloatX16# -> FloatX16#
+  fnmsubFloatX4# :: FloatX4# -> FloatX4# -> FloatX4# -> FloatX4#
+  fnmsubFloatX8# :: FloatX8# -> FloatX8# -> FloatX8# -> FloatX8#
+  fork# :: forall {q :: RuntimeRep} (a :: TYPE q). (State# RealWorld -> (# State# RealWorld, a #)) -> State# RealWorld -> (# State# RealWorld, ThreadId# #)
+  forkOn# :: forall {q :: RuntimeRep} (a :: TYPE q). Int# -> (State# RealWorld -> (# State# RealWorld, a #)) -> State# RealWorld -> (# State# RealWorld, ThreadId# #)
+  freezeArray# :: forall {l :: Levity} d (a :: TYPE (BoxedRep l)). MutableArray# d a -> Int# -> Int# -> State# d -> (# State# d, Array# a #)
+  freezeSmallArray# :: forall {l :: Levity} d (a :: TYPE (BoxedRep l)). SmallMutableArray# d a -> Int# -> Int# -> State# d -> (# State# d, SmallArray# a #)
+  geAddr# :: Addr# -> Addr# -> Int#
+  geChar# :: Char# -> Char# -> Int#
+  geFloat# :: Float# -> Float# -> Int#
+  geInt16# :: Int16# -> Int16# -> Int#
+  geInt32# :: Int32# -> Int32# -> Int#
+  geInt64# :: Int64# -> Int64# -> Int#
+  geInt8# :: Int8# -> Int8# -> Int#
+  geWord# :: Word# -> Word# -> Int#
+  geWord16# :: Word16# -> Word16# -> Int#
+  geWord32# :: Word32# -> Word32# -> Int#
+  geWord64# :: Word64# -> Word64# -> Int#
+  geWord8# :: Word8# -> Word8# -> Int#
+  getApStackVal# :: forall a b. a -> Int# -> (# Int#, b #)
+  getCCSOf# :: forall a d. a -> State# d -> (# State# d, Addr# #)
+  getCurrentCCS# :: forall a d. a -> State# d -> (# State# d, Addr# #)
+  getMaskingState# :: State# RealWorld -> (# State# RealWorld, Int# #)
+  getSizeofMutableByteArray# :: forall d. MutableByteArray# d -> State# d -> (# State# d, Int# #)
+  getSizeofSmallMutableArray# :: forall {l :: Levity} d (a :: TYPE (BoxedRep l)). SmallMutableArray# d a -> State# d -> (# State# d, Int# #)
+  getSpark# :: forall d a. State# d -> (# State# d, Int#, a #)
+  getThreadAllocationCounter# :: State# RealWorld -> (# State# RealWorld, Int64# #)
+  groupWith :: forall b a. GHC.Classes.Ord b => (a -> b) -> [a] -> [[a]]
+  gtAddr# :: Addr# -> Addr# -> Int#
+  gtChar# :: Char# -> Char# -> Int#
+  gtFloat# :: Float# -> Float# -> Int#
+  gtInt16# :: Int16# -> Int16# -> Int#
+  gtInt32# :: Int32# -> Int32# -> Int#
+  gtInt64# :: Int64# -> Int64# -> Int#
+  gtInt8# :: Int8# -> Int8# -> Int#
+  gtWord# :: Word# -> Word# -> Int#
+  gtWord16# :: Word16# -> Word16# -> Int#
+  gtWord32# :: Word32# -> Word32# -> Int#
+  gtWord64# :: Word64# -> Word64# -> Int#
+  gtWord8# :: Word8# -> Word8# -> Int#
+  iShiftL# :: Int# -> Int# -> Int#
+  iShiftRA# :: Int# -> Int# -> Int#
+  iShiftRL# :: Int# -> Int# -> Int#
+  indexAddrArray# :: ByteArray# -> Int# -> Addr#
+  indexAddrOffAddr# :: Addr# -> Int# -> Addr#
+  indexArray# :: forall {l :: Levity} (a :: TYPE (BoxedRep l)). Array# a -> Int# -> (# a #)
+  indexArrayArrayArray# :: ArrayArray# -> Int# -> ArrayArray#
+  indexByteArrayArray# :: ArrayArray# -> Int# -> ByteArray#
+  indexCharArray# :: ByteArray# -> Int# -> Char#
+  indexCharOffAddr# :: Addr# -> Int# -> Char#
+  indexDoubleArray# :: ByteArray# -> Int# -> Double#
+  indexDoubleArrayAsDoubleX2# :: ByteArray# -> Int# -> DoubleX2#
+  indexDoubleArrayAsDoubleX4# :: ByteArray# -> Int# -> DoubleX4#
+  indexDoubleArrayAsDoubleX8# :: ByteArray# -> Int# -> DoubleX8#
+  indexDoubleOffAddr# :: Addr# -> Int# -> Double#
+  indexDoubleOffAddrAsDoubleX2# :: Addr# -> Int# -> DoubleX2#
+  indexDoubleOffAddrAsDoubleX4# :: Addr# -> Int# -> DoubleX4#
+  indexDoubleOffAddrAsDoubleX8# :: Addr# -> Int# -> DoubleX8#
+  indexDoubleX2Array# :: ByteArray# -> Int# -> DoubleX2#
+  indexDoubleX2OffAddr# :: Addr# -> Int# -> DoubleX2#
+  indexDoubleX4Array# :: ByteArray# -> Int# -> DoubleX4#
+  indexDoubleX4OffAddr# :: Addr# -> Int# -> DoubleX4#
+  indexDoubleX8Array# :: ByteArray# -> Int# -> DoubleX8#
+  indexDoubleX8OffAddr# :: Addr# -> Int# -> DoubleX8#
+  indexFloatArray# :: ByteArray# -> Int# -> Float#
+  indexFloatArrayAsFloatX16# :: ByteArray# -> Int# -> FloatX16#
+  indexFloatArrayAsFloatX4# :: ByteArray# -> Int# -> FloatX4#
+  indexFloatArrayAsFloatX8# :: ByteArray# -> Int# -> FloatX8#
+  indexFloatOffAddr# :: Addr# -> Int# -> Float#
+  indexFloatOffAddrAsFloatX16# :: Addr# -> Int# -> FloatX16#
+  indexFloatOffAddrAsFloatX4# :: Addr# -> Int# -> FloatX4#
+  indexFloatOffAddrAsFloatX8# :: Addr# -> Int# -> FloatX8#
+  indexFloatX16Array# :: ByteArray# -> Int# -> FloatX16#
+  indexFloatX16OffAddr# :: Addr# -> Int# -> FloatX16#
+  indexFloatX4Array# :: ByteArray# -> Int# -> FloatX4#
+  indexFloatX4OffAddr# :: Addr# -> Int# -> FloatX4#
+  indexFloatX8Array# :: ByteArray# -> Int# -> FloatX8#
+  indexFloatX8OffAddr# :: Addr# -> Int# -> FloatX8#
+  indexInt16Array# :: ByteArray# -> Int# -> Int16#
+  indexInt16ArrayAsInt16X16# :: ByteArray# -> Int# -> Int16X16#
+  indexInt16ArrayAsInt16X32# :: ByteArray# -> Int# -> Int16X32#
+  indexInt16ArrayAsInt16X8# :: ByteArray# -> Int# -> Int16X8#
+  indexInt16OffAddr# :: Addr# -> Int# -> Int16#
+  indexInt16OffAddrAsInt16X16# :: Addr# -> Int# -> Int16X16#
+  indexInt16OffAddrAsInt16X32# :: Addr# -> Int# -> Int16X32#
+  indexInt16OffAddrAsInt16X8# :: Addr# -> Int# -> Int16X8#
+  indexInt16X16Array# :: ByteArray# -> Int# -> Int16X16#
+  indexInt16X16OffAddr# :: Addr# -> Int# -> Int16X16#
+  indexInt16X32Array# :: ByteArray# -> Int# -> Int16X32#
+  indexInt16X32OffAddr# :: Addr# -> Int# -> Int16X32#
+  indexInt16X8Array# :: ByteArray# -> Int# -> Int16X8#
+  indexInt16X8OffAddr# :: Addr# -> Int# -> Int16X8#
+  indexInt32Array# :: ByteArray# -> Int# -> Int32#
+  indexInt32ArrayAsInt32X16# :: ByteArray# -> Int# -> Int32X16#
+  indexInt32ArrayAsInt32X4# :: ByteArray# -> Int# -> Int32X4#
+  indexInt32ArrayAsInt32X8# :: ByteArray# -> Int# -> Int32X8#
+  indexInt32OffAddr# :: Addr# -> Int# -> Int32#
+  indexInt32OffAddrAsInt32X16# :: Addr# -> Int# -> Int32X16#
+  indexInt32OffAddrAsInt32X4# :: Addr# -> Int# -> Int32X4#
+  indexInt32OffAddrAsInt32X8# :: Addr# -> Int# -> Int32X8#
+  indexInt32X16Array# :: ByteArray# -> Int# -> Int32X16#
+  indexInt32X16OffAddr# :: Addr# -> Int# -> Int32X16#
+  indexInt32X4Array# :: ByteArray# -> Int# -> Int32X4#
+  indexInt32X4OffAddr# :: Addr# -> Int# -> Int32X4#
+  indexInt32X8Array# :: ByteArray# -> Int# -> Int32X8#
+  indexInt32X8OffAddr# :: Addr# -> Int# -> Int32X8#
+  indexInt64Array# :: ByteArray# -> Int# -> Int64#
+  indexInt64ArrayAsInt64X2# :: ByteArray# -> Int# -> Int64X2#
+  indexInt64ArrayAsInt64X4# :: ByteArray# -> Int# -> Int64X4#
+  indexInt64ArrayAsInt64X8# :: ByteArray# -> Int# -> Int64X8#
+  indexInt64OffAddr# :: Addr# -> Int# -> Int64#
+  indexInt64OffAddrAsInt64X2# :: Addr# -> Int# -> Int64X2#
+  indexInt64OffAddrAsInt64X4# :: Addr# -> Int# -> Int64X4#
+  indexInt64OffAddrAsInt64X8# :: Addr# -> Int# -> Int64X8#
+  indexInt64X2Array# :: ByteArray# -> Int# -> Int64X2#
+  indexInt64X2OffAddr# :: Addr# -> Int# -> Int64X2#
+  indexInt64X4Array# :: ByteArray# -> Int# -> Int64X4#
+  indexInt64X4OffAddr# :: Addr# -> Int# -> Int64X4#
+  indexInt64X8Array# :: ByteArray# -> Int# -> Int64X8#
+  indexInt64X8OffAddr# :: Addr# -> Int# -> Int64X8#
+  indexInt8Array# :: ByteArray# -> Int# -> Int8#
+  indexInt8ArrayAsInt8X16# :: ByteArray# -> Int# -> Int8X16#
+  indexInt8ArrayAsInt8X32# :: ByteArray# -> Int# -> Int8X32#
+  indexInt8ArrayAsInt8X64# :: ByteArray# -> Int# -> Int8X64#
+  indexInt8OffAddr# :: Addr# -> Int# -> Int8#
+  indexInt8OffAddrAsInt8X16# :: Addr# -> Int# -> Int8X16#
+  indexInt8OffAddrAsInt8X32# :: Addr# -> Int# -> Int8X32#
+  indexInt8OffAddrAsInt8X64# :: Addr# -> Int# -> Int8X64#
+  indexInt8X16Array# :: ByteArray# -> Int# -> Int8X16#
+  indexInt8X16OffAddr# :: Addr# -> Int# -> Int8X16#
+  indexInt8X32Array# :: ByteArray# -> Int# -> Int8X32#
+  indexInt8X32OffAddr# :: Addr# -> Int# -> Int8X32#
+  indexInt8X64Array# :: ByteArray# -> Int# -> Int8X64#
+  indexInt8X64OffAddr# :: Addr# -> Int# -> Int8X64#
+  indexIntArray# :: ByteArray# -> Int# -> Int#
+  indexIntOffAddr# :: Addr# -> Int# -> Int#
+  indexSmallArray# :: forall {l :: Levity} (a :: TYPE (BoxedRep l)). SmallArray# a -> Int# -> (# a #)
+  indexStablePtrArray# :: forall a. ByteArray# -> Int# -> StablePtr# a
+  indexStablePtrOffAddr# :: forall a. Addr# -> Int# -> StablePtr# a
+  indexWideCharArray# :: ByteArray# -> Int# -> Char#
+  indexWideCharOffAddr# :: Addr# -> Int# -> Char#
+  indexWord16Array# :: ByteArray# -> Int# -> Word16#
+  indexWord16ArrayAsWord16X16# :: ByteArray# -> Int# -> Word16X16#
+  indexWord16ArrayAsWord16X32# :: ByteArray# -> Int# -> Word16X32#
+  indexWord16ArrayAsWord16X8# :: ByteArray# -> Int# -> Word16X8#
+  indexWord16OffAddr# :: Addr# -> Int# -> Word16#
+  indexWord16OffAddrAsWord16X16# :: Addr# -> Int# -> Word16X16#
+  indexWord16OffAddrAsWord16X32# :: Addr# -> Int# -> Word16X32#
+  indexWord16OffAddrAsWord16X8# :: Addr# -> Int# -> Word16X8#
+  indexWord16X16Array# :: ByteArray# -> Int# -> Word16X16#
+  indexWord16X16OffAddr# :: Addr# -> Int# -> Word16X16#
+  indexWord16X32Array# :: ByteArray# -> Int# -> Word16X32#
+  indexWord16X32OffAddr# :: Addr# -> Int# -> Word16X32#
+  indexWord16X8Array# :: ByteArray# -> Int# -> Word16X8#
+  indexWord16X8OffAddr# :: Addr# -> Int# -> Word16X8#
+  indexWord32Array# :: ByteArray# -> Int# -> Word32#
+  indexWord32ArrayAsWord32X16# :: ByteArray# -> Int# -> Word32X16#
+  indexWord32ArrayAsWord32X4# :: ByteArray# -> Int# -> Word32X4#
+  indexWord32ArrayAsWord32X8# :: ByteArray# -> Int# -> Word32X8#
+  indexWord32OffAddr# :: Addr# -> Int# -> Word32#
+  indexWord32OffAddrAsWord32X16# :: Addr# -> Int# -> Word32X16#
+  indexWord32OffAddrAsWord32X4# :: Addr# -> Int# -> Word32X4#
+  indexWord32OffAddrAsWord32X8# :: Addr# -> Int# -> Word32X8#
+  indexWord32X16Array# :: ByteArray# -> Int# -> Word32X16#
+  indexWord32X16OffAddr# :: Addr# -> Int# -> Word32X16#
+  indexWord32X4Array# :: ByteArray# -> Int# -> Word32X4#
+  indexWord32X4OffAddr# :: Addr# -> Int# -> Word32X4#
+  indexWord32X8Array# :: ByteArray# -> Int# -> Word32X8#
+  indexWord32X8OffAddr# :: Addr# -> Int# -> Word32X8#
+  indexWord64Array# :: ByteArray# -> Int# -> Word64#
+  indexWord64ArrayAsWord64X2# :: ByteArray# -> Int# -> Word64X2#
+  indexWord64ArrayAsWord64X4# :: ByteArray# -> Int# -> Word64X4#
+  indexWord64ArrayAsWord64X8# :: ByteArray# -> Int# -> Word64X8#
+  indexWord64OffAddr# :: Addr# -> Int# -> Word64#
+  indexWord64OffAddrAsWord64X2# :: Addr# -> Int# -> Word64X2#
+  indexWord64OffAddrAsWord64X4# :: Addr# -> Int# -> Word64X4#
+  indexWord64OffAddrAsWord64X8# :: Addr# -> Int# -> Word64X8#
+  indexWord64X2Array# :: ByteArray# -> Int# -> Word64X2#
+  indexWord64X2OffAddr# :: Addr# -> Int# -> Word64X2#
+  indexWord64X4Array# :: ByteArray# -> Int# -> Word64X4#
+  indexWord64X4OffAddr# :: Addr# -> Int# -> Word64X4#
+  indexWord64X8Array# :: ByteArray# -> Int# -> Word64X8#
+  indexWord64X8OffAddr# :: Addr# -> Int# -> Word64X8#
+  indexWord8Array# :: ByteArray# -> Int# -> Word8#
+  indexWord8ArrayAsAddr# :: ByteArray# -> Int# -> Addr#
+  indexWord8ArrayAsChar# :: ByteArray# -> Int# -> Char#
+  indexWord8ArrayAsDouble# :: ByteArray# -> Int# -> Double#
+  indexWord8ArrayAsFloat# :: ByteArray# -> Int# -> Float#
+  indexWord8ArrayAsInt# :: ByteArray# -> Int# -> Int#
+  indexWord8ArrayAsInt16# :: ByteArray# -> Int# -> Int16#
+  indexWord8ArrayAsInt32# :: ByteArray# -> Int# -> Int32#
+  indexWord8ArrayAsInt64# :: ByteArray# -> Int# -> Int64#
+  indexWord8ArrayAsStablePtr# :: forall a. ByteArray# -> Int# -> StablePtr# a
+  indexWord8ArrayAsWideChar# :: ByteArray# -> Int# -> Char#
+  indexWord8ArrayAsWord# :: ByteArray# -> Int# -> Word#
+  indexWord8ArrayAsWord16# :: ByteArray# -> Int# -> Word16#
+  indexWord8ArrayAsWord32# :: ByteArray# -> Int# -> Word32#
+  indexWord8ArrayAsWord64# :: ByteArray# -> Int# -> Word64#
+  indexWord8ArrayAsWord8X16# :: ByteArray# -> Int# -> Word8X16#
+  indexWord8ArrayAsWord8X32# :: ByteArray# -> Int# -> Word8X32#
+  indexWord8ArrayAsWord8X64# :: ByteArray# -> Int# -> Word8X64#
+  indexWord8OffAddr# :: Addr# -> Int# -> Word8#
+  indexWord8OffAddrAsAddr# :: Addr# -> Int# -> Addr#
+  indexWord8OffAddrAsChar# :: Addr# -> Int# -> Char#
+  indexWord8OffAddrAsDouble# :: Addr# -> Int# -> Double#
+  indexWord8OffAddrAsFloat# :: Addr# -> Int# -> Float#
+  indexWord8OffAddrAsInt# :: Addr# -> Int# -> Int#
+  indexWord8OffAddrAsInt16# :: Addr# -> Int# -> Int16#
+  indexWord8OffAddrAsInt32# :: Addr# -> Int# -> Int32#
+  indexWord8OffAddrAsInt64# :: Addr# -> Int# -> Int64#
+  indexWord8OffAddrAsStablePtr# :: forall a. Addr# -> Int# -> StablePtr# a
+  indexWord8OffAddrAsWideChar# :: Addr# -> Int# -> Char#
+  indexWord8OffAddrAsWord# :: Addr# -> Int# -> Word#
+  indexWord8OffAddrAsWord16# :: Addr# -> Int# -> Word16#
+  indexWord8OffAddrAsWord32# :: Addr# -> Int# -> Word32#
+  indexWord8OffAddrAsWord64# :: Addr# -> Int# -> Word64#
+  indexWord8OffAddrAsWord8X16# :: Addr# -> Int# -> Word8X16#
+  indexWord8OffAddrAsWord8X32# :: Addr# -> Int# -> Word8X32#
+  indexWord8OffAddrAsWord8X64# :: Addr# -> Int# -> Word8X64#
+  indexWord8X16Array# :: ByteArray# -> Int# -> Word8X16#
+  indexWord8X16OffAddr# :: Addr# -> Int# -> Word8X16#
+  indexWord8X32Array# :: ByteArray# -> Int# -> Word8X32#
+  indexWord8X32OffAddr# :: Addr# -> Int# -> Word8X32#
+  indexWord8X64Array# :: ByteArray# -> Int# -> Word8X64#
+  indexWord8X64OffAddr# :: Addr# -> Int# -> Word8X64#
+  indexWordArray# :: ByteArray# -> Int# -> Word#
+  indexWordOffAddr# :: Addr# -> Int# -> Word#
+  inline :: forall a. a -> a
+  insertDoubleX2# :: DoubleX2# -> Double# -> Int# -> DoubleX2#
+  insertDoubleX4# :: DoubleX4# -> Double# -> Int# -> DoubleX4#
+  insertDoubleX8# :: DoubleX8# -> Double# -> Int# -> DoubleX8#
+  insertFloatX16# :: FloatX16# -> Float# -> Int# -> FloatX16#
+  insertFloatX4# :: FloatX4# -> Float# -> Int# -> FloatX4#
+  insertFloatX8# :: FloatX8# -> Float# -> Int# -> FloatX8#
+  insertInt16X16# :: Int16X16# -> Int16# -> Int# -> Int16X16#
+  insertInt16X32# :: Int16X32# -> Int16# -> Int# -> Int16X32#
+  insertInt16X8# :: Int16X8# -> Int16# -> Int# -> Int16X8#
+  insertInt32X16# :: Int32X16# -> Int32# -> Int# -> Int32X16#
+  insertInt32X4# :: Int32X4# -> Int32# -> Int# -> Int32X4#
+  insertInt32X8# :: Int32X8# -> Int32# -> Int# -> Int32X8#
+  insertInt64X2# :: Int64X2# -> Int64# -> Int# -> Int64X2#
+  insertInt64X4# :: Int64X4# -> Int64# -> Int# -> Int64X4#
+  insertInt64X8# :: Int64X8# -> Int64# -> Int# -> Int64X8#
+  insertInt8X16# :: Int8X16# -> Int8# -> Int# -> Int8X16#
+  insertInt8X32# :: Int8X32# -> Int8# -> Int# -> Int8X32#
+  insertInt8X64# :: Int8X64# -> Int8# -> Int# -> Int8X64#
+  insertWord16X16# :: Word16X16# -> Word16# -> Int# -> Word16X16#
+  insertWord16X32# :: Word16X32# -> Word16# -> Int# -> Word16X32#
+  insertWord16X8# :: Word16X8# -> Word16# -> Int# -> Word16X8#
+  insertWord32X16# :: Word32X16# -> Word32# -> Int# -> Word32X16#
+  insertWord32X4# :: Word32X4# -> Word32# -> Int# -> Word32X4#
+  insertWord32X8# :: Word32X8# -> Word32# -> Int# -> Word32X8#
+  insertWord64X2# :: Word64X2# -> Word64# -> Int# -> Word64X2#
+  insertWord64X4# :: Word64X4# -> Word64# -> Int# -> Word64X4#
+  insertWord64X8# :: Word64X8# -> Word64# -> Int# -> Word64X8#
+  insertWord8X16# :: Word8X16# -> Word8# -> Int# -> Word8X16#
+  insertWord8X32# :: Word8X32# -> Word8# -> Int# -> Word8X32#
+  insertWord8X64# :: Word8X64# -> Word8# -> Int# -> Word8X64#
+  int16ToInt# :: Int16# -> Int#
+  int16ToWord16# :: Int16# -> Word16#
+  int2Addr# :: Int# -> Addr#
+  int2Double# :: Int# -> Double#
+  int2Float# :: Int# -> Float#
+  int2Word# :: Int# -> Word#
+  int32ToInt# :: Int32# -> Int#
+  int32ToWord32# :: Int32# -> Word32#
+  int64ToInt# :: Int64# -> Int#
+  int64ToWord64# :: Int64# -> Word64#
+  int8ToInt# :: Int8# -> Int#
+  int8ToWord8# :: Int8# -> Word8#
+  intToInt16# :: Int# -> Int16#
+  intToInt32# :: Int# -> Int32#
+  intToInt64# :: Int# -> Int64#
+  intToInt8# :: Int# -> Int8#
+  isByteArrayPinned# :: ByteArray# -> Int#
+  isByteArrayWeaklyPinned# :: ByteArray# -> Int#
+  isCurrentThreadBound# :: State# RealWorld -> (# State# RealWorld, Int# #)
+  isEmptyMVar# :: forall {l :: Levity} d (a :: TYPE (BoxedRep l)). MVar# d a -> State# d -> (# State# d, Int# #)
+  isMutableByteArrayPinned# :: forall d. MutableByteArray# d -> Int#
+  isMutableByteArrayWeaklyPinned# :: forall d. MutableByteArray# d -> Int#
+  isTrue# :: Int# -> Bool
+  keepAlive# :: forall {l :: Levity} {r :: RuntimeRep} (a :: TYPE (BoxedRep l)) d (b :: TYPE r). a -> State# d -> (State# d -> b) -> b
+  killThread# :: forall a. ThreadId# -> a -> State# RealWorld -> State# RealWorld
+  labelThread# :: ThreadId# -> ByteArray# -> State# RealWorld -> State# RealWorld
+  lazy :: forall a. a -> a
+  leAddr# :: Addr# -> Addr# -> Int#
+  leChar# :: Char# -> Char# -> Int#
+  leFloat# :: Float# -> Float# -> Int#
+  leInt16# :: Int16# -> Int16# -> Int#
+  leInt32# :: Int32# -> Int32# -> Int#
+  leInt64# :: Int64# -> Int64# -> Int#
+  leInt8# :: Int8# -> Int8# -> Int#
+  leWord# :: Word# -> Word# -> Int#
+  leWord16# :: Word16# -> Word16# -> Int#
+  leWord32# :: Word32# -> Word32# -> Int#
+  leWord64# :: Word64# -> Word64# -> Int#
+  leWord8# :: Word8# -> Word8# -> Int#
+  leftSection :: forall {q :: RuntimeRep} {r :: RuntimeRep} (a :: TYPE q) (b :: TYPE r). (a -> b) -> a -> b
+  listThreads# :: State# RealWorld -> (# State# RealWorld, Array# ThreadId# #)
+  log1pDouble# :: Double# -> Double#
+  log1pFloat# :: Float# -> Float#
+  logDouble# :: Double# -> Double#
+  logFloat# :: Float# -> Float#
+  ltAddr# :: Addr# -> Addr# -> Int#
+  ltChar# :: Char# -> Char# -> Int#
+  ltFloat# :: Float# -> Float# -> Int#
+  ltInt16# :: Int16# -> Int16# -> Int#
+  ltInt32# :: Int32# -> Int32# -> Int#
+  ltInt64# :: Int64# -> Int64# -> Int#
+  ltInt8# :: Int8# -> Int8# -> Int#
+  ltWord# :: Word# -> Word# -> Int#
+  ltWord16# :: Word16# -> Word16# -> Int#
+  ltWord32# :: Word32# -> Word32# -> Int#
+  ltWord64# :: Word64# -> Word64# -> Int#
+  ltWord8# :: Word8# -> Word8# -> Int#
+  makeStableName# :: forall {l :: Levity} (a :: TYPE (BoxedRep l)). a -> State# RealWorld -> (# State# RealWorld, StableName# a #)
+  makeStablePtr# :: forall {l :: Levity} (a :: TYPE (BoxedRep l)). a -> State# RealWorld -> (# State# RealWorld, StablePtr# a #)
+  maskAsyncExceptions# :: forall {q :: RuntimeRep} (a :: TYPE q). (State# RealWorld -> (# State# RealWorld, a #)) -> State# RealWorld -> (# State# RealWorld, a #)
+  maskUninterruptible# :: forall {q :: RuntimeRep} (a :: TYPE q). (State# RealWorld -> (# State# RealWorld, a #)) -> State# RealWorld -> (# State# RealWorld, a #)
+  maxDouble# :: Double# -> Double# -> Double#
+  maxDoubleX2# :: DoubleX2# -> DoubleX2# -> DoubleX2#
+  maxDoubleX4# :: DoubleX4# -> DoubleX4# -> DoubleX4#
+  maxDoubleX8# :: DoubleX8# -> DoubleX8# -> DoubleX8#
+  maxFloat# :: Float# -> Float# -> Float#
+  maxFloatX16# :: FloatX16# -> FloatX16# -> FloatX16#
+  maxFloatX4# :: FloatX4# -> FloatX4# -> FloatX4#
+  maxFloatX8# :: FloatX8# -> FloatX8# -> FloatX8#
+  maxInt16X16# :: Int16X16# -> Int16X16# -> Int16X16#
+  maxInt16X32# :: Int16X32# -> Int16X32# -> Int16X32#
+  maxInt16X8# :: Int16X8# -> Int16X8# -> Int16X8#
+  maxInt32X16# :: Int32X16# -> Int32X16# -> Int32X16#
+  maxInt32X4# :: Int32X4# -> Int32X4# -> Int32X4#
+  maxInt32X8# :: Int32X8# -> Int32X8# -> Int32X8#
+  maxInt64X2# :: Int64X2# -> Int64X2# -> Int64X2#
+  maxInt64X4# :: Int64X4# -> Int64X4# -> Int64X4#
+  maxInt64X8# :: Int64X8# -> Int64X8# -> Int64X8#
+  maxInt8X16# :: Int8X16# -> Int8X16# -> Int8X16#
+  maxInt8X32# :: Int8X32# -> Int8X32# -> Int8X32#
+  maxInt8X64# :: Int8X64# -> Int8X64# -> Int8X64#
+  maxTupleSize :: Int
+  maxWord16X16# :: Word16X16# -> Word16X16# -> Word16X16#
+  maxWord16X32# :: Word16X32# -> Word16X32# -> Word16X32#
+  maxWord16X8# :: Word16X8# -> Word16X8# -> Word16X8#
+  maxWord32X16# :: Word32X16# -> Word32X16# -> Word32X16#
+  maxWord32X4# :: Word32X4# -> Word32X4# -> Word32X4#
+  maxWord32X8# :: Word32X8# -> Word32X8# -> Word32X8#
+  maxWord64X2# :: Word64X2# -> Word64X2# -> Word64X2#
+  maxWord64X4# :: Word64X4# -> Word64X4# -> Word64X4#
+  maxWord64X8# :: Word64X8# -> Word64X8# -> Word64X8#
+  maxWord8X16# :: Word8X16# -> Word8X16# -> Word8X16#
+  maxWord8X32# :: Word8X32# -> Word8X32# -> Word8X32#
+  maxWord8X64# :: Word8X64# -> Word8X64# -> Word8X64#
+  minDouble# :: Double# -> Double# -> Double#
+  minDoubleX2# :: DoubleX2# -> DoubleX2# -> DoubleX2#
+  minDoubleX4# :: DoubleX4# -> DoubleX4# -> DoubleX4#
+  minDoubleX8# :: DoubleX8# -> DoubleX8# -> DoubleX8#
+  minFloat# :: Float# -> Float# -> Float#
+  minFloatX16# :: FloatX16# -> FloatX16# -> FloatX16#
+  minFloatX4# :: FloatX4# -> FloatX4# -> FloatX4#
+  minFloatX8# :: FloatX8# -> FloatX8# -> FloatX8#
+  minInt16X16# :: Int16X16# -> Int16X16# -> Int16X16#
+  minInt16X32# :: Int16X32# -> Int16X32# -> Int16X32#
+  minInt16X8# :: Int16X8# -> Int16X8# -> Int16X8#
+  minInt32X16# :: Int32X16# -> Int32X16# -> Int32X16#
+  minInt32X4# :: Int32X4# -> Int32X4# -> Int32X4#
+  minInt32X8# :: Int32X8# -> Int32X8# -> Int32X8#
+  minInt64X2# :: Int64X2# -> Int64X2# -> Int64X2#
+  minInt64X4# :: Int64X4# -> Int64X4# -> Int64X4#
+  minInt64X8# :: Int64X8# -> Int64X8# -> Int64X8#
+  minInt8X16# :: Int8X16# -> Int8X16# -> Int8X16#
+  minInt8X32# :: Int8X32# -> Int8X32# -> Int8X32#
+  minInt8X64# :: Int8X64# -> Int8X64# -> Int8X64#
+  minWord16X16# :: Word16X16# -> Word16X16# -> Word16X16#
+  minWord16X32# :: Word16X32# -> Word16X32# -> Word16X32#
+  minWord16X8# :: Word16X8# -> Word16X8# -> Word16X8#
+  minWord32X16# :: Word32X16# -> Word32X16# -> Word32X16#
+  minWord32X4# :: Word32X4# -> Word32X4# -> Word32X4#
+  minWord32X8# :: Word32X8# -> Word32X8# -> Word32X8#
+  minWord64X2# :: Word64X2# -> Word64X2# -> Word64X2#
+  minWord64X4# :: Word64X4# -> Word64X4# -> Word64X4#
+  minWord64X8# :: Word64X8# -> Word64X8# -> Word64X8#
+  minWord8X16# :: Word8X16# -> Word8X16# -> Word8X16#
+  minWord8X32# :: Word8X32# -> Word8X32# -> Word8X32#
+  minWord8X64# :: Word8X64# -> Word8X64# -> Word8X64#
+  minusAddr# :: Addr# -> Addr# -> Int#
+  minusDoubleX2# :: DoubleX2# -> DoubleX2# -> DoubleX2#
+  minusDoubleX4# :: DoubleX4# -> DoubleX4# -> DoubleX4#
+  minusDoubleX8# :: DoubleX8# -> DoubleX8# -> DoubleX8#
+  minusFloat# :: Float# -> Float# -> Float#
+  minusFloatX16# :: FloatX16# -> FloatX16# -> FloatX16#
+  minusFloatX4# :: FloatX4# -> FloatX4# -> FloatX4#
+  minusFloatX8# :: FloatX8# -> FloatX8# -> FloatX8#
+  minusInt16X16# :: Int16X16# -> Int16X16# -> Int16X16#
+  minusInt16X32# :: Int16X32# -> Int16X32# -> Int16X32#
+  minusInt16X8# :: Int16X8# -> Int16X8# -> Int16X8#
+  minusInt32X16# :: Int32X16# -> Int32X16# -> Int32X16#
+  minusInt32X4# :: Int32X4# -> Int32X4# -> Int32X4#
+  minusInt32X8# :: Int32X8# -> Int32X8# -> Int32X8#
+  minusInt64X2# :: Int64X2# -> Int64X2# -> Int64X2#
+  minusInt64X4# :: Int64X4# -> Int64X4# -> Int64X4#
+  minusInt64X8# :: Int64X8# -> Int64X8# -> Int64X8#
+  minusInt8X16# :: Int8X16# -> Int8X16# -> Int8X16#
+  minusInt8X32# :: Int8X32# -> Int8X32# -> Int8X32#
+  minusInt8X64# :: Int8X64# -> Int8X64# -> Int8X64#
+  minusWord# :: Word# -> Word# -> Word#
+  minusWord16X16# :: Word16X16# -> Word16X16# -> Word16X16#
+  minusWord16X32# :: Word16X32# -> Word16X32# -> Word16X32#
+  minusWord16X8# :: Word16X8# -> Word16X8# -> Word16X8#
+  minusWord32X16# :: Word32X16# -> Word32X16# -> Word32X16#
+  minusWord32X4# :: Word32X4# -> Word32X4# -> Word32X4#
+  minusWord32X8# :: Word32X8# -> Word32X8# -> Word32X8#
+  minusWord64X2# :: Word64X2# -> Word64X2# -> Word64X2#
+  minusWord64X4# :: Word64X4# -> Word64X4# -> Word64X4#
+  minusWord64X8# :: Word64X8# -> Word64X8# -> Word64X8#
+  minusWord8X16# :: Word8X16# -> Word8X16# -> Word8X16#
+  minusWord8X32# :: Word8X32# -> Word8X32# -> Word8X32#
+  minusWord8X64# :: Word8X64# -> Word8X64# -> Word8X64#
+  mkApUpd0# :: forall a. BCO -> (# a #)
+  mkWeak# :: forall {l :: Levity} {k :: Levity} (a :: TYPE (BoxedRep l)) (b :: TYPE (BoxedRep k)) c. a -> b -> (State# RealWorld -> (# State# RealWorld, c #)) -> State# RealWorld -> (# State# RealWorld, Weak# b #)
+  mkWeakNoFinalizer# :: forall {l :: Levity} {k :: Levity} (a :: TYPE (BoxedRep l)) (b :: TYPE (BoxedRep k)). a -> b -> State# RealWorld -> (# State# RealWorld, Weak# b #)
+  mulIntMayOflo# :: Int# -> Int# -> Int#
+  mutableByteArrayContents# :: forall d. MutableByteArray# d -> Addr#
+  myThreadId# :: State# RealWorld -> (# State# RealWorld, ThreadId# #)
+  narrow16Int# :: Int# -> Int#
+  narrow16Word# :: Word# -> Word#
+  narrow32Int# :: Int# -> Int#
+  narrow32Word# :: Word# -> Word#
+  narrow8Int# :: Int# -> Int#
+  narrow8Word# :: Word# -> Word#
+  neAddr# :: Addr# -> Addr# -> Int#
+  neChar# :: Char# -> Char# -> Int#
+  neFloat# :: Float# -> Float# -> Int#
+  neInt16# :: Int16# -> Int16# -> Int#
+  neInt32# :: Int32# -> Int32# -> Int#
+  neInt64# :: Int64# -> Int64# -> Int#
+  neInt8# :: Int8# -> Int8# -> Int#
+  neWord# :: Word# -> Word# -> Int#
+  neWord16# :: Word16# -> Word16# -> Int#
+  neWord32# :: Word32# -> Word32# -> Int#
+  neWord64# :: Word64# -> Word64# -> Int#
+  neWord8# :: Word8# -> Word8# -> Int#
+  negateDouble# :: Double# -> Double#
+  negateDoubleX2# :: DoubleX2# -> DoubleX2#
+  negateDoubleX4# :: DoubleX4# -> DoubleX4#
+  negateDoubleX8# :: DoubleX8# -> DoubleX8#
+  negateFloat# :: Float# -> Float#
+  negateFloatX16# :: FloatX16# -> FloatX16#
+  negateFloatX4# :: FloatX4# -> FloatX4#
+  negateFloatX8# :: FloatX8# -> FloatX8#
+  negateInt# :: Int# -> Int#
+  negateInt16# :: Int16# -> Int16#
+  negateInt16X16# :: Int16X16# -> Int16X16#
+  negateInt16X32# :: Int16X32# -> Int16X32#
+  negateInt16X8# :: Int16X8# -> Int16X8#
+  negateInt32# :: Int32# -> Int32#
+  negateInt32X16# :: Int32X16# -> Int32X16#
+  negateInt32X4# :: Int32X4# -> Int32X4#
+  negateInt32X8# :: Int32X8# -> Int32X8#
+  negateInt64# :: Int64# -> Int64#
+  negateInt64X2# :: Int64X2# -> Int64X2#
+  negateInt64X4# :: Int64X4# -> Int64X4#
+  negateInt64X8# :: Int64X8# -> Int64X8#
+  negateInt8# :: Int8# -> Int8#
+  negateInt8X16# :: Int8X16# -> Int8X16#
+  negateInt8X32# :: Int8X32# -> Int8X32#
+  negateInt8X64# :: Int8X64# -> Int8X64#
+  newAlignedPinnedByteArray# :: forall d. Int# -> Int# -> State# d -> (# State# d, MutableByteArray# d #)
+  newArray# :: forall {l :: Levity} (a :: TYPE (BoxedRep l)) d. Int# -> a -> State# d -> (# State# d, MutableArray# d a #)
+  newArrayArray# :: forall s. Int# -> State# s -> (# State# s, MutableArrayArray# s #)
+  newBCO# :: forall a d. ByteArray# -> ByteArray# -> Array# a -> Int# -> ByteArray# -> State# d -> (# State# d, BCO #)
+  newByteArray# :: forall d. Int# -> State# d -> (# State# d, MutableByteArray# d #)
+  newIOPort# :: forall {l :: Levity} d (a :: TYPE (BoxedRep l)). State# d -> (# State# d, IOPort# d a #)
+  newMVar# :: forall {l :: Levity} d (a :: TYPE (BoxedRep l)). State# d -> (# State# d, MVar# d a #)
+  newMutVar# :: forall {l :: Levity} (a :: TYPE (BoxedRep l)) d. a -> State# d -> (# State# d, MutVar# d a #)
+  newPinnedByteArray# :: forall d. Int# -> State# d -> (# State# d, MutableByteArray# d #)
+  newPromptTag# :: forall a. State# RealWorld -> (# State# RealWorld, PromptTag# a #)
+  newSmallArray# :: forall {l :: Levity} (a :: TYPE (BoxedRep l)) d. Int# -> a -> State# d -> (# State# d, SmallMutableArray# d a #)
+  newTVar# :: forall {l :: Levity} (a :: TYPE (BoxedRep l)) d. a -> State# d -> (# State# d, TVar# d a #)
+  noDuplicate# :: forall d. State# d -> State# d
+  noinline :: forall a. a -> a
+  not# :: Word# -> Word#
+  not64# :: Word64# -> Word64#
+  notI# :: Int# -> Int#
+  notWord16# :: Word16# -> Word16#
+  notWord32# :: Word32# -> Word32#
+  notWord8# :: Word8# -> Word8#
+  nullAddr# :: Addr#
+  numSparks# :: forall d. State# d -> (# State# d, Int# #)
+  oneShot :: forall {q :: RuntimeRep} {r :: RuntimeRep} (a :: TYPE q) (b :: TYPE r). (a -> b) -> a -> b
+  or# :: Word# -> Word# -> Word#
+  or64# :: Word64# -> Word64# -> Word64#
+  orI# :: Int# -> Int# -> Int#
+  orWord16# :: Word16# -> Word16# -> Word16#
+  orWord32# :: Word32# -> Word32# -> Word32#
+  orWord8# :: Word8# -> Word8# -> Word8#
+  ord# :: Char# -> Int#
+  packDoubleX2# :: (# Double#, Double# #) -> DoubleX2#
+  packDoubleX4# :: (# Double#, Double#, Double#, Double# #) -> DoubleX4#
+  packDoubleX8# :: (# Double#, Double#, Double#, Double#, Double#, Double#, Double#, Double# #) -> DoubleX8#
+  packFloatX16# :: (# Float#, Float#, Float#, Float#, Float#, Float#, Float#, Float#, Float#, Float#, Float#, Float#, Float#, Float#, Float#, Float# #) -> FloatX16#
+  packFloatX4# :: (# Float#, Float#, Float#, Float# #) -> FloatX4#
+  packFloatX8# :: (# Float#, Float#, Float#, Float#, Float#, Float#, Float#, Float# #) -> FloatX8#
+  packInt16X16# :: (# Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16# #) -> Int16X16#
+  packInt16X32# :: (# Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16# #) -> Int16X32#
+  packInt16X8# :: (# Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16# #) -> Int16X8#
+  packInt32X16# :: (# Int32#, Int32#, Int32#, Int32#, Int32#, Int32#, Int32#, Int32#, Int32#, Int32#, Int32#, Int32#, Int32#, Int32#, Int32#, Int32# #) -> Int32X16#
+  packInt32X4# :: (# Int32#, Int32#, Int32#, Int32# #) -> Int32X4#
+  packInt32X8# :: (# Int32#, Int32#, Int32#, Int32#, Int32#, Int32#, Int32#, Int32# #) -> Int32X8#
+  packInt64X2# :: (# Int64#, Int64# #) -> Int64X2#
+  packInt64X4# :: (# Int64#, Int64#, Int64#, Int64# #) -> Int64X4#
+  packInt64X8# :: (# Int64#, Int64#, Int64#, Int64#, Int64#, Int64#, Int64#, Int64# #) -> Int64X8#
+  packInt8X16# :: (# Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8# #) -> Int8X16#
+  packInt8X32# :: (# Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8# #) -> Int8X32#
+  packInt8X64# :: (# Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8# #) -> Int8X64#
+  packWord16X16# :: (# Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16# #) -> Word16X16#
+  packWord16X32# :: (# Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16# #) -> Word16X32#
+  packWord16X8# :: (# Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16# #) -> Word16X8#
+  packWord32X16# :: (# Word32#, Word32#, Word32#, Word32#, Word32#, Word32#, Word32#, Word32#, Word32#, Word32#, Word32#, Word32#, Word32#, Word32#, Word32#, Word32# #) -> Word32X16#
+  packWord32X4# :: (# Word32#, Word32#, Word32#, Word32# #) -> Word32X4#
+  packWord32X8# :: (# Word32#, Word32#, Word32#, Word32#, Word32#, Word32#, Word32#, Word32# #) -> Word32X8#
+  packWord64X2# :: (# Word64#, Word64# #) -> Word64X2#
+  packWord64X4# :: (# Word64#, Word64#, Word64#, Word64# #) -> Word64X4#
+  packWord64X8# :: (# Word64#, Word64#, Word64#, Word64#, Word64#, Word64#, Word64#, Word64# #) -> Word64X8#
+  packWord8X16# :: (# Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8# #) -> Word8X16#
+  packWord8X32# :: (# Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8# #) -> Word8X32#
+  packWord8X64# :: (# Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8# #) -> Word8X64#
+  par# :: forall a. a -> Int#
+  pdep# :: Word# -> Word# -> Word#
+  pdep16# :: Word# -> Word# -> Word#
+  pdep32# :: Word# -> Word# -> Word#
+  pdep64# :: Word64# -> Word64# -> Word64#
+  pdep8# :: Word# -> Word# -> Word#
+  pext# :: Word# -> Word# -> Word#
+  pext16# :: Word# -> Word# -> Word#
+  pext32# :: Word# -> Word# -> Word#
+  pext64# :: Word64# -> Word64# -> Word64#
+  pext8# :: Word# -> Word# -> Word#
+  plusAddr# :: Addr# -> Int# -> Addr#
+  plusDoubleX2# :: DoubleX2# -> DoubleX2# -> DoubleX2#
+  plusDoubleX4# :: DoubleX4# -> DoubleX4# -> DoubleX4#
+  plusDoubleX8# :: DoubleX8# -> DoubleX8# -> DoubleX8#
+  plusFloat# :: Float# -> Float# -> Float#
+  plusFloatX16# :: FloatX16# -> FloatX16# -> FloatX16#
+  plusFloatX4# :: FloatX4# -> FloatX4# -> FloatX4#
+  plusFloatX8# :: FloatX8# -> FloatX8# -> FloatX8#
+  plusInt16# :: Int16# -> Int16# -> Int16#
+  plusInt16X16# :: Int16X16# -> Int16X16# -> Int16X16#
+  plusInt16X32# :: Int16X32# -> Int16X32# -> Int16X32#
+  plusInt16X8# :: Int16X8# -> Int16X8# -> Int16X8#
+  plusInt32# :: Int32# -> Int32# -> Int32#
+  plusInt32X16# :: Int32X16# -> Int32X16# -> Int32X16#
+  plusInt32X4# :: Int32X4# -> Int32X4# -> Int32X4#
+  plusInt32X8# :: Int32X8# -> Int32X8# -> Int32X8#
+  plusInt64# :: Int64# -> Int64# -> Int64#
+  plusInt64X2# :: Int64X2# -> Int64X2# -> Int64X2#
+  plusInt64X4# :: Int64X4# -> Int64X4# -> Int64X4#
+  plusInt64X8# :: Int64X8# -> Int64X8# -> Int64X8#
+  plusInt8# :: Int8# -> Int8# -> Int8#
+  plusInt8X16# :: Int8X16# -> Int8X16# -> Int8X16#
+  plusInt8X32# :: Int8X32# -> Int8X32# -> Int8X32#
+  plusInt8X64# :: Int8X64# -> Int8X64# -> Int8X64#
+  plusWord# :: Word# -> Word# -> Word#
+  plusWord16# :: Word16# -> Word16# -> Word16#
+  plusWord16X16# :: Word16X16# -> Word16X16# -> Word16X16#
+  plusWord16X32# :: Word16X32# -> Word16X32# -> Word16X32#
+  plusWord16X8# :: Word16X8# -> Word16X8# -> Word16X8#
+  plusWord2# :: Word# -> Word# -> (# Word#, Word# #)
+  plusWord32# :: Word32# -> Word32# -> Word32#
+  plusWord32X16# :: Word32X16# -> Word32X16# -> Word32X16#
+  plusWord32X4# :: Word32X4# -> Word32X4# -> Word32X4#
+  plusWord32X8# :: Word32X8# -> Word32X8# -> Word32X8#
+  plusWord64# :: Word64# -> Word64# -> Word64#
+  plusWord64X2# :: Word64X2# -> Word64X2# -> Word64X2#
+  plusWord64X4# :: Word64X4# -> Word64X4# -> Word64X4#
+  plusWord64X8# :: Word64X8# -> Word64X8# -> Word64X8#
+  plusWord8# :: Word8# -> Word8# -> Word8#
+  plusWord8X16# :: Word8X16# -> Word8X16# -> Word8X16#
+  plusWord8X32# :: Word8X32# -> Word8X32# -> Word8X32#
+  plusWord8X64# :: Word8X64# -> Word8X64# -> Word8X64#
+  popCnt# :: Word# -> Word#
+  popCnt16# :: Word# -> Word#
+  popCnt32# :: Word# -> Word#
+  popCnt64# :: Word64# -> Word#
+  popCnt8# :: Word# -> Word#
+  powerFloat# :: Float# -> Float# -> Float#
+  prefetchAddr0# :: forall d. Addr# -> Int# -> State# d -> State# d
+  prefetchAddr1# :: forall d. Addr# -> Int# -> State# d -> State# d
+  prefetchAddr2# :: forall d. Addr# -> Int# -> State# d -> State# d
+  prefetchAddr3# :: forall d. Addr# -> Int# -> State# d -> State# d
+  prefetchByteArray0# :: forall d. ByteArray# -> Int# -> State# d -> State# d
+  prefetchByteArray1# :: forall d. ByteArray# -> Int# -> State# d -> State# d
+  prefetchByteArray2# :: forall d. ByteArray# -> Int# -> State# d -> State# d
+  prefetchByteArray3# :: forall d. ByteArray# -> Int# -> State# d -> State# d
+  prefetchMutableByteArray0# :: forall d. MutableByteArray# d -> Int# -> State# d -> State# d
+  prefetchMutableByteArray1# :: forall d. MutableByteArray# d -> Int# -> State# d -> State# d
+  prefetchMutableByteArray2# :: forall d. MutableByteArray# d -> Int# -> State# d -> State# d
+  prefetchMutableByteArray3# :: forall d. MutableByteArray# d -> Int# -> State# d -> State# d
+  prefetchValue0# :: forall a d. a -> State# d -> State# d
+  prefetchValue1# :: forall a d. a -> State# d -> State# d
+  prefetchValue2# :: forall a d. a -> State# d -> State# d
+  prefetchValue3# :: forall a d. a -> State# d -> State# d
+  prompt# :: forall a. PromptTag# a -> (State# RealWorld -> (# State# RealWorld, a #)) -> State# RealWorld -> (# State# RealWorld, a #)
+  proxy# :: forall {k} (a :: k). Proxy# a
+  putMVar# :: forall {l :: Levity} d (a :: TYPE (BoxedRep l)). MVar# d a -> a -> State# d -> State# d
+  quotInt# :: Int# -> Int# -> Int#
+  quotInt16# :: Int16# -> Int16# -> Int16#
+  quotInt16X16# :: Int16X16# -> Int16X16# -> Int16X16#
+  quotInt16X32# :: Int16X32# -> Int16X32# -> Int16X32#
+  quotInt16X8# :: Int16X8# -> Int16X8# -> Int16X8#
+  quotInt32# :: Int32# -> Int32# -> Int32#
+  quotInt32X16# :: Int32X16# -> Int32X16# -> Int32X16#
+  quotInt32X4# :: Int32X4# -> Int32X4# -> Int32X4#
+  quotInt32X8# :: Int32X8# -> Int32X8# -> Int32X8#
+  quotInt64# :: Int64# -> Int64# -> Int64#
+  quotInt64X2# :: Int64X2# -> Int64X2# -> Int64X2#
+  quotInt64X4# :: Int64X4# -> Int64X4# -> Int64X4#
+  quotInt64X8# :: Int64X8# -> Int64X8# -> Int64X8#
+  quotInt8# :: Int8# -> Int8# -> Int8#
+  quotInt8X16# :: Int8X16# -> Int8X16# -> Int8X16#
+  quotInt8X32# :: Int8X32# -> Int8X32# -> Int8X32#
+  quotInt8X64# :: Int8X64# -> Int8X64# -> Int8X64#
+  quotRemInt# :: Int# -> Int# -> (# Int#, Int# #)
+  quotRemInt16# :: Int16# -> Int16# -> (# Int16#, Int16# #)
+  quotRemInt32# :: Int32# -> Int32# -> (# Int32#, Int32# #)
+  quotRemInt8# :: Int8# -> Int8# -> (# Int8#, Int8# #)
+  quotRemWord# :: Word# -> Word# -> (# Word#, Word# #)
+  quotRemWord16# :: Word16# -> Word16# -> (# Word16#, Word16# #)
+  quotRemWord2# :: Word# -> Word# -> Word# -> (# Word#, Word# #)
+  quotRemWord32# :: Word32# -> Word32# -> (# Word32#, Word32# #)
+  quotRemWord8# :: Word8# -> Word8# -> (# Word8#, Word8# #)
+  quotWord# :: Word# -> Word# -> Word#
+  quotWord16# :: Word16# -> Word16# -> Word16#
+  quotWord16X16# :: Word16X16# -> Word16X16# -> Word16X16#
+  quotWord16X32# :: Word16X32# -> Word16X32# -> Word16X32#
+  quotWord16X8# :: Word16X8# -> Word16X8# -> Word16X8#
+  quotWord32# :: Word32# -> Word32# -> Word32#
+  quotWord32X16# :: Word32X16# -> Word32X16# -> Word32X16#
+  quotWord32X4# :: Word32X4# -> Word32X4# -> Word32X4#
+  quotWord32X8# :: Word32X8# -> Word32X8# -> Word32X8#
+  quotWord64# :: Word64# -> Word64# -> Word64#
+  quotWord64X2# :: Word64X2# -> Word64X2# -> Word64X2#
+  quotWord64X4# :: Word64X4# -> Word64X4# -> Word64X4#
+  quotWord64X8# :: Word64X8# -> Word64X8# -> Word64X8#
+  quotWord8# :: Word8# -> Word8# -> Word8#
+  quotWord8X16# :: Word8X16# -> Word8X16# -> Word8X16#
+  quotWord8X32# :: Word8X32# -> Word8X32# -> Word8X32#
+  quotWord8X64# :: Word8X64# -> Word8X64# -> Word8X64#
+  raise# :: forall {l :: Levity} {r :: RuntimeRep} (a :: TYPE (BoxedRep l)) (b :: TYPE r). a -> b
+  raiseDivZero# :: forall {r :: RuntimeRep} (b :: TYPE r). (# #) -> b
+  raiseIO# :: forall {l :: Levity} {r :: RuntimeRep} (a :: TYPE (BoxedRep l)) (b :: TYPE r). a -> State# RealWorld -> (# State# RealWorld, b #)
+  raiseOverflow# :: forall {r :: RuntimeRep} (b :: TYPE r). (# #) -> b
+  raiseUnderflow# :: forall {r :: RuntimeRep} (b :: TYPE r). (# #) -> b
+  readAddrArray# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Addr# #)
+  readAddrOffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Addr# #)
+  readArray# :: forall {l :: Levity} d (a :: TYPE (BoxedRep l)). MutableArray# d a -> Int# -> State# d -> (# State# d, a #)
+  readArrayArrayArray# :: forall s. MutableArrayArray# s -> Int# -> State# s -> (# State# s, ArrayArray# #)
+  readByteArrayArray# :: forall s. MutableArrayArray# s -> Int# -> State# s -> (# State# s, ByteArray# #)
+  readCharArray# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Char# #)
+  readCharOffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Char# #)
+  readDoubleArray# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Double# #)
+  readDoubleArrayAsDoubleX2# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, DoubleX2# #)
+  readDoubleArrayAsDoubleX4# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, DoubleX4# #)
+  readDoubleArrayAsDoubleX8# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, DoubleX8# #)
+  readDoubleOffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Double# #)
+  readDoubleOffAddrAsDoubleX2# :: forall d. Addr# -> Int# -> State# d -> (# State# d, DoubleX2# #)
+  readDoubleOffAddrAsDoubleX4# :: forall d. Addr# -> Int# -> State# d -> (# State# d, DoubleX4# #)
+  readDoubleOffAddrAsDoubleX8# :: forall d. Addr# -> Int# -> State# d -> (# State# d, DoubleX8# #)
+  readDoubleX2Array# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, DoubleX2# #)
+  readDoubleX2OffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, DoubleX2# #)
+  readDoubleX4Array# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, DoubleX4# #)
+  readDoubleX4OffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, DoubleX4# #)
+  readDoubleX8Array# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, DoubleX8# #)
+  readDoubleX8OffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, DoubleX8# #)
+  readFloatArray# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Float# #)
+  readFloatArrayAsFloatX16# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, FloatX16# #)
+  readFloatArrayAsFloatX4# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, FloatX4# #)
+  readFloatArrayAsFloatX8# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, FloatX8# #)
+  readFloatOffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Float# #)
+  readFloatOffAddrAsFloatX16# :: forall d. Addr# -> Int# -> State# d -> (# State# d, FloatX16# #)
+  readFloatOffAddrAsFloatX4# :: forall d. Addr# -> Int# -> State# d -> (# State# d, FloatX4# #)
+  readFloatOffAddrAsFloatX8# :: forall d. Addr# -> Int# -> State# d -> (# State# d, FloatX8# #)
+  readFloatX16Array# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, FloatX16# #)
+  readFloatX16OffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, FloatX16# #)
+  readFloatX4Array# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, FloatX4# #)
+  readFloatX4OffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, FloatX4# #)
+  readFloatX8Array# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, FloatX8# #)
+  readFloatX8OffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, FloatX8# #)
+  readIOPort# :: forall {l :: Levity} d (a :: TYPE (BoxedRep l)). IOPort# d a -> State# d -> (# State# d, a #)
+  readInt16Array# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Int16# #)
+  readInt16ArrayAsInt16X16# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Int16X16# #)
+  readInt16ArrayAsInt16X32# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Int16X32# #)
+  readInt16ArrayAsInt16X8# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Int16X8# #)
+  readInt16OffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Int16# #)
+  readInt16OffAddrAsInt16X16# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Int16X16# #)
+  readInt16OffAddrAsInt16X32# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Int16X32# #)
+  readInt16OffAddrAsInt16X8# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Int16X8# #)
+  readInt16X16Array# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Int16X16# #)
+  readInt16X16OffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Int16X16# #)
+  readInt16X32Array# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Int16X32# #)
+  readInt16X32OffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Int16X32# #)
+  readInt16X8Array# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Int16X8# #)
+  readInt16X8OffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Int16X8# #)
+  readInt32Array# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Int32# #)
+  readInt32ArrayAsInt32X16# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Int32X16# #)
+  readInt32ArrayAsInt32X4# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Int32X4# #)
+  readInt32ArrayAsInt32X8# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Int32X8# #)
+  readInt32OffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Int32# #)
+  readInt32OffAddrAsInt32X16# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Int32X16# #)
+  readInt32OffAddrAsInt32X4# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Int32X4# #)
+  readInt32OffAddrAsInt32X8# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Int32X8# #)
+  readInt32X16Array# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Int32X16# #)
+  readInt32X16OffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Int32X16# #)
+  readInt32X4Array# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Int32X4# #)
+  readInt32X4OffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Int32X4# #)
+  readInt32X8Array# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Int32X8# #)
+  readInt32X8OffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Int32X8# #)
+  readInt64Array# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Int64# #)
+  readInt64ArrayAsInt64X2# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Int64X2# #)
+  readInt64ArrayAsInt64X4# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Int64X4# #)
+  readInt64ArrayAsInt64X8# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Int64X8# #)
+  readInt64OffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Int64# #)
+  readInt64OffAddrAsInt64X2# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Int64X2# #)
+  readInt64OffAddrAsInt64X4# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Int64X4# #)
+  readInt64OffAddrAsInt64X8# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Int64X8# #)
+  readInt64X2Array# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Int64X2# #)
+  readInt64X2OffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Int64X2# #)
+  readInt64X4Array# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Int64X4# #)
+  readInt64X4OffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Int64X4# #)
+  readInt64X8Array# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Int64X8# #)
+  readInt64X8OffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Int64X8# #)
+  readInt8Array# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Int8# #)
+  readInt8ArrayAsInt8X16# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Int8X16# #)
+  readInt8ArrayAsInt8X32# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Int8X32# #)
+  readInt8ArrayAsInt8X64# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Int8X64# #)
+  readInt8OffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Int8# #)
+  readInt8OffAddrAsInt8X16# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Int8X16# #)
+  readInt8OffAddrAsInt8X32# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Int8X32# #)
+  readInt8OffAddrAsInt8X64# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Int8X64# #)
+  readInt8X16Array# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Int8X16# #)
+  readInt8X16OffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Int8X16# #)
+  readInt8X32Array# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Int8X32# #)
+  readInt8X32OffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Int8X32# #)
+  readInt8X64Array# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Int8X64# #)
+  readInt8X64OffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Int8X64# #)
+  readIntArray# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Int# #)
+  readIntOffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Int# #)
+  readMVar# :: forall {l :: Levity} d (a :: TYPE (BoxedRep l)). MVar# d a -> State# d -> (# State# d, a #)
+  readMutVar# :: forall {l :: Levity} d (a :: TYPE (BoxedRep l)). MutVar# d a -> State# d -> (# State# d, a #)
+  readMutableArrayArrayArray# :: forall s. MutableArrayArray# s -> Int# -> State# s -> (# State# s, MutableArrayArray# s #)
+  readMutableByteArrayArray# :: forall s. MutableArrayArray# s -> Int# -> State# s -> (# State# s, MutableByteArray# s #)
+  readSmallArray# :: forall {l :: Levity} d (a :: TYPE (BoxedRep l)). SmallMutableArray# d a -> Int# -> State# d -> (# State# d, a #)
+  readStablePtrArray# :: forall d a. MutableByteArray# d -> Int# -> State# d -> (# State# d, StablePtr# a #)
+  readStablePtrOffAddr# :: forall d a. Addr# -> Int# -> State# d -> (# State# d, StablePtr# a #)
+  readTVar# :: forall {l :: Levity} d (a :: TYPE (BoxedRep l)). TVar# d a -> State# d -> (# State# d, a #)
+  readTVarIO# :: forall {l :: Levity} d (a :: TYPE (BoxedRep l)). TVar# d a -> State# d -> (# State# d, a #)
+  readWideCharArray# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Char# #)
+  readWideCharOffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Char# #)
+  readWord16Array# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Word16# #)
+  readWord16ArrayAsWord16X16# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Word16X16# #)
+  readWord16ArrayAsWord16X32# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Word16X32# #)
+  readWord16ArrayAsWord16X8# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Word16X8# #)
+  readWord16OffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Word16# #)
+  readWord16OffAddrAsWord16X16# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Word16X16# #)
+  readWord16OffAddrAsWord16X32# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Word16X32# #)
+  readWord16OffAddrAsWord16X8# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Word16X8# #)
+  readWord16X16Array# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Word16X16# #)
+  readWord16X16OffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Word16X16# #)
+  readWord16X32Array# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Word16X32# #)
+  readWord16X32OffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Word16X32# #)
+  readWord16X8Array# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Word16X8# #)
+  readWord16X8OffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Word16X8# #)
+  readWord32Array# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Word32# #)
+  readWord32ArrayAsWord32X16# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Word32X16# #)
+  readWord32ArrayAsWord32X4# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Word32X4# #)
+  readWord32ArrayAsWord32X8# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Word32X8# #)
+  readWord32OffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Word32# #)
+  readWord32OffAddrAsWord32X16# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Word32X16# #)
+  readWord32OffAddrAsWord32X4# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Word32X4# #)
+  readWord32OffAddrAsWord32X8# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Word32X8# #)
+  readWord32X16Array# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Word32X16# #)
+  readWord32X16OffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Word32X16# #)
+  readWord32X4Array# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Word32X4# #)
+  readWord32X4OffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Word32X4# #)
+  readWord32X8Array# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Word32X8# #)
+  readWord32X8OffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Word32X8# #)
+  readWord64Array# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Word64# #)
+  readWord64ArrayAsWord64X2# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Word64X2# #)
+  readWord64ArrayAsWord64X4# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Word64X4# #)
+  readWord64ArrayAsWord64X8# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Word64X8# #)
+  readWord64OffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Word64# #)
+  readWord64OffAddrAsWord64X2# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Word64X2# #)
+  readWord64OffAddrAsWord64X4# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Word64X4# #)
+  readWord64OffAddrAsWord64X8# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Word64X8# #)
+  readWord64X2Array# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Word64X2# #)
+  readWord64X2OffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Word64X2# #)
+  readWord64X4Array# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Word64X4# #)
+  readWord64X4OffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Word64X4# #)
+  readWord64X8Array# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Word64X8# #)
+  readWord64X8OffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Word64X8# #)
+  readWord8Array# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Word8# #)
+  readWord8ArrayAsAddr# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Addr# #)
+  readWord8ArrayAsChar# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Char# #)
+  readWord8ArrayAsDouble# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Double# #)
+  readWord8ArrayAsFloat# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Float# #)
+  readWord8ArrayAsInt# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Int# #)
+  readWord8ArrayAsInt16# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Int16# #)
+  readWord8ArrayAsInt32# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Int32# #)
+  readWord8ArrayAsInt64# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Int64# #)
+  readWord8ArrayAsStablePtr# :: forall d a. MutableByteArray# d -> Int# -> State# d -> (# State# d, StablePtr# a #)
+  readWord8ArrayAsWideChar# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Char# #)
+  readWord8ArrayAsWord# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Word# #)
+  readWord8ArrayAsWord16# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Word16# #)
+  readWord8ArrayAsWord32# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Word32# #)
+  readWord8ArrayAsWord64# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Word64# #)
+  readWord8ArrayAsWord8X16# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Word8X16# #)
+  readWord8ArrayAsWord8X32# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Word8X32# #)
+  readWord8ArrayAsWord8X64# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Word8X64# #)
+  readWord8OffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Word8# #)
+  readWord8OffAddrAsAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Addr# #)
+  readWord8OffAddrAsChar# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Char# #)
+  readWord8OffAddrAsDouble# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Double# #)
+  readWord8OffAddrAsFloat# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Float# #)
+  readWord8OffAddrAsInt# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Int# #)
+  readWord8OffAddrAsInt16# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Int16# #)
+  readWord8OffAddrAsInt32# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Int32# #)
+  readWord8OffAddrAsInt64# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Int64# #)
+  readWord8OffAddrAsStablePtr# :: forall d a. Addr# -> Int# -> State# d -> (# State# d, StablePtr# a #)
+  readWord8OffAddrAsWideChar# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Char# #)
+  readWord8OffAddrAsWord# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Word# #)
+  readWord8OffAddrAsWord16# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Word16# #)
+  readWord8OffAddrAsWord32# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Word32# #)
+  readWord8OffAddrAsWord64# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Word64# #)
+  readWord8OffAddrAsWord8X16# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Word8X16# #)
+  readWord8OffAddrAsWord8X32# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Word8X32# #)
+  readWord8OffAddrAsWord8X64# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Word8X64# #)
+  readWord8X16Array# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Word8X16# #)
+  readWord8X16OffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Word8X16# #)
+  readWord8X32Array# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Word8X32# #)
+  readWord8X32OffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Word8X32# #)
+  readWord8X64Array# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Word8X64# #)
+  readWord8X64OffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Word8X64# #)
+  readWordArray# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Word# #)
+  readWordOffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Word# #)
+  realWorld# :: State# RealWorld
+  reallyUnsafePtrEquality :: forall a. a -> a -> Int#
+  reallyUnsafePtrEquality# :: forall {l :: Levity} {k :: Levity} (a :: TYPE (BoxedRep l)) (b :: TYPE (BoxedRep k)). a -> b -> Int#
+  remAddr# :: Addr# -> Int# -> Int#
+  remInt# :: Int# -> Int# -> Int#
+  remInt16# :: Int16# -> Int16# -> Int16#
+  remInt16X16# :: Int16X16# -> Int16X16# -> Int16X16#
+  remInt16X32# :: Int16X32# -> Int16X32# -> Int16X32#
+  remInt16X8# :: Int16X8# -> Int16X8# -> Int16X8#
+  remInt32# :: Int32# -> Int32# -> Int32#
+  remInt32X16# :: Int32X16# -> Int32X16# -> Int32X16#
+  remInt32X4# :: Int32X4# -> Int32X4# -> Int32X4#
+  remInt32X8# :: Int32X8# -> Int32X8# -> Int32X8#
+  remInt64# :: Int64# -> Int64# -> Int64#
+  remInt64X2# :: Int64X2# -> Int64X2# -> Int64X2#
+  remInt64X4# :: Int64X4# -> Int64X4# -> Int64X4#
+  remInt64X8# :: Int64X8# -> Int64X8# -> Int64X8#
+  remInt8# :: Int8# -> Int8# -> Int8#
+  remInt8X16# :: Int8X16# -> Int8X16# -> Int8X16#
+  remInt8X32# :: Int8X32# -> Int8X32# -> Int8X32#
+  remInt8X64# :: Int8X64# -> Int8X64# -> Int8X64#
+  remWord# :: Word# -> Word# -> Word#
+  remWord16# :: Word16# -> Word16# -> Word16#
+  remWord16X16# :: Word16X16# -> Word16X16# -> Word16X16#
+  remWord16X32# :: Word16X32# -> Word16X32# -> Word16X32#
+  remWord16X8# :: Word16X8# -> Word16X8# -> Word16X8#
+  remWord32# :: Word32# -> Word32# -> Word32#
+  remWord32X16# :: Word32X16# -> Word32X16# -> Word32X16#
+  remWord32X4# :: Word32X4# -> Word32X4# -> Word32X4#
+  remWord32X8# :: Word32X8# -> Word32X8# -> Word32X8#
+  remWord64# :: Word64# -> Word64# -> Word64#
+  remWord64X2# :: Word64X2# -> Word64X2# -> Word64X2#
+  remWord64X4# :: Word64X4# -> Word64X4# -> Word64X4#
+  remWord64X8# :: Word64X8# -> Word64X8# -> Word64X8#
+  remWord8# :: Word8# -> Word8# -> Word8#
+  remWord8X16# :: Word8X16# -> Word8X16# -> Word8X16#
+  remWord8X32# :: Word8X32# -> Word8X32# -> Word8X32#
+  remWord8X64# :: Word8X64# -> Word8X64# -> Word8X64#
+  resizeMutableByteArray# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, MutableByteArray# d #)
+  resizeSmallMutableArray# :: forall s a. SmallMutableArray# s a -> Int# -> a -> State# s -> (# State# s, SmallMutableArray# s a #)
+  retry# :: forall {l :: Levity} (a :: TYPE (BoxedRep l)). State# RealWorld -> (# State# RealWorld, a #)
+  rightSection :: forall {q :: RuntimeRep} {r :: RuntimeRep} {s :: RuntimeRep} (a :: TYPE q) (b :: TYPE r) (c :: TYPE s). (a -> b -> c) -> b -> a -> c
+  runRW# :: forall (r :: RuntimeRep) (o :: TYPE r). (State# RealWorld -> o) -> o
+  sameArray# :: forall {l :: Levity} (a :: TYPE (BoxedRep l)). Array# a -> Array# a -> Int#
+  sameArrayArray# :: ArrayArray# -> ArrayArray# -> Int#
+  sameByteArray# :: ByteArray# -> ByteArray# -> Int#
+  sameIOPort# :: forall {l :: Levity} s (a :: TYPE (BoxedRep l)). IOPort# s a -> IOPort# s a -> Int#
+  sameMVar# :: forall {l :: Levity} s (a :: TYPE (BoxedRep l)). MVar# s a -> MVar# s a -> Int#
+  sameMutVar# :: forall {l :: Levity} s (a :: TYPE (BoxedRep l)). MutVar# s a -> MutVar# s a -> Int#
+  sameMutableArray# :: forall {l :: Levity} s (a :: TYPE (BoxedRep l)). MutableArray# s a -> MutableArray# s a -> Int#
+  sameMutableArrayArray# :: forall s. MutableArrayArray# s -> MutableArrayArray# s -> Int#
+  sameMutableByteArray# :: forall s. MutableByteArray# s -> MutableByteArray# s -> Int#
+  samePromptTag# :: forall a. PromptTag# a -> PromptTag# a -> Int#
+  sameSmallArray# :: forall {l :: Levity} (a :: TYPE (BoxedRep l)). SmallArray# a -> SmallArray# a -> Int#
+  sameSmallMutableArray# :: forall {l :: Levity} s (a :: TYPE (BoxedRep l)). SmallMutableArray# s a -> SmallMutableArray# s a -> Int#
+  sameTVar# :: forall {l :: Levity} s (a :: TYPE (BoxedRep l)). TVar# s a -> TVar# s a -> Int#
+  seq :: forall {r :: RuntimeRep} a (b :: TYPE r). a -> b -> b
+  seq# :: forall a s. a -> State# s -> (# State# s, a #)
+  setAddrRange# :: Addr# -> Int# -> Int# -> State# RealWorld -> State# RealWorld
+  setByteArray# :: forall d. MutableByteArray# d -> Int# -> Int# -> Int# -> State# d -> State# d
+  setThreadAllocationCounter# :: Int64# -> State# RealWorld -> State# RealWorld
+  shiftL# :: Word# -> Int# -> Word#
+  shiftRL# :: Word# -> Int# -> Word#
+  shrinkMutableByteArray# :: forall d. MutableByteArray# d -> Int# -> State# d -> State# d
+  shrinkSmallMutableArray# :: forall {l :: Levity} d (a :: TYPE (BoxedRep l)). SmallMutableArray# d a -> Int# -> State# d -> State# d
+  shuffleDoubleX2# :: DoubleX2# -> DoubleX2# -> (# Int#, Int# #) -> DoubleX2#
+  shuffleDoubleX4# :: DoubleX4# -> DoubleX4# -> (# Int#, Int#, Int#, Int# #) -> DoubleX4#
+  shuffleDoubleX8# :: DoubleX8# -> DoubleX8# -> (# Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int# #) -> DoubleX8#
+  shuffleFloatX16# :: FloatX16# -> FloatX16# -> (# Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int# #) -> FloatX16#
+  shuffleFloatX4# :: FloatX4# -> FloatX4# -> (# Int#, Int#, Int#, Int# #) -> FloatX4#
+  shuffleFloatX8# :: FloatX8# -> FloatX8# -> (# Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int# #) -> FloatX8#
+  shuffleInt16X16# :: Int16X16# -> Int16X16# -> (# Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int# #) -> Int16X16#
+  shuffleInt16X32# :: Int16X32# -> Int16X32# -> (# Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int# #) -> Int16X32#
+  shuffleInt16X8# :: Int16X8# -> Int16X8# -> (# Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int# #) -> Int16X8#
+  shuffleInt32X16# :: Int32X16# -> Int32X16# -> (# Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int# #) -> Int32X16#
+  shuffleInt32X4# :: Int32X4# -> Int32X4# -> (# Int#, Int#, Int#, Int# #) -> Int32X4#
+  shuffleInt32X8# :: Int32X8# -> Int32X8# -> (# Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int# #) -> Int32X8#
+  shuffleInt64X2# :: Int64X2# -> Int64X2# -> (# Int#, Int# #) -> Int64X2#
+  shuffleInt64X4# :: Int64X4# -> Int64X4# -> (# Int#, Int#, Int#, Int# #) -> Int64X4#
+  shuffleInt64X8# :: Int64X8# -> Int64X8# -> (# Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int# #) -> Int64X8#
+  shuffleInt8X16# :: Int8X16# -> Int8X16# -> (# Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int# #) -> Int8X16#
+  shuffleInt8X32# :: Int8X32# -> Int8X32# -> (# Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int# #) -> Int8X32#
+  shuffleInt8X64# :: Int8X64# -> Int8X64# -> (# Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int# #) -> Int8X64#
+  shuffleWord16X16# :: Word16X16# -> Word16X16# -> (# Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int# #) -> Word16X16#
+  shuffleWord16X32# :: Word16X32# -> Word16X32# -> (# Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int# #) -> Word16X32#
+  shuffleWord16X8# :: Word16X8# -> Word16X8# -> (# Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int# #) -> Word16X8#
+  shuffleWord32X16# :: Word32X16# -> Word32X16# -> (# Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int# #) -> Word32X16#
+  shuffleWord32X4# :: Word32X4# -> Word32X4# -> (# Int#, Int#, Int#, Int# #) -> Word32X4#
+  shuffleWord32X8# :: Word32X8# -> Word32X8# -> (# Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int# #) -> Word32X8#
+  shuffleWord64X2# :: Word64X2# -> Word64X2# -> (# Int#, Int# #) -> Word64X2#
+  shuffleWord64X4# :: Word64X4# -> Word64X4# -> (# Int#, Int#, Int#, Int# #) -> Word64X4#
+  shuffleWord64X8# :: Word64X8# -> Word64X8# -> (# Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int# #) -> Word64X8#
+  shuffleWord8X16# :: Word8X16# -> Word8X16# -> (# Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int# #) -> Word8X16#
+  shuffleWord8X32# :: Word8X32# -> Word8X32# -> (# Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int# #) -> Word8X32#
+  shuffleWord8X64# :: Word8X64# -> Word8X64# -> (# Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int# #) -> Word8X64#
+  sinDouble# :: Double# -> Double#
+  sinFloat# :: Float# -> Float#
+  sinhDouble# :: Double# -> Double#
+  sinhFloat# :: Float# -> Float#
+  sizeofArray# :: forall {l :: Levity} (a :: TYPE (BoxedRep l)). Array# a -> Int#
+  sizeofArrayArray# :: ArrayArray# -> Int#
+  sizeofByteArray# :: ByteArray# -> Int#
+  sizeofMutableArray# :: forall {l :: Levity} d (a :: TYPE (BoxedRep l)). MutableArray# d a -> Int#
+  sizeofMutableArrayArray# :: forall s. MutableArrayArray# s -> Int#
+  sizeofMutableByteArray# :: forall d. MutableByteArray# d -> Int#
+  sizeofSmallArray# :: forall {l :: Levity} (a :: TYPE (BoxedRep l)). SmallArray# a -> Int#
+  sizeofSmallMutableArray# :: forall {l :: Levity} d (a :: TYPE (BoxedRep l)). SmallMutableArray# d a -> Int#
+  sortWith :: forall b a. GHC.Classes.Ord b => (a -> b) -> [a] -> [a]
+  spark# :: forall a d. a -> State# d -> (# State# d, a #)
+  sqrtDouble# :: Double# -> Double#
+  sqrtFloat# :: Float# -> Float#
+  stableNameToInt# :: forall {l :: Levity} (a :: TYPE (BoxedRep l)). StableName# a -> Int#
+  subInt16# :: Int16# -> Int16# -> Int16#
+  subInt32# :: Int32# -> Int32# -> Int32#
+  subInt64# :: Int64# -> Int64# -> Int64#
+  subInt8# :: Int8# -> Int8# -> Int8#
+  subIntC# :: Int# -> Int# -> (# Int#, Int# #)
+  subWord16# :: Word16# -> Word16# -> Word16#
+  subWord32# :: Word32# -> Word32# -> Word32#
+  subWord64# :: Word64# -> Word64# -> Word64#
+  subWord8# :: Word8# -> Word8# -> Word8#
+  subWordC# :: Word# -> Word# -> (# Word#, Int# #)
+  tagToEnum# :: forall a. Int# -> a
+  takeMVar# :: forall {l :: Levity} d (a :: TYPE (BoxedRep l)). MVar# d a -> State# d -> (# State# d, a #)
+  tanDouble# :: Double# -> Double#
+  tanFloat# :: Float# -> Float#
+  tanhDouble# :: Double# -> Double#
+  tanhFloat# :: Float# -> Float#
+  thawArray# :: forall {l :: Levity} (a :: TYPE (BoxedRep l)) d. Array# a -> Int# -> Int# -> State# d -> (# State# d, MutableArray# d a #)
+  thawSmallArray# :: forall {l :: Levity} (a :: TYPE (BoxedRep l)) d. SmallArray# a -> Int# -> Int# -> State# d -> (# State# d, SmallMutableArray# d a #)
+  the :: forall a. GHC.Classes.Eq a => [a] -> a
+  threadLabel# :: ThreadId# -> State# RealWorld -> (# State# RealWorld, Int#, ByteArray# #)
+  threadStatus# :: ThreadId# -> State# RealWorld -> (# State# RealWorld, Int#, Int#, Int# #)
+  timesDoubleX2# :: DoubleX2# -> DoubleX2# -> DoubleX2#
+  timesDoubleX4# :: DoubleX4# -> DoubleX4# -> DoubleX4#
+  timesDoubleX8# :: DoubleX8# -> DoubleX8# -> DoubleX8#
+  timesFloat# :: Float# -> Float# -> Float#
+  timesFloatX16# :: FloatX16# -> FloatX16# -> FloatX16#
+  timesFloatX4# :: FloatX4# -> FloatX4# -> FloatX4#
+  timesFloatX8# :: FloatX8# -> FloatX8# -> FloatX8#
+  timesInt16# :: Int16# -> Int16# -> Int16#
+  timesInt16X16# :: Int16X16# -> Int16X16# -> Int16X16#
+  timesInt16X32# :: Int16X32# -> Int16X32# -> Int16X32#
+  timesInt16X8# :: Int16X8# -> Int16X8# -> Int16X8#
+  timesInt2# :: Int# -> Int# -> (# Int#, Int#, Int# #)
+  timesInt32# :: Int32# -> Int32# -> Int32#
+  timesInt32X16# :: Int32X16# -> Int32X16# -> Int32X16#
+  timesInt32X4# :: Int32X4# -> Int32X4# -> Int32X4#
+  timesInt32X8# :: Int32X8# -> Int32X8# -> Int32X8#
+  timesInt64# :: Int64# -> Int64# -> Int64#
+  timesInt64X2# :: Int64X2# -> Int64X2# -> Int64X2#
+  timesInt64X4# :: Int64X4# -> Int64X4# -> Int64X4#
+  timesInt64X8# :: Int64X8# -> Int64X8# -> Int64X8#
+  timesInt8# :: Int8# -> Int8# -> Int8#
+  timesInt8X16# :: Int8X16# -> Int8X16# -> Int8X16#
+  timesInt8X32# :: Int8X32# -> Int8X32# -> Int8X32#
+  timesInt8X64# :: Int8X64# -> Int8X64# -> Int8X64#
+  timesWord# :: Word# -> Word# -> Word#
+  timesWord16# :: Word16# -> Word16# -> Word16#
+  timesWord16X16# :: Word16X16# -> Word16X16# -> Word16X16#
+  timesWord16X32# :: Word16X32# -> Word16X32# -> Word16X32#
+  timesWord16X8# :: Word16X8# -> Word16X8# -> Word16X8#
+  timesWord2# :: Word# -> Word# -> (# Word#, Word# #)
+  timesWord32# :: Word32# -> Word32# -> Word32#
+  timesWord32X16# :: Word32X16# -> Word32X16# -> Word32X16#
+  timesWord32X4# :: Word32X4# -> Word32X4# -> Word32X4#
+  timesWord32X8# :: Word32X8# -> Word32X8# -> Word32X8#
+  timesWord64# :: Word64# -> Word64# -> Word64#
+  timesWord64X2# :: Word64X2# -> Word64X2# -> Word64X2#
+  timesWord64X4# :: Word64X4# -> Word64X4# -> Word64X4#
+  timesWord64X8# :: Word64X8# -> Word64X8# -> Word64X8#
+  timesWord8# :: Word8# -> Word8# -> Word8#
+  timesWord8X16# :: Word8X16# -> Word8X16# -> Word8X16#
+  timesWord8X32# :: Word8X32# -> Word8X32# -> Word8X32#
+  timesWord8X64# :: Word8X64# -> Word8X64# -> Word8X64#
+  touch# :: forall {l :: Levity} (a :: TYPE (BoxedRep l)) d. a -> State# d -> State# d
+  traceBinaryEvent# :: forall d. Addr# -> Int# -> State# d -> State# d
+  traceEvent :: GHC.Internal.Base.String -> GHC.Types.IO ()
+  traceEvent# :: forall d. Addr# -> State# d -> State# d
+  traceMarker# :: forall d. Addr# -> State# d -> State# d
+  tryPutMVar# :: forall {l :: Levity} d (a :: TYPE (BoxedRep l)). MVar# d a -> a -> State# d -> (# State# d, Int# #)
+  tryReadMVar# :: forall {l :: Levity} d (a :: TYPE (BoxedRep l)). MVar# d a -> State# d -> (# State# d, Int#, a #)
+  tryTakeMVar# :: forall {l :: Levity} d (a :: TYPE (BoxedRep l)). MVar# d a -> State# d -> (# State# d, Int#, a #)
+  uncheckedIShiftL# :: Int# -> Int# -> Int#
+  uncheckedIShiftL64# :: Int64# -> Int# -> Int64#
+  uncheckedIShiftRA# :: Int# -> Int# -> Int#
+  uncheckedIShiftRA64# :: Int64# -> Int# -> Int64#
+  uncheckedIShiftRL# :: Int# -> Int# -> Int#
+  uncheckedIShiftRL64# :: Int64# -> Int# -> Int64#
+  uncheckedShiftL# :: Word# -> Int# -> Word#
+  uncheckedShiftL64# :: Word64# -> Int# -> Word64#
+  uncheckedShiftLInt16# :: Int16# -> Int# -> Int16#
+  uncheckedShiftLInt32# :: Int32# -> Int# -> Int32#
+  uncheckedShiftLInt8# :: Int8# -> Int# -> Int8#
+  uncheckedShiftLWord16# :: Word16# -> Int# -> Word16#
+  uncheckedShiftLWord32# :: Word32# -> Int# -> Word32#
+  uncheckedShiftLWord8# :: Word8# -> Int# -> Word8#
+  uncheckedShiftRAInt16# :: Int16# -> Int# -> Int16#
+  uncheckedShiftRAInt32# :: Int32# -> Int# -> Int32#
+  uncheckedShiftRAInt8# :: Int8# -> Int# -> Int8#
+  uncheckedShiftRL# :: Word# -> Int# -> Word#
+  uncheckedShiftRL64# :: Word64# -> Int# -> Word64#
+  uncheckedShiftRLInt16# :: Int16# -> Int# -> Int16#
+  uncheckedShiftRLInt32# :: Int32# -> Int# -> Int32#
+  uncheckedShiftRLInt8# :: Int8# -> Int# -> Int8#
+  uncheckedShiftRLWord16# :: Word16# -> Int# -> Word16#
+  uncheckedShiftRLWord32# :: Word32# -> Int# -> Word32#
+  uncheckedShiftRLWord8# :: Word8# -> Int# -> Word8#
+  unmaskAsyncExceptions# :: forall {q :: RuntimeRep} (a :: TYPE q). (State# RealWorld -> (# State# RealWorld, a #)) -> State# RealWorld -> (# State# RealWorld, a #)
+  unpackAppendCString# :: Addr# -> [Char] -> [Char]
+  unpackCString# :: Addr# -> [Char]
+  unpackCStringUtf8# :: Addr# -> [Char]
+  unpackClosure# :: forall a b. a -> (# Addr#, ByteArray#, Array# b #)
+  unpackDoubleX2# :: DoubleX2# -> (# Double#, Double# #)
+  unpackDoubleX4# :: DoubleX4# -> (# Double#, Double#, Double#, Double# #)
+  unpackDoubleX8# :: DoubleX8# -> (# Double#, Double#, Double#, Double#, Double#, Double#, Double#, Double# #)
+  unpackFloatX16# :: FloatX16# -> (# Float#, Float#, Float#, Float#, Float#, Float#, Float#, Float#, Float#, Float#, Float#, Float#, Float#, Float#, Float#, Float# #)
+  unpackFloatX4# :: FloatX4# -> (# Float#, Float#, Float#, Float# #)
+  unpackFloatX8# :: FloatX8# -> (# Float#, Float#, Float#, Float#, Float#, Float#, Float#, Float# #)
+  unpackFoldrCString# :: forall a. Addr# -> (Char -> a -> a) -> a -> a
+  unpackInt16X16# :: Int16X16# -> (# Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16# #)
+  unpackInt16X32# :: Int16X32# -> (# Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16# #)
+  unpackInt16X8# :: Int16X8# -> (# Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16# #)
+  unpackInt32X16# :: Int32X16# -> (# Int32#, Int32#, Int32#, Int32#, Int32#, Int32#, Int32#, Int32#, Int32#, Int32#, Int32#, Int32#, Int32#, Int32#, Int32#, Int32# #)
+  unpackInt32X4# :: Int32X4# -> (# Int32#, Int32#, Int32#, Int32# #)
+  unpackInt32X8# :: Int32X8# -> (# Int32#, Int32#, Int32#, Int32#, Int32#, Int32#, Int32#, Int32# #)
+  unpackInt64X2# :: Int64X2# -> (# Int64#, Int64# #)
+  unpackInt64X4# :: Int64X4# -> (# Int64#, Int64#, Int64#, Int64# #)
+  unpackInt64X8# :: Int64X8# -> (# Int64#, Int64#, Int64#, Int64#, Int64#, Int64#, Int64#, Int64# #)
+  unpackInt8X16# :: Int8X16# -> (# Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8# #)
+  unpackInt8X32# :: Int8X32# -> (# Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8# #)
+  unpackInt8X64# :: Int8X64# -> (# Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8# #)
+  unpackNBytes# :: Addr# -> Int# -> [Char]
+  unpackWord16X16# :: Word16X16# -> (# Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16# #)
+  unpackWord16X32# :: Word16X32# -> (# Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16# #)
+  unpackWord16X8# :: Word16X8# -> (# Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16# #)
+  unpackWord32X16# :: Word32X16# -> (# Word32#, Word32#, Word32#, Word32#, Word32#, Word32#, Word32#, Word32#, Word32#, Word32#, Word32#, Word32#, Word32#, Word32#, Word32#, Word32# #)
+  unpackWord32X4# :: Word32X4# -> (# Word32#, Word32#, Word32#, Word32# #)
+  unpackWord32X8# :: Word32X8# -> (# Word32#, Word32#, Word32#, Word32#, Word32#, Word32#, Word32#, Word32# #)
+  unpackWord64X2# :: Word64X2# -> (# Word64#, Word64# #)
+  unpackWord64X4# :: Word64X4# -> (# Word64#, Word64#, Word64#, Word64# #)
+  unpackWord64X8# :: Word64X8# -> (# Word64#, Word64#, Word64#, Word64#, Word64#, Word64#, Word64#, Word64# #)
+  unpackWord8X16# :: Word8X16# -> (# Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8# #)
+  unpackWord8X32# :: Word8X32# -> (# Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8# #)
+  unpackWord8X64# :: Word8X64# -> (# Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8# #)
+  unsafeCoerce# :: forall (q :: RuntimeRep) (r :: RuntimeRep) (a :: TYPE q) (b :: TYPE r). a -> b
+  unsafeFreezeArray# :: forall {l :: Levity} d (a :: TYPE (BoxedRep l)). MutableArray# d a -> State# d -> (# State# d, Array# a #)
+  unsafeFreezeArrayArray# :: forall s. MutableArrayArray# s -> State# s -> (# State# s, ArrayArray# #)
+  unsafeFreezeByteArray# :: forall d. MutableByteArray# d -> State# d -> (# State# d, ByteArray# #)
+  unsafeFreezeSmallArray# :: forall {l :: Levity} d (a :: TYPE (BoxedRep l)). SmallMutableArray# d a -> State# d -> (# State# d, SmallArray# a #)
+  unsafePtrEquality# :: forall (a :: UnliftedType) (b :: UnliftedType). a -> b -> Int#
+  unsafeThawArray# :: forall {l :: Levity} (a :: TYPE (BoxedRep l)) d. Array# a -> State# d -> (# State# d, MutableArray# d a #)
+  unsafeThawByteArray# :: forall d. ByteArray# -> State# d -> (# State# d, MutableByteArray# d #)
+  unsafeThawSmallArray# :: forall {l :: Levity} (a :: TYPE (BoxedRep l)) d. SmallArray# a -> State# d -> (# State# d, SmallMutableArray# d a #)
+  void# :: (# #)
+  waitRead# :: forall d. Int# -> State# d -> State# d
+  waitWrite# :: forall d. Int# -> State# d -> State# d
+  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.Profiling.Eras where
   -- Safety: Trustworthy
   getUserEra :: GHC.Types.IO GHC.Types.Word
@@ -8657,6 +10490,92 @@ module Prelude.Experimental where
 
 
 -- Instances:
+instance GHC.Internal.Base.Alternative GHC.Types.IO -- Defined in ‘GHC.Internal.Base’
+instance GHC.Internal.Base.Alternative [] -- Defined in ‘GHC.Internal.Base’
+instance GHC.Internal.Base.Alternative GHC.Internal.Maybe.Maybe -- Defined in ‘GHC.Internal.Base’
+instance GHC.Internal.Base.Applicative GHC.Internal.Data.Ord.Down -- Defined in ‘GHC.Internal.Data.Ord’
+instance GHC.Internal.Base.Applicative GHC.Types.IO -- Defined in ‘GHC.Internal.Base’
+instance GHC.Internal.Base.Applicative [] -- Defined in ‘GHC.Internal.Base’
+instance GHC.Internal.Base.Applicative GHC.Internal.Maybe.Maybe -- Defined in ‘GHC.Internal.Base’
+instance GHC.Internal.Base.Applicative GHC.Internal.Base.NonEmpty -- Defined in ‘GHC.Internal.Base’
+instance GHC.Internal.Base.Applicative Solo -- Defined in ‘GHC.Internal.Base’
+instance forall a. GHC.Internal.Base.Monoid a => GHC.Internal.Base.Applicative ((,) a) -- Defined in ‘GHC.Internal.Base’
+instance forall a b. (GHC.Internal.Base.Monoid a, GHC.Internal.Base.Monoid b) => GHC.Internal.Base.Applicative ((,,) a b) -- Defined in ‘GHC.Internal.Base’
+instance forall a b c. (GHC.Internal.Base.Monoid a, GHC.Internal.Base.Monoid b, GHC.Internal.Base.Monoid c) => GHC.Internal.Base.Applicative ((,,,) a b c) -- Defined in ‘GHC.Internal.Base’
+instance GHC.Internal.Base.Functor GHC.Internal.Data.Ord.Down -- Defined in ‘GHC.Internal.Data.Ord’
+instance GHC.Internal.Base.Functor GHC.Types.IO -- Defined in ‘GHC.Internal.Base’
+instance GHC.Internal.Base.Functor [] -- Defined in ‘GHC.Internal.Base’
+instance GHC.Internal.Base.Functor GHC.Internal.Maybe.Maybe -- Defined in ‘GHC.Internal.Base’
+instance GHC.Internal.Base.Functor GHC.Internal.Base.NonEmpty -- Defined in ‘GHC.Internal.Base’
+instance GHC.Internal.Base.Functor Solo -- Defined in ‘GHC.Internal.Base’
+instance forall a. GHC.Internal.Base.Functor ((,) a) -- Defined in ‘GHC.Internal.Base’
+instance forall a b. GHC.Internal.Base.Functor ((,,) a b) -- Defined in ‘GHC.Internal.Base’
+instance forall a b c. GHC.Internal.Base.Functor ((,,,) a b c) -- Defined in ‘GHC.Internal.Base’
+instance forall a b c d. GHC.Internal.Base.Functor ((,,,,) a b c d) -- Defined in ‘GHC.Internal.Base’
+instance forall a b c d e. GHC.Internal.Base.Functor ((,,,,,) a b c d e) -- Defined in ‘GHC.Internal.Base’
+instance forall a b c d e f. GHC.Internal.Base.Functor ((,,,,,,) a b c d e f) -- Defined in ‘GHC.Internal.Base’
+instance GHC.Internal.Base.Monad GHC.Internal.Data.Ord.Down -- Defined in ‘GHC.Internal.Data.Ord’
+instance GHC.Internal.Base.Monad GHC.Types.IO -- Defined in ‘GHC.Internal.Base’
+instance GHC.Internal.Base.Monad [] -- Defined in ‘GHC.Internal.Base’
+instance GHC.Internal.Base.Monad GHC.Internal.Maybe.Maybe -- Defined in ‘GHC.Internal.Base’
+instance GHC.Internal.Base.Monad GHC.Internal.Base.NonEmpty -- Defined in ‘GHC.Internal.Base’
+instance GHC.Internal.Base.Monad Solo -- Defined in ‘GHC.Internal.Base’
+instance forall a. GHC.Internal.Base.Monoid a => GHC.Internal.Base.Monad ((,) a) -- Defined in ‘GHC.Internal.Base’
+instance forall a b. (GHC.Internal.Base.Monoid a, GHC.Internal.Base.Monoid b) => GHC.Internal.Base.Monad ((,,) a b) -- Defined in ‘GHC.Internal.Base’
+instance forall a b c. (GHC.Internal.Base.Monoid a, GHC.Internal.Base.Monoid b, GHC.Internal.Base.Monoid c) => GHC.Internal.Base.Monad ((,,,) a b c) -- Defined in ‘GHC.Internal.Base’
+instance GHC.Internal.Base.MonadPlus GHC.Types.IO -- Defined in ‘GHC.Internal.Base’
+instance GHC.Internal.Base.MonadPlus [] -- Defined in ‘GHC.Internal.Base’
+instance GHC.Internal.Base.MonadPlus GHC.Internal.Maybe.Maybe -- Defined in ‘GHC.Internal.Base’
+instance forall a. GHC.Internal.Base.Monoid a => GHC.Internal.Base.Monoid (GHC.Internal.Data.Ord.Down a) -- Defined in ‘GHC.Internal.Data.Ord’
+instance forall a. GHC.Internal.Base.Monoid a => GHC.Internal.Base.Monoid (GHC.Types.IO a) -- Defined in ‘GHC.Internal.Base’
+instance forall a. GHC.Internal.Base.Monoid [a] -- Defined in ‘GHC.Internal.Base’
+instance forall a. GHC.Internal.Base.Semigroup a => GHC.Internal.Base.Monoid (GHC.Internal.Maybe.Maybe a) -- Defined in ‘GHC.Internal.Base’
+instance GHC.Internal.Base.Monoid GHC.Types.Ordering -- Defined in ‘GHC.Internal.Base’
+instance forall a. GHC.Internal.Base.Monoid a => GHC.Internal.Base.Monoid (Solo a) -- Defined in ‘GHC.Internal.Base’
+instance forall a b. (GHC.Internal.Base.Monoid a, GHC.Internal.Base.Monoid b) => GHC.Internal.Base.Monoid (a, b) -- Defined in ‘GHC.Internal.Base’
+instance forall a b c. (GHC.Internal.Base.Monoid a, GHC.Internal.Base.Monoid b, GHC.Internal.Base.Monoid c) => GHC.Internal.Base.Monoid (a, b, c) -- Defined in ‘GHC.Internal.Base’
+instance forall a b c d. (GHC.Internal.Base.Monoid a, GHC.Internal.Base.Monoid b, GHC.Internal.Base.Monoid c, GHC.Internal.Base.Monoid d) => GHC.Internal.Base.Monoid (a, b, c, d) -- Defined in ‘GHC.Internal.Base’
+instance forall a b c d e. (GHC.Internal.Base.Monoid a, GHC.Internal.Base.Monoid b, GHC.Internal.Base.Monoid c, GHC.Internal.Base.Monoid d, GHC.Internal.Base.Monoid e) => GHC.Internal.Base.Monoid (a, b, c, d, e) -- Defined in ‘GHC.Internal.Base’
+instance GHC.Internal.Base.Monoid () -- Defined in ‘GHC.Internal.Base’
+instance forall a. GHC.Internal.Base.Semigroup a => GHC.Internal.Base.Semigroup (GHC.Internal.Data.Ord.Down a) -- Defined in ‘GHC.Internal.Data.Ord’
+instance forall a. GHC.Internal.Base.Semigroup a => GHC.Internal.Base.Semigroup (GHC.Types.IO a) -- Defined in ‘GHC.Internal.Base’
+instance forall a. GHC.Internal.Base.Semigroup [a] -- Defined in ‘GHC.Internal.Base’
+instance forall a. GHC.Internal.Base.Semigroup a => GHC.Internal.Base.Semigroup (GHC.Internal.Maybe.Maybe a) -- Defined in ‘GHC.Internal.Base’
+instance forall a. GHC.Internal.Base.Semigroup (GHC.Internal.Base.NonEmpty a) -- Defined in ‘GHC.Internal.Base’
+instance GHC.Internal.Base.Semigroup GHC.Types.Ordering -- Defined in ‘GHC.Internal.Base’
+instance forall a. GHC.Internal.Base.Semigroup a => GHC.Internal.Base.Semigroup (Solo a) -- Defined in ‘GHC.Internal.Base’
+instance forall a b. (GHC.Internal.Base.Semigroup a, GHC.Internal.Base.Semigroup b) => GHC.Internal.Base.Semigroup (a, b) -- Defined in ‘GHC.Internal.Base’
+instance forall a b c. (GHC.Internal.Base.Semigroup a, GHC.Internal.Base.Semigroup b, GHC.Internal.Base.Semigroup c) => GHC.Internal.Base.Semigroup (a, b, c) -- Defined in ‘GHC.Internal.Base’
+instance forall a b c d. (GHC.Internal.Base.Semigroup a, GHC.Internal.Base.Semigroup b, GHC.Internal.Base.Semigroup c, GHC.Internal.Base.Semigroup d) => GHC.Internal.Base.Semigroup (a, b, c, d) -- Defined in ‘GHC.Internal.Base’
+instance forall a b c d e. (GHC.Internal.Base.Semigroup a, GHC.Internal.Base.Semigroup b, GHC.Internal.Base.Semigroup c, GHC.Internal.Base.Semigroup d, GHC.Internal.Base.Semigroup e) => GHC.Internal.Base.Semigroup (a, b, c, d, e) -- Defined in ‘GHC.Internal.Base’
+instance GHC.Internal.Base.Semigroup () -- Defined in ‘GHC.Internal.Base’
+instance GHC.Internal.Base.Semigroup GHC.Internal.Base.Void -- Defined in ‘GHC.Internal.Base’
+instance forall a. GHC.Internal.Bits.Bits a => GHC.Internal.Bits.Bits (GHC.Internal.Data.Ord.Down a) -- Defined in ‘GHC.Internal.Data.Ord’
+instance forall a. GHC.Internal.Bits.FiniteBits a => GHC.Internal.Bits.FiniteBits (GHC.Internal.Data.Ord.Down a) -- Defined in ‘GHC.Internal.Data.Ord’
+instance GHC.Internal.Data.Data.Data GHC.Internal.Exts.SpecConstrAnnotation -- Defined in ‘GHC.Internal.Exts’
+instance forall a k (b :: k). GHC.Internal.Data.String.IsString a => GHC.Internal.Data.String.IsString (GHC.Internal.Data.Functor.Const.Const a b) -- Defined in ‘GHC.Internal.Data.String’
+instance forall a. GHC.Internal.Data.String.IsString a => GHC.Internal.Data.String.IsString (GHC.Internal.Data.Functor.Identity.Identity a) -- Defined in ‘GHC.Internal.Data.String’
+instance forall a. (a ~ GHC.Types.Char) => GHC.Internal.Data.String.IsString [a] -- Defined in ‘GHC.Internal.Data.String’
+instance forall a. GHC.Internal.Enum.Bounded a => GHC.Internal.Enum.Bounded (GHC.Internal.Data.Ord.Down a) -- Defined in ‘GHC.Internal.Data.Ord’
+instance forall a. (GHC.Internal.Enum.Enum a, GHC.Internal.Enum.Bounded a, GHC.Classes.Eq a) => GHC.Internal.Enum.Enum (GHC.Internal.Data.Ord.Down a) -- Defined in ‘GHC.Internal.Data.Ord’
+instance forall a. GHC.Internal.Float.Floating a => GHC.Internal.Float.Floating (GHC.Internal.Data.Ord.Down a) -- Defined in ‘GHC.Internal.Data.Ord’
+instance forall a. GHC.Internal.Float.RealFloat a => GHC.Internal.Float.RealFloat (GHC.Internal.Data.Ord.Down a) -- Defined in ‘GHC.Internal.Data.Ord’
+instance forall a. GHC.Internal.Foreign.Storable.Storable a => GHC.Internal.Foreign.Storable.Storable (GHC.Internal.Data.Ord.Down a) -- Defined in ‘GHC.Internal.Data.Ord’
+instance GHC.Internal.IsList.IsList GHC.Internal.Stack.Types.CallStack -- Defined in ‘GHC.Internal.IsList’
+instance forall a. GHC.Internal.IsList.IsList [a] -- Defined in ‘GHC.Internal.IsList’
+instance forall a. GHC.Internal.IsList.IsList (GHC.Internal.Base.NonEmpty a) -- Defined in ‘GHC.Internal.IsList’
+instance GHC.Internal.IsList.IsList GHC.Internal.Data.Version.Version -- Defined in ‘GHC.Internal.IsList’
+instance forall a. GHC.Internal.IsList.IsList (GHC.Internal.Functor.ZipList.ZipList a) -- Defined in ‘GHC.Internal.IsList’
+instance forall a. GHC.Internal.Ix.Ix a => GHC.Internal.Ix.Ix (GHC.Internal.Data.Ord.Down a) -- Defined in ‘GHC.Internal.Data.Ord’
+instance forall a. GHC.Internal.Num.Num a => GHC.Internal.Num.Num (GHC.Internal.Data.Ord.Down a) -- Defined in ‘GHC.Internal.Data.Ord’
+instance forall a. GHC.Internal.Read.Read a => GHC.Internal.Read.Read (GHC.Internal.Data.Ord.Down a) -- Defined in ‘GHC.Internal.Data.Ord’
+instance forall a. GHC.Internal.Real.Fractional a => GHC.Internal.Real.Fractional (GHC.Internal.Data.Ord.Down a) -- Defined in ‘GHC.Internal.Data.Ord’
+instance forall a. GHC.Internal.Real.Real a => GHC.Internal.Real.Real (GHC.Internal.Data.Ord.Down a) -- Defined in ‘GHC.Internal.Data.Ord’
+instance forall a. GHC.Internal.Real.RealFrac a => GHC.Internal.Real.RealFrac (GHC.Internal.Data.Ord.Down a) -- Defined in ‘GHC.Internal.Data.Ord’
+instance forall a. GHC.Internal.Show.Show a => GHC.Internal.Show.Show (GHC.Internal.Data.Ord.Down a) -- Defined in ‘GHC.Internal.Data.Ord’
+instance forall a. GHC.Internal.Show.Show (GHC.Internal.Ptr.FunPtr a) -- Defined in ‘GHC.Internal.Ptr’
+instance forall a. GHC.Internal.Show.Show (GHC.Internal.Ptr.Ptr a) -- Defined in ‘GHC.Internal.Ptr’
+instance GHC.Internal.Show.Show GHC.Internal.IO.MaskingState -- Defined in ‘GHC.Internal.IO’
 instance GHC.Classes.Eq GHC.Types.Bool -- Defined in ‘GHC.Classes’
 instance GHC.Classes.Eq GHC.Types.Char -- Defined in ‘GHC.Classes’
 instance GHC.Classes.Eq GHC.Types.Double -- Defined in ‘GHC.Classes’
@@ -8684,6 +10603,13 @@ instance forall a b c d e f g h i. (GHC.Classes.Eq a, GHC.Classes.Eq b, GHC.Clas
 instance GHC.Classes.Eq GHC.Types.TyCon -- Defined in ‘GHC.Classes’
 instance GHC.Classes.Eq () -- Defined in ‘GHC.Classes’
 instance GHC.Classes.Eq GHC.Types.Word -- Defined in ‘GHC.Classes’
+instance forall a. GHC.Classes.Eq a => GHC.Classes.Eq (GHC.Internal.Data.Ord.Down a) -- Defined in ‘GHC.Internal.Data.Ord’
+instance GHC.Classes.Eq GHC.Internal.Exts.SpecConstrAnnotation -- Defined in ‘GHC.Internal.Exts’
+instance forall a. GHC.Classes.Eq (GHC.Internal.Ptr.FunPtr a) -- Defined in ‘GHC.Internal.Ptr’
+instance forall a. GHC.Classes.Eq (GHC.Internal.Ptr.Ptr a) -- Defined in ‘GHC.Internal.Ptr’
+instance forall a. GHC.Classes.Eq a => GHC.Classes.Eq (GHC.Internal.Base.NonEmpty a) -- Defined in ‘GHC.Internal.Base’
+instance GHC.Classes.Eq GHC.Internal.Base.Void -- Defined in ‘GHC.Internal.Base’
+instance GHC.Classes.Eq GHC.Internal.IO.MaskingState -- Defined in ‘GHC.Internal.IO’
 instance GHC.Classes.Ord GHC.Types.Bool -- Defined in ‘GHC.Classes’
 instance GHC.Classes.Ord GHC.Types.Char -- Defined in ‘GHC.Classes’
 instance GHC.Classes.Ord GHC.Types.Double -- Defined in ‘GHC.Classes’
@@ -8709,3 +10635,8 @@ instance forall a b c d e f g h i. (GHC.Classes.Ord a, GHC.Classes.Ord b, GHC.Cl
 instance GHC.Classes.Ord GHC.Types.TyCon -- Defined in ‘GHC.Classes’
 instance GHC.Classes.Ord () -- Defined in ‘GHC.Classes’
 instance GHC.Classes.Ord GHC.Types.Word -- Defined in ‘GHC.Classes’
+instance forall a. GHC.Classes.Ord a => GHC.Classes.Ord (GHC.Internal.Data.Ord.Down a) -- Defined in ‘GHC.Internal.Data.Ord’
+instance forall a. GHC.Classes.Ord (GHC.Internal.Ptr.FunPtr a) -- Defined in ‘GHC.Internal.Ptr’
+instance forall a. GHC.Classes.Ord (GHC.Internal.Ptr.Ptr a) -- Defined in ‘GHC.Internal.Ptr’
+instance forall a. GHC.Classes.Ord a => GHC.Classes.Ord (GHC.Internal.Base.NonEmpty a) -- Defined in ‘GHC.Internal.Base’
+instance GHC.Classes.Ord GHC.Internal.Base.Void -- Defined in ‘GHC.Internal.Base’


=====================================
testsuite/tests/interface-stability/ghc-experimental-exports.stdout-mingw32
=====================================
The diff for this file was not included because it is too large.


View it on GitLab: https://gitlab.haskell.org/ghc/ghc/-/commit/39497eeda74fc7f1e7ea89292de395b16f69cee2

-- 
View it on GitLab: https://gitlab.haskell.org/ghc/ghc/-/commit/39497eeda74fc7f1e7ea89292de395b16f69cee2
You're receiving this email because of your account on gitlab.haskell.org.


-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.haskell.org/pipermail/ghc-commits/attachments/20241002/b454f5b3/attachment-0001.html>