[Git][ghc/ghc][wip/andreask/ghc-primops] ghc-experimental: Expose primops and ghc extensions via GHC.PrimOps
Andreas Klebinger (@AndreasK)
gitlab at gitlab.haskell.org
Mon Sep 23 10:34:48 UTC 2024
Andreas Klebinger pushed to branch wip/andreask/ghc-primops at Glasgow Haskell Compiler / GHC
Commits:
3c32c060 by Andreas Klebinger at 2024-09-23T12:16:10+02: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,1721 @@ 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#
+ fmaddFloat# :: Float# -> Float# -> Float# -> Float#
+ fmsubDouble# :: Double# -> Double# -> Double# -> Double#
+ fmsubFloat# :: Float# -> Float# -> Float# -> Float#
+ fnmaddDouble# :: Double# -> Double# -> Double# -> Double#
+ fnmaddFloat# :: Float# -> Float# -> Float# -> Float#
+ fnmsubDouble# :: Double# -> Double# -> Double# -> Double#
+ fnmsubFloat# :: Float# -> Float# -> Float# -> Float#
+ fork# :: forall {q :: RuntimeRep} (a :: TYPE q). (State# RealWorld -> (# State# RealWorld, a #)) -> State# RealWorld -> (# State# RealWorld, ThreadId# #)
+ forkOn# :: forall {q :: RuntimeRep} (a :: TYPE q). Int# -> (State# RealWorld -> (# State# RealWorld, a #)) -> State# RealWorld -> (# State# RealWorld, ThreadId# #)
+ freezeArray# :: forall {l :: Levity} d (a :: TYPE (BoxedRep l)). MutableArray# d a -> Int# -> Int# -> State# d -> (# State# d, Array# a #)
+ freezeSmallArray# :: forall {l :: Levity} d (a :: TYPE (BoxedRep l)). SmallMutableArray# d a -> Int# -> Int# -> State# d -> (# State# d, SmallArray# a #)
+ geAddr# :: Addr# -> Addr# -> Int#
+ geChar# :: Char# -> Char# -> Int#
+ geFloat# :: Float# -> Float# -> Int#
+ geInt16# :: Int16# -> Int16# -> Int#
+ geInt32# :: Int32# -> Int32# -> Int#
+ geInt64# :: Int64# -> Int64# -> Int#
+ geInt8# :: Int8# -> Int8# -> Int#
+ geWord# :: Word# -> Word# -> Int#
+ geWord16# :: Word16# -> Word16# -> Int#
+ geWord32# :: Word32# -> Word32# -> Int#
+ geWord64# :: Word64# -> Word64# -> Int#
+ geWord8# :: Word8# -> Word8# -> Int#
+ getApStackVal# :: forall a b. a -> Int# -> (# Int#, b #)
+ getCCSOf# :: forall a d. a -> State# d -> (# State# d, Addr# #)
+ getCurrentCCS# :: forall a d. a -> State# d -> (# State# d, Addr# #)
+ getMaskingState# :: State# RealWorld -> (# State# RealWorld, Int# #)
+ getSizeofMutableByteArray# :: forall d. MutableByteArray# d -> State# d -> (# State# d, Int# #)
+ getSizeofSmallMutableArray# :: forall {l :: Levity} d (a :: TYPE (BoxedRep l)). SmallMutableArray# d a -> State# d -> (# State# d, Int# #)
+ getSpark# :: forall d a. State# d -> (# State# d, Int#, a #)
+ getThreadAllocationCounter# :: State# RealWorld -> (# State# RealWorld, Int64# #)
+ groupWith :: forall b a. GHC.Classes.Ord b => (a -> b) -> [a] -> [[a]]
+ gtAddr# :: Addr# -> Addr# -> Int#
+ gtChar# :: Char# -> Char# -> Int#
+ gtFloat# :: Float# -> Float# -> Int#
+ gtInt16# :: Int16# -> Int16# -> Int#
+ gtInt32# :: Int32# -> Int32# -> Int#
+ gtInt64# :: Int64# -> Int64# -> Int#
+ gtInt8# :: Int8# -> Int8# -> Int#
+ gtWord# :: Word# -> Word# -> Int#
+ gtWord16# :: Word16# -> Word16# -> Int#
+ gtWord32# :: Word32# -> Word32# -> Int#
+ gtWord64# :: Word64# -> Word64# -> Int#
+ gtWord8# :: Word8# -> Word8# -> Int#
+ iShiftL# :: Int# -> Int# -> Int#
+ iShiftRA# :: Int# -> Int# -> Int#
+ iShiftRL# :: Int# -> Int# -> Int#
+ indexAddrArray# :: ByteArray# -> Int# -> Addr#
+ indexAddrOffAddr# :: Addr# -> Int# -> Addr#
+ indexArray# :: forall {l :: Levity} (a :: TYPE (BoxedRep l)). Array# a -> Int# -> (# a #)
+ indexArrayArrayArray# :: ArrayArray# -> Int# -> ArrayArray#
+ indexByteArrayArray# :: ArrayArray# -> Int# -> ByteArray#
+ indexCharArray# :: ByteArray# -> Int# -> Char#
+ indexCharOffAddr# :: Addr# -> Int# -> Char#
+ indexDoubleArray# :: ByteArray# -> Int# -> Double#
+ indexDoubleArrayAsDoubleX2# :: ByteArray# -> Int# -> DoubleX2#
+ indexDoubleArrayAsDoubleX4# :: ByteArray# -> Int# -> DoubleX4#
+ indexDoubleArrayAsDoubleX8# :: ByteArray# -> Int# -> DoubleX8#
+ indexDoubleOffAddr# :: Addr# -> Int# -> Double#
+ indexDoubleOffAddrAsDoubleX2# :: Addr# -> Int# -> DoubleX2#
+ indexDoubleOffAddrAsDoubleX4# :: Addr# -> Int# -> DoubleX4#
+ indexDoubleOffAddrAsDoubleX8# :: Addr# -> Int# -> DoubleX8#
+ indexDoubleX2Array# :: ByteArray# -> Int# -> DoubleX2#
+ indexDoubleX2OffAddr# :: Addr# -> Int# -> DoubleX2#
+ indexDoubleX4Array# :: ByteArray# -> Int# -> DoubleX4#
+ indexDoubleX4OffAddr# :: Addr# -> Int# -> DoubleX4#
+ indexDoubleX8Array# :: ByteArray# -> Int# -> DoubleX8#
+ indexDoubleX8OffAddr# :: Addr# -> Int# -> DoubleX8#
+ indexFloatArray# :: ByteArray# -> Int# -> Float#
+ indexFloatArrayAsFloatX16# :: ByteArray# -> Int# -> FloatX16#
+ indexFloatArrayAsFloatX4# :: ByteArray# -> Int# -> FloatX4#
+ indexFloatArrayAsFloatX8# :: ByteArray# -> Int# -> FloatX8#
+ indexFloatOffAddr# :: Addr# -> Int# -> Float#
+ indexFloatOffAddrAsFloatX16# :: Addr# -> Int# -> FloatX16#
+ indexFloatOffAddrAsFloatX4# :: Addr# -> Int# -> FloatX4#
+ indexFloatOffAddrAsFloatX8# :: Addr# -> Int# -> FloatX8#
+ indexFloatX16Array# :: ByteArray# -> Int# -> FloatX16#
+ indexFloatX16OffAddr# :: Addr# -> Int# -> FloatX16#
+ indexFloatX4Array# :: ByteArray# -> Int# -> FloatX4#
+ indexFloatX4OffAddr# :: Addr# -> Int# -> FloatX4#
+ indexFloatX8Array# :: ByteArray# -> Int# -> FloatX8#
+ indexFloatX8OffAddr# :: Addr# -> Int# -> FloatX8#
+ indexInt16Array# :: ByteArray# -> Int# -> Int16#
+ indexInt16ArrayAsInt16X16# :: ByteArray# -> Int# -> Int16X16#
+ indexInt16ArrayAsInt16X32# :: ByteArray# -> Int# -> Int16X32#
+ indexInt16ArrayAsInt16X8# :: ByteArray# -> Int# -> Int16X8#
+ indexInt16OffAddr# :: Addr# -> Int# -> Int16#
+ indexInt16OffAddrAsInt16X16# :: Addr# -> Int# -> Int16X16#
+ indexInt16OffAddrAsInt16X32# :: Addr# -> Int# -> Int16X32#
+ indexInt16OffAddrAsInt16X8# :: Addr# -> Int# -> Int16X8#
+ indexInt16X16Array# :: ByteArray# -> Int# -> Int16X16#
+ indexInt16X16OffAddr# :: Addr# -> Int# -> Int16X16#
+ indexInt16X32Array# :: ByteArray# -> Int# -> Int16X32#
+ indexInt16X32OffAddr# :: Addr# -> Int# -> Int16X32#
+ indexInt16X8Array# :: ByteArray# -> Int# -> Int16X8#
+ indexInt16X8OffAddr# :: Addr# -> Int# -> Int16X8#
+ indexInt32Array# :: ByteArray# -> Int# -> Int32#
+ indexInt32ArrayAsInt32X16# :: ByteArray# -> Int# -> Int32X16#
+ indexInt32ArrayAsInt32X4# :: ByteArray# -> Int# -> Int32X4#
+ indexInt32ArrayAsInt32X8# :: ByteArray# -> Int# -> Int32X8#
+ indexInt32OffAddr# :: Addr# -> Int# -> Int32#
+ indexInt32OffAddrAsInt32X16# :: Addr# -> Int# -> Int32X16#
+ indexInt32OffAddrAsInt32X4# :: Addr# -> Int# -> Int32X4#
+ indexInt32OffAddrAsInt32X8# :: Addr# -> Int# -> Int32X8#
+ indexInt32X16Array# :: ByteArray# -> Int# -> Int32X16#
+ indexInt32X16OffAddr# :: Addr# -> Int# -> Int32X16#
+ indexInt32X4Array# :: ByteArray# -> Int# -> Int32X4#
+ indexInt32X4OffAddr# :: Addr# -> Int# -> Int32X4#
+ indexInt32X8Array# :: ByteArray# -> Int# -> Int32X8#
+ indexInt32X8OffAddr# :: Addr# -> Int# -> Int32X8#
+ indexInt64Array# :: ByteArray# -> Int# -> Int64#
+ indexInt64ArrayAsInt64X2# :: ByteArray# -> Int# -> Int64X2#
+ indexInt64ArrayAsInt64X4# :: ByteArray# -> Int# -> Int64X4#
+ indexInt64ArrayAsInt64X8# :: ByteArray# -> Int# -> Int64X8#
+ indexInt64OffAddr# :: Addr# -> Int# -> Int64#
+ indexInt64OffAddrAsInt64X2# :: Addr# -> Int# -> Int64X2#
+ indexInt64OffAddrAsInt64X4# :: Addr# -> Int# -> Int64X4#
+ indexInt64OffAddrAsInt64X8# :: Addr# -> Int# -> Int64X8#
+ indexInt64X2Array# :: ByteArray# -> Int# -> Int64X2#
+ indexInt64X2OffAddr# :: Addr# -> Int# -> Int64X2#
+ indexInt64X4Array# :: ByteArray# -> Int# -> Int64X4#
+ indexInt64X4OffAddr# :: Addr# -> Int# -> Int64X4#
+ indexInt64X8Array# :: ByteArray# -> Int# -> Int64X8#
+ indexInt64X8OffAddr# :: Addr# -> Int# -> Int64X8#
+ indexInt8Array# :: ByteArray# -> Int# -> Int8#
+ indexInt8ArrayAsInt8X16# :: ByteArray# -> Int# -> Int8X16#
+ indexInt8ArrayAsInt8X32# :: ByteArray# -> Int# -> Int8X32#
+ indexInt8ArrayAsInt8X64# :: ByteArray# -> Int# -> Int8X64#
+ indexInt8OffAddr# :: Addr# -> Int# -> Int8#
+ indexInt8OffAddrAsInt8X16# :: Addr# -> Int# -> Int8X16#
+ indexInt8OffAddrAsInt8X32# :: Addr# -> Int# -> Int8X32#
+ indexInt8OffAddrAsInt8X64# :: Addr# -> Int# -> Int8X64#
+ indexInt8X16Array# :: ByteArray# -> Int# -> Int8X16#
+ indexInt8X16OffAddr# :: Addr# -> Int# -> Int8X16#
+ indexInt8X32Array# :: ByteArray# -> Int# -> Int8X32#
+ indexInt8X32OffAddr# :: Addr# -> Int# -> Int8X32#
+ indexInt8X64Array# :: ByteArray# -> Int# -> Int8X64#
+ indexInt8X64OffAddr# :: Addr# -> Int# -> Int8X64#
+ indexIntArray# :: ByteArray# -> Int# -> Int#
+ indexIntOffAddr# :: Addr# -> Int# -> Int#
+ indexSmallArray# :: forall {l :: Levity} (a :: TYPE (BoxedRep l)). SmallArray# a -> Int# -> (# a #)
+ indexStablePtrArray# :: forall a. ByteArray# -> Int# -> StablePtr# a
+ indexStablePtrOffAddr# :: forall a. Addr# -> Int# -> StablePtr# a
+ indexWideCharArray# :: ByteArray# -> Int# -> Char#
+ indexWideCharOffAddr# :: Addr# -> Int# -> Char#
+ indexWord16Array# :: ByteArray# -> Int# -> Word16#
+ indexWord16ArrayAsWord16X16# :: ByteArray# -> Int# -> Word16X16#
+ indexWord16ArrayAsWord16X32# :: ByteArray# -> Int# -> Word16X32#
+ indexWord16ArrayAsWord16X8# :: ByteArray# -> Int# -> Word16X8#
+ indexWord16OffAddr# :: Addr# -> Int# -> Word16#
+ indexWord16OffAddrAsWord16X16# :: Addr# -> Int# -> Word16X16#
+ indexWord16OffAddrAsWord16X32# :: Addr# -> Int# -> Word16X32#
+ indexWord16OffAddrAsWord16X8# :: Addr# -> Int# -> Word16X8#
+ indexWord16X16Array# :: ByteArray# -> Int# -> Word16X16#
+ indexWord16X16OffAddr# :: Addr# -> Int# -> Word16X16#
+ indexWord16X32Array# :: ByteArray# -> Int# -> Word16X32#
+ indexWord16X32OffAddr# :: Addr# -> Int# -> Word16X32#
+ indexWord16X8Array# :: ByteArray# -> Int# -> Word16X8#
+ indexWord16X8OffAddr# :: Addr# -> Int# -> Word16X8#
+ indexWord32Array# :: ByteArray# -> Int# -> Word32#
+ indexWord32ArrayAsWord32X16# :: ByteArray# -> Int# -> Word32X16#
+ indexWord32ArrayAsWord32X4# :: ByteArray# -> Int# -> Word32X4#
+ indexWord32ArrayAsWord32X8# :: ByteArray# -> Int# -> Word32X8#
+ indexWord32OffAddr# :: Addr# -> Int# -> Word32#
+ indexWord32OffAddrAsWord32X16# :: Addr# -> Int# -> Word32X16#
+ indexWord32OffAddrAsWord32X4# :: Addr# -> Int# -> Word32X4#
+ indexWord32OffAddrAsWord32X8# :: Addr# -> Int# -> Word32X8#
+ indexWord32X16Array# :: ByteArray# -> Int# -> Word32X16#
+ indexWord32X16OffAddr# :: Addr# -> Int# -> Word32X16#
+ indexWord32X4Array# :: ByteArray# -> Int# -> Word32X4#
+ indexWord32X4OffAddr# :: Addr# -> Int# -> Word32X4#
+ indexWord32X8Array# :: ByteArray# -> Int# -> Word32X8#
+ indexWord32X8OffAddr# :: Addr# -> Int# -> Word32X8#
+ indexWord64Array# :: ByteArray# -> Int# -> Word64#
+ indexWord64ArrayAsWord64X2# :: ByteArray# -> Int# -> Word64X2#
+ indexWord64ArrayAsWord64X4# :: ByteArray# -> Int# -> Word64X4#
+ indexWord64ArrayAsWord64X8# :: ByteArray# -> Int# -> Word64X8#
+ indexWord64OffAddr# :: Addr# -> Int# -> Word64#
+ indexWord64OffAddrAsWord64X2# :: Addr# -> Int# -> Word64X2#
+ indexWord64OffAddrAsWord64X4# :: Addr# -> Int# -> Word64X4#
+ indexWord64OffAddrAsWord64X8# :: Addr# -> Int# -> Word64X8#
+ indexWord64X2Array# :: ByteArray# -> Int# -> Word64X2#
+ indexWord64X2OffAddr# :: Addr# -> Int# -> Word64X2#
+ indexWord64X4Array# :: ByteArray# -> Int# -> Word64X4#
+ indexWord64X4OffAddr# :: Addr# -> Int# -> Word64X4#
+ indexWord64X8Array# :: ByteArray# -> Int# -> Word64X8#
+ indexWord64X8OffAddr# :: Addr# -> Int# -> Word64X8#
+ indexWord8Array# :: ByteArray# -> Int# -> Word8#
+ indexWord8ArrayAsAddr# :: ByteArray# -> Int# -> Addr#
+ indexWord8ArrayAsChar# :: ByteArray# -> Int# -> Char#
+ indexWord8ArrayAsDouble# :: ByteArray# -> Int# -> Double#
+ indexWord8ArrayAsFloat# :: ByteArray# -> Int# -> Float#
+ indexWord8ArrayAsInt# :: ByteArray# -> Int# -> Int#
+ indexWord8ArrayAsInt16# :: ByteArray# -> Int# -> Int16#
+ indexWord8ArrayAsInt32# :: ByteArray# -> Int# -> Int32#
+ indexWord8ArrayAsInt64# :: ByteArray# -> Int# -> Int64#
+ indexWord8ArrayAsStablePtr# :: forall a. ByteArray# -> Int# -> StablePtr# a
+ indexWord8ArrayAsWideChar# :: ByteArray# -> Int# -> Char#
+ indexWord8ArrayAsWord# :: ByteArray# -> Int# -> Word#
+ indexWord8ArrayAsWord16# :: ByteArray# -> Int# -> Word16#
+ indexWord8ArrayAsWord32# :: ByteArray# -> Int# -> Word32#
+ indexWord8ArrayAsWord64# :: ByteArray# -> Int# -> Word64#
+ indexWord8ArrayAsWord8X16# :: ByteArray# -> Int# -> Word8X16#
+ indexWord8ArrayAsWord8X32# :: ByteArray# -> Int# -> Word8X32#
+ indexWord8ArrayAsWord8X64# :: ByteArray# -> Int# -> Word8X64#
+ indexWord8OffAddr# :: Addr# -> Int# -> Word8#
+ indexWord8OffAddrAsAddr# :: Addr# -> Int# -> Addr#
+ indexWord8OffAddrAsChar# :: Addr# -> Int# -> Char#
+ indexWord8OffAddrAsDouble# :: Addr# -> Int# -> Double#
+ indexWord8OffAddrAsFloat# :: Addr# -> Int# -> Float#
+ indexWord8OffAddrAsInt# :: Addr# -> Int# -> Int#
+ indexWord8OffAddrAsInt16# :: Addr# -> Int# -> Int16#
+ indexWord8OffAddrAsInt32# :: Addr# -> Int# -> Int32#
+ indexWord8OffAddrAsInt64# :: Addr# -> Int# -> Int64#
+ indexWord8OffAddrAsStablePtr# :: forall a. Addr# -> Int# -> StablePtr# a
+ indexWord8OffAddrAsWideChar# :: Addr# -> Int# -> Char#
+ indexWord8OffAddrAsWord# :: Addr# -> Int# -> Word#
+ indexWord8OffAddrAsWord16# :: Addr# -> Int# -> Word16#
+ indexWord8OffAddrAsWord32# :: Addr# -> Int# -> Word32#
+ indexWord8OffAddrAsWord64# :: Addr# -> Int# -> Word64#
+ indexWord8OffAddrAsWord8X16# :: Addr# -> Int# -> Word8X16#
+ indexWord8OffAddrAsWord8X32# :: Addr# -> Int# -> Word8X32#
+ indexWord8OffAddrAsWord8X64# :: Addr# -> Int# -> Word8X64#
+ indexWord8X16Array# :: ByteArray# -> Int# -> Word8X16#
+ indexWord8X16OffAddr# :: Addr# -> Int# -> Word8X16#
+ indexWord8X32Array# :: ByteArray# -> Int# -> Word8X32#
+ indexWord8X32OffAddr# :: Addr# -> Int# -> Word8X32#
+ indexWord8X64Array# :: ByteArray# -> Int# -> Word8X64#
+ indexWord8X64OffAddr# :: Addr# -> Int# -> Word8X64#
+ indexWordArray# :: ByteArray# -> Int# -> Word#
+ indexWordOffAddr# :: Addr# -> Int# -> Word#
+ inline :: forall a. a -> a
+ insertDoubleX2# :: DoubleX2# -> Double# -> Int# -> DoubleX2#
+ insertDoubleX4# :: DoubleX4# -> Double# -> Int# -> DoubleX4#
+ insertDoubleX8# :: DoubleX8# -> Double# -> Int# -> DoubleX8#
+ insertFloatX16# :: FloatX16# -> Float# -> Int# -> FloatX16#
+ insertFloatX4# :: FloatX4# -> Float# -> Int# -> FloatX4#
+ insertFloatX8# :: FloatX8# -> Float# -> Int# -> FloatX8#
+ insertInt16X16# :: Int16X16# -> Int16# -> Int# -> Int16X16#
+ insertInt16X32# :: Int16X32# -> Int16# -> Int# -> Int16X32#
+ insertInt16X8# :: Int16X8# -> Int16# -> Int# -> Int16X8#
+ insertInt32X16# :: Int32X16# -> Int32# -> Int# -> Int32X16#
+ insertInt32X4# :: Int32X4# -> Int32# -> Int# -> Int32X4#
+ insertInt32X8# :: Int32X8# -> Int32# -> Int# -> Int32X8#
+ insertInt64X2# :: Int64X2# -> Int64# -> Int# -> Int64X2#
+ insertInt64X4# :: Int64X4# -> Int64# -> Int# -> Int64X4#
+ insertInt64X8# :: Int64X8# -> Int64# -> Int# -> Int64X8#
+ insertInt8X16# :: Int8X16# -> Int8# -> Int# -> Int8X16#
+ insertInt8X32# :: Int8X32# -> Int8# -> Int# -> Int8X32#
+ insertInt8X64# :: Int8X64# -> Int8# -> Int# -> Int8X64#
+ insertWord16X16# :: Word16X16# -> Word16# -> Int# -> Word16X16#
+ insertWord16X32# :: Word16X32# -> Word16# -> Int# -> Word16X32#
+ insertWord16X8# :: Word16X8# -> Word16# -> Int# -> Word16X8#
+ insertWord32X16# :: Word32X16# -> Word32# -> Int# -> Word32X16#
+ insertWord32X4# :: Word32X4# -> Word32# -> Int# -> Word32X4#
+ insertWord32X8# :: Word32X8# -> Word32# -> Int# -> Word32X8#
+ insertWord64X2# :: Word64X2# -> Word64# -> Int# -> Word64X2#
+ insertWord64X4# :: Word64X4# -> Word64# -> Int# -> Word64X4#
+ insertWord64X8# :: Word64X8# -> Word64# -> Int# -> Word64X8#
+ insertWord8X16# :: Word8X16# -> Word8# -> Int# -> Word8X16#
+ insertWord8X32# :: Word8X32# -> Word8# -> Int# -> Word8X32#
+ insertWord8X64# :: Word8X64# -> Word8# -> Int# -> Word8X64#
+ int16ToInt# :: Int16# -> Int#
+ int16ToWord16# :: Int16# -> Word16#
+ int2Addr# :: Int# -> Addr#
+ int2Double# :: Int# -> Double#
+ int2Float# :: Int# -> Float#
+ int2Word# :: Int# -> Word#
+ int32ToInt# :: Int32# -> Int#
+ int32ToWord32# :: Int32# -> Word32#
+ int64ToInt# :: Int64# -> Int#
+ int64ToWord64# :: Int64# -> Word64#
+ int8ToInt# :: Int8# -> Int#
+ int8ToWord8# :: Int8# -> Word8#
+ intToInt16# :: Int# -> Int16#
+ intToInt32# :: Int# -> Int32#
+ intToInt64# :: Int# -> Int64#
+ intToInt8# :: Int# -> Int8#
+ isByteArrayPinned# :: ByteArray# -> Int#
+ 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 #)
+ maxTupleSize :: Int
+ minusAddr# :: Addr# -> Addr# -> Int#
+ minusDoubleX2# :: DoubleX2# -> DoubleX2# -> DoubleX2#
+ minusDoubleX4# :: DoubleX4# -> DoubleX4# -> DoubleX4#
+ minusDoubleX8# :: DoubleX8# -> DoubleX8# -> DoubleX8#
+ minusFloat# :: Float# -> Float# -> Float#
+ minusFloatX16# :: FloatX16# -> FloatX16# -> FloatX16#
+ minusFloatX4# :: FloatX4# -> FloatX4# -> FloatX4#
+ minusFloatX8# :: FloatX8# -> FloatX8# -> FloatX8#
+ minusInt16X16# :: Int16X16# -> Int16X16# -> Int16X16#
+ minusInt16X32# :: Int16X32# -> Int16X32# -> Int16X32#
+ minusInt16X8# :: Int16X8# -> Int16X8# -> Int16X8#
+ minusInt32X16# :: Int32X16# -> Int32X16# -> Int32X16#
+ minusInt32X4# :: Int32X4# -> Int32X4# -> Int32X4#
+ minusInt32X8# :: Int32X8# -> Int32X8# -> Int32X8#
+ minusInt64X2# :: Int64X2# -> Int64X2# -> Int64X2#
+ minusInt64X4# :: Int64X4# -> Int64X4# -> Int64X4#
+ minusInt64X8# :: Int64X8# -> Int64X8# -> Int64X8#
+ minusInt8X16# :: Int8X16# -> Int8X16# -> Int8X16#
+ minusInt8X32# :: Int8X32# -> Int8X32# -> Int8X32#
+ minusInt8X64# :: Int8X64# -> Int8X64# -> Int8X64#
+ minusWord# :: Word# -> Word# -> Word#
+ minusWord16X16# :: Word16X16# -> Word16X16# -> Word16X16#
+ minusWord16X32# :: Word16X32# -> Word16X32# -> Word16X32#
+ minusWord16X8# :: Word16X8# -> Word16X8# -> Word16X8#
+ minusWord32X16# :: Word32X16# -> Word32X16# -> Word32X16#
+ minusWord32X4# :: Word32X4# -> Word32X4# -> Word32X4#
+ minusWord32X8# :: Word32X8# -> Word32X8# -> Word32X8#
+ minusWord64X2# :: Word64X2# -> Word64X2# -> Word64X2#
+ minusWord64X4# :: Word64X4# -> Word64X4# -> Word64X4#
+ minusWord64X8# :: Word64X8# -> Word64X8# -> Word64X8#
+ minusWord8X16# :: Word8X16# -> Word8X16# -> Word8X16#
+ minusWord8X32# :: Word8X32# -> Word8X32# -> Word8X32#
+ minusWord8X64# :: Word8X64# -> Word8X64# -> Word8X64#
+ mkApUpd0# :: forall a. BCO -> (# a #)
+ mkWeak# :: forall {l :: Levity} {k :: Levity} (a :: TYPE (BoxedRep l)) (b :: TYPE (BoxedRep k)) c. a -> b -> (State# RealWorld -> (# State# RealWorld, c #)) -> State# RealWorld -> (# State# RealWorld, Weak# b #)
+ mkWeakNoFinalizer# :: forall {l :: Levity} {k :: Levity} (a :: TYPE (BoxedRep l)) (b :: TYPE (BoxedRep k)). a -> b -> State# RealWorld -> (# State# RealWorld, Weak# b #)
+ mulIntMayOflo# :: Int# -> Int# -> Int#
+ mutableByteArrayContents# :: forall d. MutableByteArray# d -> Addr#
+ myThreadId# :: State# RealWorld -> (# State# RealWorld, ThreadId# #)
+ narrow16Int# :: Int# -> Int#
+ narrow16Word# :: Word# -> Word#
+ narrow32Int# :: Int# -> Int#
+ narrow32Word# :: Word# -> Word#
+ narrow8Int# :: Int# -> Int#
+ narrow8Word# :: Word# -> Word#
+ neAddr# :: Addr# -> Addr# -> Int#
+ neChar# :: Char# -> Char# -> Int#
+ neFloat# :: Float# -> Float# -> Int#
+ neInt16# :: Int16# -> Int16# -> Int#
+ neInt32# :: Int32# -> Int32# -> Int#
+ neInt64# :: Int64# -> Int64# -> Int#
+ neInt8# :: Int8# -> Int8# -> Int#
+ neWord# :: Word# -> Word# -> Int#
+ neWord16# :: Word16# -> Word16# -> Int#
+ neWord32# :: Word32# -> Word32# -> Int#
+ neWord64# :: Word64# -> Word64# -> Int#
+ neWord8# :: Word8# -> Word8# -> Int#
+ negateDouble# :: Double# -> Double#
+ negateDoubleX2# :: DoubleX2# -> DoubleX2#
+ negateDoubleX4# :: DoubleX4# -> DoubleX4#
+ negateDoubleX8# :: DoubleX8# -> DoubleX8#
+ negateFloat# :: Float# -> Float#
+ negateFloatX16# :: FloatX16# -> FloatX16#
+ negateFloatX4# :: FloatX4# -> FloatX4#
+ negateFloatX8# :: FloatX8# -> FloatX8#
+ negateInt# :: Int# -> Int#
+ negateInt16# :: Int16# -> Int16#
+ negateInt16X16# :: Int16X16# -> Int16X16#
+ negateInt16X32# :: Int16X32# -> Int16X32#
+ negateInt16X8# :: Int16X8# -> Int16X8#
+ negateInt32# :: Int32# -> Int32#
+ negateInt32X16# :: Int32X16# -> Int32X16#
+ negateInt32X4# :: Int32X4# -> Int32X4#
+ negateInt32X8# :: Int32X8# -> Int32X8#
+ negateInt64# :: Int64# -> Int64#
+ negateInt64X2# :: Int64X2# -> Int64X2#
+ negateInt64X4# :: Int64X4# -> Int64X4#
+ negateInt64X8# :: Int64X8# -> Int64X8#
+ negateInt8# :: Int8# -> Int8#
+ negateInt8X16# :: Int8X16# -> Int8X16#
+ negateInt8X32# :: Int8X32# -> Int8X32#
+ negateInt8X64# :: Int8X64# -> Int8X64#
+ newAlignedPinnedByteArray# :: forall d. Int# -> Int# -> State# d -> (# State# d, MutableByteArray# d #)
+ newArray# :: forall {l :: Levity} (a :: TYPE (BoxedRep l)) d. Int# -> a -> State# d -> (# State# d, MutableArray# d a #)
+ newArrayArray# :: forall s. Int# -> State# s -> (# State# s, MutableArrayArray# s #)
+ newBCO# :: forall a d. ByteArray# -> ByteArray# -> Array# a -> Int# -> ByteArray# -> State# d -> (# State# d, BCO #)
+ newByteArray# :: forall d. Int# -> State# d -> (# State# d, MutableByteArray# d #)
+ newIOPort# :: forall {l :: Levity} d (a :: TYPE (BoxedRep l)). State# d -> (# State# d, IOPort# d a #)
+ newMVar# :: forall {l :: Levity} d (a :: TYPE (BoxedRep l)). State# d -> (# State# d, MVar# d a #)
+ newMutVar# :: forall {l :: Levity} (a :: TYPE (BoxedRep l)) d. a -> State# d -> (# State# d, MutVar# d a #)
+ newPinnedByteArray# :: forall d. Int# -> State# d -> (# State# d, MutableByteArray# d #)
+ newPromptTag# :: forall a. State# RealWorld -> (# State# RealWorld, PromptTag# a #)
+ newSmallArray# :: forall {l :: Levity} (a :: TYPE (BoxedRep l)) d. Int# -> a -> State# d -> (# State# d, SmallMutableArray# d a #)
+ newTVar# :: forall {l :: Levity} (a :: TYPE (BoxedRep l)) d. a -> State# d -> (# State# d, TVar# d a #)
+ noDuplicate# :: forall d. State# d -> State# d
+ noinline :: forall a. a -> a
+ not# :: Word# -> Word#
+ not64# :: Word64# -> Word64#
+ notI# :: Int# -> Int#
+ notWord16# :: Word16# -> Word16#
+ notWord32# :: Word32# -> Word32#
+ notWord8# :: Word8# -> Word8#
+ nullAddr# :: Addr#
+ numSparks# :: forall d. State# d -> (# State# d, Int# #)
+ oneShot :: forall {q :: RuntimeRep} {r :: RuntimeRep} (a :: TYPE q) (b :: TYPE r). (a -> b) -> a -> b
+ or# :: Word# -> Word# -> Word#
+ or64# :: Word64# -> Word64# -> Word64#
+ orI# :: Int# -> Int# -> Int#
+ orWord16# :: Word16# -> Word16# -> Word16#
+ orWord32# :: Word32# -> Word32# -> Word32#
+ orWord8# :: Word8# -> Word8# -> Word8#
+ ord# :: Char# -> Int#
+ packDoubleX2# :: (# Double#, Double# #) -> DoubleX2#
+ packDoubleX4# :: (# Double#, Double#, Double#, Double# #) -> DoubleX4#
+ packDoubleX8# :: (# Double#, Double#, Double#, Double#, Double#, Double#, Double#, Double# #) -> DoubleX8#
+ packFloatX16# :: (# Float#, Float#, Float#, Float#, Float#, Float#, Float#, Float#, Float#, Float#, Float#, Float#, Float#, Float#, Float#, Float# #) -> FloatX16#
+ packFloatX4# :: (# Float#, Float#, Float#, Float# #) -> FloatX4#
+ packFloatX8# :: (# Float#, Float#, Float#, Float#, Float#, Float#, Float#, Float# #) -> FloatX8#
+ packInt16X16# :: (# Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16# #) -> Int16X16#
+ packInt16X32# :: (# Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16# #) -> Int16X32#
+ packInt16X8# :: (# Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16#, Int16# #) -> Int16X8#
+ packInt32X16# :: (# Int32#, Int32#, Int32#, Int32#, Int32#, Int32#, Int32#, Int32#, Int32#, Int32#, Int32#, Int32#, Int32#, Int32#, Int32#, Int32# #) -> Int32X16#
+ packInt32X4# :: (# Int32#, Int32#, Int32#, Int32# #) -> Int32X4#
+ packInt32X8# :: (# Int32#, Int32#, Int32#, Int32#, Int32#, Int32#, Int32#, Int32# #) -> Int32X8#
+ packInt64X2# :: (# Int64#, Int64# #) -> Int64X2#
+ packInt64X4# :: (# Int64#, Int64#, Int64#, Int64# #) -> Int64X4#
+ packInt64X8# :: (# Int64#, Int64#, Int64#, Int64#, Int64#, Int64#, Int64#, Int64# #) -> Int64X8#
+ packInt8X16# :: (# Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8# #) -> Int8X16#
+ packInt8X32# :: (# Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8# #) -> Int8X32#
+ packInt8X64# :: (# Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8#, Int8# #) -> Int8X64#
+ packWord16X16# :: (# Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16# #) -> Word16X16#
+ packWord16X32# :: (# Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16# #) -> Word16X32#
+ packWord16X8# :: (# Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16#, Word16# #) -> Word16X8#
+ packWord32X16# :: (# Word32#, Word32#, Word32#, Word32#, Word32#, Word32#, Word32#, Word32#, Word32#, Word32#, Word32#, Word32#, Word32#, Word32#, Word32#, Word32# #) -> Word32X16#
+ packWord32X4# :: (# Word32#, Word32#, Word32#, Word32# #) -> Word32X4#
+ packWord32X8# :: (# Word32#, Word32#, Word32#, Word32#, Word32#, Word32#, Word32#, Word32# #) -> Word32X8#
+ packWord64X2# :: (# Word64#, Word64# #) -> Word64X2#
+ packWord64X4# :: (# Word64#, Word64#, Word64#, Word64# #) -> Word64X4#
+ packWord64X8# :: (# Word64#, Word64#, Word64#, Word64#, Word64#, Word64#, Word64#, Word64# #) -> Word64X8#
+ packWord8X16# :: (# Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8# #) -> Word8X16#
+ packWord8X32# :: (# Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8# #) -> Word8X32#
+ packWord8X64# :: (# Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8#, Word8# #) -> Word8X64#
+ par# :: forall a. a -> Int#
+ pdep# :: Word# -> Word# -> Word#
+ pdep16# :: Word# -> Word# -> Word#
+ pdep32# :: Word# -> Word# -> Word#
+ pdep64# :: Word64# -> Word64# -> Word64#
+ pdep8# :: Word# -> Word# -> Word#
+ pext# :: Word# -> Word# -> Word#
+ pext16# :: Word# -> Word# -> Word#
+ pext32# :: Word# -> Word# -> Word#
+ pext64# :: Word64# -> Word64# -> Word64#
+ pext8# :: Word# -> Word# -> Word#
+ plusAddr# :: Addr# -> Int# -> Addr#
+ plusDoubleX2# :: DoubleX2# -> DoubleX2# -> DoubleX2#
+ plusDoubleX4# :: DoubleX4# -> DoubleX4# -> DoubleX4#
+ plusDoubleX8# :: DoubleX8# -> DoubleX8# -> DoubleX8#
+ plusFloat# :: Float# -> Float# -> Float#
+ plusFloatX16# :: FloatX16# -> FloatX16# -> FloatX16#
+ plusFloatX4# :: FloatX4# -> FloatX4# -> FloatX4#
+ plusFloatX8# :: FloatX8# -> FloatX8# -> FloatX8#
+ plusInt16# :: Int16# -> Int16# -> Int16#
+ plusInt16X16# :: Int16X16# -> Int16X16# -> Int16X16#
+ plusInt16X32# :: Int16X32# -> Int16X32# -> Int16X32#
+ plusInt16X8# :: Int16X8# -> Int16X8# -> Int16X8#
+ plusInt32# :: Int32# -> Int32# -> Int32#
+ plusInt32X16# :: Int32X16# -> Int32X16# -> Int32X16#
+ plusInt32X4# :: Int32X4# -> Int32X4# -> Int32X4#
+ plusInt32X8# :: Int32X8# -> Int32X8# -> Int32X8#
+ plusInt64# :: Int64# -> Int64# -> Int64#
+ plusInt64X2# :: Int64X2# -> Int64X2# -> Int64X2#
+ plusInt64X4# :: Int64X4# -> Int64X4# -> Int64X4#
+ plusInt64X8# :: Int64X8# -> Int64X8# -> Int64X8#
+ plusInt8# :: Int8# -> Int8# -> Int8#
+ plusInt8X16# :: Int8X16# -> Int8X16# -> Int8X16#
+ plusInt8X32# :: Int8X32# -> Int8X32# -> Int8X32#
+ plusInt8X64# :: Int8X64# -> Int8X64# -> Int8X64#
+ plusWord# :: Word# -> Word# -> Word#
+ plusWord16# :: Word16# -> Word16# -> Word16#
+ plusWord16X16# :: Word16X16# -> Word16X16# -> Word16X16#
+ plusWord16X32# :: Word16X32# -> Word16X32# -> Word16X32#
+ plusWord16X8# :: Word16X8# -> Word16X8# -> Word16X8#
+ plusWord2# :: Word# -> Word# -> (# Word#, Word# #)
+ plusWord32# :: Word32# -> Word32# -> Word32#
+ plusWord32X16# :: Word32X16# -> Word32X16# -> Word32X16#
+ plusWord32X4# :: Word32X4# -> Word32X4# -> Word32X4#
+ plusWord32X8# :: Word32X8# -> Word32X8# -> Word32X8#
+ plusWord64# :: Word64# -> Word64# -> Word64#
+ plusWord64X2# :: Word64X2# -> Word64X2# -> Word64X2#
+ plusWord64X4# :: Word64X4# -> Word64X4# -> Word64X4#
+ plusWord64X8# :: Word64X8# -> Word64X8# -> Word64X8#
+ plusWord8# :: Word8# -> Word8# -> Word8#
+ plusWord8X16# :: Word8X16# -> Word8X16# -> Word8X16#
+ plusWord8X32# :: Word8X32# -> Word8X32# -> Word8X32#
+ plusWord8X64# :: Word8X64# -> Word8X64# -> Word8X64#
+ popCnt# :: Word# -> Word#
+ popCnt16# :: Word# -> Word#
+ popCnt32# :: Word# -> Word#
+ popCnt64# :: Word64# -> Word#
+ popCnt8# :: Word# -> Word#
+ powerFloat# :: Float# -> Float# -> Float#
+ prefetchAddr0# :: forall d. Addr# -> Int# -> State# d -> State# d
+ prefetchAddr1# :: forall d. Addr# -> Int# -> State# d -> State# d
+ prefetchAddr2# :: forall d. Addr# -> Int# -> State# d -> State# d
+ prefetchAddr3# :: forall d. Addr# -> Int# -> State# d -> State# d
+ prefetchByteArray0# :: forall d. ByteArray# -> Int# -> State# d -> State# d
+ prefetchByteArray1# :: forall d. ByteArray# -> Int# -> State# d -> State# d
+ prefetchByteArray2# :: forall d. ByteArray# -> Int# -> State# d -> State# d
+ prefetchByteArray3# :: forall d. ByteArray# -> Int# -> State# d -> State# d
+ prefetchMutableByteArray0# :: forall d. MutableByteArray# d -> Int# -> State# d -> State# d
+ prefetchMutableByteArray1# :: forall d. MutableByteArray# d -> Int# -> State# d -> State# d
+ prefetchMutableByteArray2# :: forall d. MutableByteArray# d -> Int# -> State# d -> State# d
+ prefetchMutableByteArray3# :: forall d. MutableByteArray# d -> Int# -> State# d -> State# d
+ prefetchValue0# :: forall a d. a -> State# d -> State# d
+ prefetchValue1# :: forall a d. a -> State# d -> State# d
+ prefetchValue2# :: forall a d. a -> State# d -> State# d
+ prefetchValue3# :: forall a d. a -> State# d -> State# d
+ prompt# :: forall a. PromptTag# a -> (State# RealWorld -> (# State# RealWorld, a #)) -> State# RealWorld -> (# State# RealWorld, a #)
+ proxy# :: forall {k} (a :: k). Proxy# a
+ putMVar# :: forall {l :: Levity} d (a :: TYPE (BoxedRep l)). MVar# d a -> a -> State# d -> State# d
+ quotInt# :: Int# -> Int# -> Int#
+ quotInt16# :: Int16# -> Int16# -> Int16#
+ quotInt16X16# :: Int16X16# -> Int16X16# -> Int16X16#
+ quotInt16X32# :: Int16X32# -> Int16X32# -> Int16X32#
+ quotInt16X8# :: Int16X8# -> Int16X8# -> Int16X8#
+ quotInt32# :: Int32# -> Int32# -> Int32#
+ quotInt32X16# :: Int32X16# -> Int32X16# -> Int32X16#
+ quotInt32X4# :: Int32X4# -> Int32X4# -> Int32X4#
+ quotInt32X8# :: Int32X8# -> Int32X8# -> Int32X8#
+ quotInt64# :: Int64# -> Int64# -> Int64#
+ quotInt64X2# :: Int64X2# -> Int64X2# -> Int64X2#
+ quotInt64X4# :: Int64X4# -> Int64X4# -> Int64X4#
+ quotInt64X8# :: Int64X8# -> Int64X8# -> Int64X8#
+ quotInt8# :: Int8# -> Int8# -> Int8#
+ quotInt8X16# :: Int8X16# -> Int8X16# -> Int8X16#
+ quotInt8X32# :: Int8X32# -> Int8X32# -> Int8X32#
+ quotInt8X64# :: Int8X64# -> Int8X64# -> Int8X64#
+ quotRemInt# :: Int# -> Int# -> (# Int#, Int# #)
+ quotRemInt16# :: Int16# -> Int16# -> (# Int16#, Int16# #)
+ quotRemInt32# :: Int32# -> Int32# -> (# Int32#, Int32# #)
+ quotRemInt8# :: Int8# -> Int8# -> (# Int8#, Int8# #)
+ quotRemWord# :: Word# -> Word# -> (# Word#, Word# #)
+ quotRemWord16# :: Word16# -> Word16# -> (# Word16#, Word16# #)
+ quotRemWord2# :: Word# -> Word# -> Word# -> (# Word#, Word# #)
+ quotRemWord32# :: Word32# -> Word32# -> (# Word32#, Word32# #)
+ quotRemWord8# :: Word8# -> Word8# -> (# Word8#, Word8# #)
+ quotWord# :: Word# -> Word# -> Word#
+ quotWord16# :: Word16# -> Word16# -> Word16#
+ quotWord16X16# :: Word16X16# -> Word16X16# -> Word16X16#
+ quotWord16X32# :: Word16X32# -> Word16X32# -> Word16X32#
+ quotWord16X8# :: Word16X8# -> Word16X8# -> Word16X8#
+ quotWord32# :: Word32# -> Word32# -> Word32#
+ quotWord32X16# :: Word32X16# -> Word32X16# -> Word32X16#
+ quotWord32X4# :: Word32X4# -> Word32X4# -> Word32X4#
+ quotWord32X8# :: Word32X8# -> Word32X8# -> Word32X8#
+ quotWord64# :: Word64# -> Word64# -> Word64#
+ quotWord64X2# :: Word64X2# -> Word64X2# -> Word64X2#
+ quotWord64X4# :: Word64X4# -> Word64X4# -> Word64X4#
+ quotWord64X8# :: Word64X8# -> Word64X8# -> Word64X8#
+ quotWord8# :: Word8# -> Word8# -> Word8#
+ quotWord8X16# :: Word8X16# -> Word8X16# -> Word8X16#
+ quotWord8X32# :: Word8X32# -> Word8X32# -> Word8X32#
+ quotWord8X64# :: Word8X64# -> Word8X64# -> Word8X64#
+ raise# :: forall {l :: Levity} {r :: RuntimeRep} (a :: TYPE (BoxedRep l)) (b :: TYPE r). a -> b
+ raiseDivZero# :: forall {r :: RuntimeRep} (b :: TYPE r). (# #) -> b
+ raiseIO# :: forall {l :: Levity} {r :: RuntimeRep} (a :: TYPE (BoxedRep l)) (b :: TYPE r). a -> State# RealWorld -> (# State# RealWorld, b #)
+ raiseOverflow# :: forall {r :: RuntimeRep} (b :: TYPE r). (# #) -> b
+ raiseUnderflow# :: forall {r :: RuntimeRep} (b :: TYPE r). (# #) -> b
+ readAddrArray# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Addr# #)
+ readAddrOffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Addr# #)
+ readArray# :: forall {l :: Levity} d (a :: TYPE (BoxedRep l)). MutableArray# d a -> Int# -> State# d -> (# State# d, a #)
+ readArrayArrayArray# :: forall s. MutableArrayArray# s -> Int# -> State# s -> (# State# s, ArrayArray# #)
+ readByteArrayArray# :: forall s. MutableArrayArray# s -> Int# -> State# s -> (# State# s, ByteArray# #)
+ readCharArray# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Char# #)
+ readCharOffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Char# #)
+ readDoubleArray# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Double# #)
+ readDoubleArrayAsDoubleX2# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, DoubleX2# #)
+ readDoubleArrayAsDoubleX4# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, DoubleX4# #)
+ readDoubleArrayAsDoubleX8# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, DoubleX8# #)
+ readDoubleOffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Double# #)
+ readDoubleOffAddrAsDoubleX2# :: forall d. Addr# -> Int# -> State# d -> (# State# d, DoubleX2# #)
+ readDoubleOffAddrAsDoubleX4# :: forall d. Addr# -> Int# -> State# d -> (# State# d, DoubleX4# #)
+ readDoubleOffAddrAsDoubleX8# :: forall d. Addr# -> Int# -> State# d -> (# State# d, DoubleX8# #)
+ readDoubleX2Array# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, DoubleX2# #)
+ readDoubleX2OffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, DoubleX2# #)
+ readDoubleX4Array# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, DoubleX4# #)
+ readDoubleX4OffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, DoubleX4# #)
+ readDoubleX8Array# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, DoubleX8# #)
+ readDoubleX8OffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, DoubleX8# #)
+ readFloatArray# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Float# #)
+ readFloatArrayAsFloatX16# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, FloatX16# #)
+ readFloatArrayAsFloatX4# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, FloatX4# #)
+ readFloatArrayAsFloatX8# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, FloatX8# #)
+ readFloatOffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Float# #)
+ readFloatOffAddrAsFloatX16# :: forall d. Addr# -> Int# -> State# d -> (# State# d, FloatX16# #)
+ readFloatOffAddrAsFloatX4# :: forall d. Addr# -> Int# -> State# d -> (# State# d, FloatX4# #)
+ readFloatOffAddrAsFloatX8# :: forall d. Addr# -> Int# -> State# d -> (# State# d, FloatX8# #)
+ readFloatX16Array# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, FloatX16# #)
+ readFloatX16OffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, FloatX16# #)
+ readFloatX4Array# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, FloatX4# #)
+ readFloatX4OffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, FloatX4# #)
+ readFloatX8Array# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, FloatX8# #)
+ readFloatX8OffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, FloatX8# #)
+ readIOPort# :: forall {l :: Levity} d (a :: TYPE (BoxedRep l)). IOPort# d a -> State# d -> (# State# d, a #)
+ readInt16Array# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Int16# #)
+ readInt16ArrayAsInt16X16# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Int16X16# #)
+ readInt16ArrayAsInt16X32# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Int16X32# #)
+ readInt16ArrayAsInt16X8# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Int16X8# #)
+ readInt16OffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Int16# #)
+ readInt16OffAddrAsInt16X16# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Int16X16# #)
+ readInt16OffAddrAsInt16X32# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Int16X32# #)
+ readInt16OffAddrAsInt16X8# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Int16X8# #)
+ readInt16X16Array# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Int16X16# #)
+ readInt16X16OffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Int16X16# #)
+ readInt16X32Array# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Int16X32# #)
+ readInt16X32OffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Int16X32# #)
+ readInt16X8Array# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Int16X8# #)
+ readInt16X8OffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Int16X8# #)
+ readInt32Array# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Int32# #)
+ readInt32ArrayAsInt32X16# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Int32X16# #)
+ readInt32ArrayAsInt32X4# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Int32X4# #)
+ readInt32ArrayAsInt32X8# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Int32X8# #)
+ readInt32OffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Int32# #)
+ readInt32OffAddrAsInt32X16# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Int32X16# #)
+ readInt32OffAddrAsInt32X4# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Int32X4# #)
+ readInt32OffAddrAsInt32X8# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Int32X8# #)
+ readInt32X16Array# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Int32X16# #)
+ readInt32X16OffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Int32X16# #)
+ readInt32X4Array# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Int32X4# #)
+ readInt32X4OffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Int32X4# #)
+ readInt32X8Array# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Int32X8# #)
+ readInt32X8OffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Int32X8# #)
+ readInt64Array# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Int64# #)
+ readInt64ArrayAsInt64X2# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Int64X2# #)
+ readInt64ArrayAsInt64X4# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Int64X4# #)
+ readInt64ArrayAsInt64X8# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Int64X8# #)
+ readInt64OffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Int64# #)
+ readInt64OffAddrAsInt64X2# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Int64X2# #)
+ readInt64OffAddrAsInt64X4# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Int64X4# #)
+ readInt64OffAddrAsInt64X8# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Int64X8# #)
+ readInt64X2Array# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Int64X2# #)
+ readInt64X2OffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Int64X2# #)
+ readInt64X4Array# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Int64X4# #)
+ readInt64X4OffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Int64X4# #)
+ readInt64X8Array# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Int64X8# #)
+ readInt64X8OffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Int64X8# #)
+ readInt8Array# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Int8# #)
+ readInt8ArrayAsInt8X16# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Int8X16# #)
+ readInt8ArrayAsInt8X32# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Int8X32# #)
+ readInt8ArrayAsInt8X64# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Int8X64# #)
+ readInt8OffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Int8# #)
+ readInt8OffAddrAsInt8X16# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Int8X16# #)
+ readInt8OffAddrAsInt8X32# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Int8X32# #)
+ readInt8OffAddrAsInt8X64# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Int8X64# #)
+ readInt8X16Array# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Int8X16# #)
+ readInt8X16OffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Int8X16# #)
+ readInt8X32Array# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Int8X32# #)
+ readInt8X32OffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Int8X32# #)
+ readInt8X64Array# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Int8X64# #)
+ readInt8X64OffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Int8X64# #)
+ readIntArray# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Int# #)
+ readIntOffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Int# #)
+ readMVar# :: forall {l :: Levity} d (a :: TYPE (BoxedRep l)). MVar# d a -> State# d -> (# State# d, a #)
+ readMutVar# :: forall {l :: Levity} d (a :: TYPE (BoxedRep l)). MutVar# d a -> State# d -> (# State# d, a #)
+ readMutableArrayArrayArray# :: forall s. MutableArrayArray# s -> Int# -> State# s -> (# State# s, MutableArrayArray# s #)
+ readMutableByteArrayArray# :: forall s. MutableArrayArray# s -> Int# -> State# s -> (# State# s, MutableByteArray# s #)
+ readSmallArray# :: forall {l :: Levity} d (a :: TYPE (BoxedRep l)). SmallMutableArray# d a -> Int# -> State# d -> (# State# d, a #)
+ readStablePtrArray# :: forall d a. MutableByteArray# d -> Int# -> State# d -> (# State# d, StablePtr# a #)
+ readStablePtrOffAddr# :: forall d a. Addr# -> Int# -> State# d -> (# State# d, StablePtr# a #)
+ readTVar# :: forall {l :: Levity} d (a :: TYPE (BoxedRep l)). TVar# d a -> State# d -> (# State# d, a #)
+ readTVarIO# :: forall {l :: Levity} d (a :: TYPE (BoxedRep l)). TVar# d a -> State# d -> (# State# d, a #)
+ readWideCharArray# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Char# #)
+ readWideCharOffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Char# #)
+ readWord16Array# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Word16# #)
+ readWord16ArrayAsWord16X16# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Word16X16# #)
+ readWord16ArrayAsWord16X32# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Word16X32# #)
+ readWord16ArrayAsWord16X8# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Word16X8# #)
+ readWord16OffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Word16# #)
+ readWord16OffAddrAsWord16X16# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Word16X16# #)
+ readWord16OffAddrAsWord16X32# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Word16X32# #)
+ readWord16OffAddrAsWord16X8# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Word16X8# #)
+ readWord16X16Array# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Word16X16# #)
+ readWord16X16OffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Word16X16# #)
+ readWord16X32Array# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Word16X32# #)
+ readWord16X32OffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Word16X32# #)
+ readWord16X8Array# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Word16X8# #)
+ readWord16X8OffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Word16X8# #)
+ readWord32Array# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Word32# #)
+ readWord32ArrayAsWord32X16# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Word32X16# #)
+ readWord32ArrayAsWord32X4# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Word32X4# #)
+ readWord32ArrayAsWord32X8# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Word32X8# #)
+ readWord32OffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Word32# #)
+ readWord32OffAddrAsWord32X16# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Word32X16# #)
+ readWord32OffAddrAsWord32X4# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Word32X4# #)
+ readWord32OffAddrAsWord32X8# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Word32X8# #)
+ readWord32X16Array# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Word32X16# #)
+ readWord32X16OffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Word32X16# #)
+ readWord32X4Array# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Word32X4# #)
+ readWord32X4OffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Word32X4# #)
+ readWord32X8Array# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Word32X8# #)
+ readWord32X8OffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Word32X8# #)
+ readWord64Array# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Word64# #)
+ readWord64ArrayAsWord64X2# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Word64X2# #)
+ readWord64ArrayAsWord64X4# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Word64X4# #)
+ readWord64ArrayAsWord64X8# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Word64X8# #)
+ readWord64OffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Word64# #)
+ readWord64OffAddrAsWord64X2# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Word64X2# #)
+ readWord64OffAddrAsWord64X4# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Word64X4# #)
+ readWord64OffAddrAsWord64X8# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Word64X8# #)
+ readWord64X2Array# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Word64X2# #)
+ readWord64X2OffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Word64X2# #)
+ readWord64X4Array# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Word64X4# #)
+ readWord64X4OffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Word64X4# #)
+ readWord64X8Array# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Word64X8# #)
+ readWord64X8OffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Word64X8# #)
+ readWord8Array# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Word8# #)
+ readWord8ArrayAsAddr# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Addr# #)
+ readWord8ArrayAsChar# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Char# #)
+ readWord8ArrayAsDouble# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Double# #)
+ readWord8ArrayAsFloat# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Float# #)
+ readWord8ArrayAsInt# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Int# #)
+ readWord8ArrayAsInt16# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Int16# #)
+ readWord8ArrayAsInt32# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Int32# #)
+ readWord8ArrayAsInt64# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Int64# #)
+ readWord8ArrayAsStablePtr# :: forall d a. MutableByteArray# d -> Int# -> State# d -> (# State# d, StablePtr# a #)
+ readWord8ArrayAsWideChar# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Char# #)
+ readWord8ArrayAsWord# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Word# #)
+ readWord8ArrayAsWord16# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Word16# #)
+ readWord8ArrayAsWord32# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Word32# #)
+ readWord8ArrayAsWord64# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Word64# #)
+ readWord8ArrayAsWord8X16# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Word8X16# #)
+ readWord8ArrayAsWord8X32# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Word8X32# #)
+ readWord8ArrayAsWord8X64# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Word8X64# #)
+ readWord8OffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Word8# #)
+ readWord8OffAddrAsAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Addr# #)
+ readWord8OffAddrAsChar# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Char# #)
+ readWord8OffAddrAsDouble# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Double# #)
+ readWord8OffAddrAsFloat# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Float# #)
+ readWord8OffAddrAsInt# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Int# #)
+ readWord8OffAddrAsInt16# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Int16# #)
+ readWord8OffAddrAsInt32# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Int32# #)
+ readWord8OffAddrAsInt64# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Int64# #)
+ readWord8OffAddrAsStablePtr# :: forall d a. Addr# -> Int# -> State# d -> (# State# d, StablePtr# a #)
+ readWord8OffAddrAsWideChar# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Char# #)
+ readWord8OffAddrAsWord# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Word# #)
+ readWord8OffAddrAsWord16# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Word16# #)
+ readWord8OffAddrAsWord32# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Word32# #)
+ readWord8OffAddrAsWord64# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Word64# #)
+ readWord8OffAddrAsWord8X16# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Word8X16# #)
+ readWord8OffAddrAsWord8X32# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Word8X32# #)
+ readWord8OffAddrAsWord8X64# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Word8X64# #)
+ readWord8X16Array# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Word8X16# #)
+ readWord8X16OffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Word8X16# #)
+ readWord8X32Array# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Word8X32# #)
+ readWord8X32OffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Word8X32# #)
+ readWord8X64Array# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Word8X64# #)
+ readWord8X64OffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Word8X64# #)
+ readWordArray# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, Word# #)
+ readWordOffAddr# :: forall d. Addr# -> Int# -> State# d -> (# State# d, Word# #)
+ realWorld# :: State# RealWorld
+ reallyUnsafePtrEquality :: forall a. a -> a -> Int#
+ reallyUnsafePtrEquality# :: forall {l :: Levity} {k :: Levity} (a :: TYPE (BoxedRep l)) (b :: TYPE (BoxedRep k)). a -> b -> Int#
+ remAddr# :: Addr# -> Int# -> Int#
+ remInt# :: Int# -> Int# -> Int#
+ remInt16# :: Int16# -> Int16# -> Int16#
+ remInt16X16# :: Int16X16# -> Int16X16# -> Int16X16#
+ remInt16X32# :: Int16X32# -> Int16X32# -> Int16X32#
+ remInt16X8# :: Int16X8# -> Int16X8# -> Int16X8#
+ remInt32# :: Int32# -> Int32# -> Int32#
+ remInt32X16# :: Int32X16# -> Int32X16# -> Int32X16#
+ remInt32X4# :: Int32X4# -> Int32X4# -> Int32X4#
+ remInt32X8# :: Int32X8# -> Int32X8# -> Int32X8#
+ remInt64# :: Int64# -> Int64# -> Int64#
+ remInt64X2# :: Int64X2# -> Int64X2# -> Int64X2#
+ remInt64X4# :: Int64X4# -> Int64X4# -> Int64X4#
+ remInt64X8# :: Int64X8# -> Int64X8# -> Int64X8#
+ remInt8# :: Int8# -> Int8# -> Int8#
+ remInt8X16# :: Int8X16# -> Int8X16# -> Int8X16#
+ remInt8X32# :: Int8X32# -> Int8X32# -> Int8X32#
+ remInt8X64# :: Int8X64# -> Int8X64# -> Int8X64#
+ remWord# :: Word# -> Word# -> Word#
+ remWord16# :: Word16# -> Word16# -> Word16#
+ remWord16X16# :: Word16X16# -> Word16X16# -> Word16X16#
+ remWord16X32# :: Word16X32# -> Word16X32# -> Word16X32#
+ remWord16X8# :: Word16X8# -> Word16X8# -> Word16X8#
+ remWord32# :: Word32# -> Word32# -> Word32#
+ remWord32X16# :: Word32X16# -> Word32X16# -> Word32X16#
+ remWord32X4# :: Word32X4# -> Word32X4# -> Word32X4#
+ remWord32X8# :: Word32X8# -> Word32X8# -> Word32X8#
+ remWord64# :: Word64# -> Word64# -> Word64#
+ remWord64X2# :: Word64X2# -> Word64X2# -> Word64X2#
+ remWord64X4# :: Word64X4# -> Word64X4# -> Word64X4#
+ remWord64X8# :: Word64X8# -> Word64X8# -> Word64X8#
+ remWord8# :: Word8# -> Word8# -> Word8#
+ remWord8X16# :: Word8X16# -> Word8X16# -> Word8X16#
+ remWord8X32# :: Word8X32# -> Word8X32# -> Word8X32#
+ remWord8X64# :: Word8X64# -> Word8X64# -> Word8X64#
+ resizeMutableByteArray# :: forall d. MutableByteArray# d -> Int# -> State# d -> (# State# d, MutableByteArray# d #)
+ resizeSmallMutableArray# :: forall s a. SmallMutableArray# s a -> Int# -> a -> State# s -> (# State# s, SmallMutableArray# s a #)
+ retry# :: forall {l :: Levity} (a :: TYPE (BoxedRep l)). State# RealWorld -> (# State# RealWorld, a #)
+ rightSection :: forall {q :: RuntimeRep} {r :: RuntimeRep} {s :: RuntimeRep} (a :: TYPE q) (b :: TYPE r) (c :: TYPE s). (a -> b -> c) -> b -> a -> c
+ runRW# :: forall (r :: RuntimeRep) (o :: TYPE r). (State# RealWorld -> o) -> o
+ sameArray# :: forall {l :: Levity} (a :: TYPE (BoxedRep l)). Array# a -> Array# a -> Int#
+ sameArrayArray# :: ArrayArray# -> ArrayArray# -> Int#
+ sameByteArray# :: ByteArray# -> ByteArray# -> Int#
+ sameIOPort# :: forall {l :: Levity} s (a :: TYPE (BoxedRep l)). IOPort# s a -> IOPort# s a -> Int#
+ sameMVar# :: forall {l :: Levity} s (a :: TYPE (BoxedRep l)). MVar# s a -> MVar# s a -> Int#
+ sameMutVar# :: forall {l :: Levity} s (a :: TYPE (BoxedRep l)). MutVar# s a -> MutVar# s a -> Int#
+ sameMutableArray# :: forall {l :: Levity} s (a :: TYPE (BoxedRep l)). MutableArray# s a -> MutableArray# s a -> Int#
+ sameMutableArrayArray# :: forall s. MutableArrayArray# s -> MutableArrayArray# s -> Int#
+ sameMutableByteArray# :: forall s. MutableByteArray# s -> MutableByteArray# s -> Int#
+ samePromptTag# :: forall a. PromptTag# a -> PromptTag# a -> Int#
+ sameSmallArray# :: forall {l :: Levity} (a :: TYPE (BoxedRep l)). SmallArray# a -> SmallArray# a -> Int#
+ sameSmallMutableArray# :: forall {l :: Levity} s (a :: TYPE (BoxedRep l)). SmallMutableArray# s a -> SmallMutableArray# s a -> Int#
+ sameTVar# :: forall {l :: Levity} s (a :: TYPE (BoxedRep l)). TVar# s a -> TVar# s a -> Int#
+ seq :: forall {r :: RuntimeRep} a (b :: TYPE r). a -> b -> b
+ seq# :: forall a 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
+ 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 +10372,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 +10485,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 +10517,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/3c32c0602eac46602fb8c86088ba7e430d5f2fc6
--
View it on GitLab: https://gitlab.haskell.org/ghc/ghc/-/commit/3c32c0602eac46602fb8c86088ba7e430d5f2fc6
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/20240923/d438087d/attachment-0001.html>
More information about the ghc-commits
mailing list