Copyright	(c) Alexey Kuleshevich 2020
License	BSD3
Maintainer	Alexey Kuleshevich <alexey@kuleshevi.ch>
Stability	experimental
Portability	non-portable
Safe Haskell	None
Language	Haskell2010

Foreign.Prim

Contents

Missing primitives
Primitive
Backwards compatibility
Forward compatibility
Extra functionality
Re-exports

Description

Synopsis

unsafeThawByteArray# :: ByteArray# -> State# s -> (# State# s, MutableByteArray# s #)
mutableByteArrayContents# :: MutableByteArray# s -> Addr#
unsafeThawArrayArray# :: ArrayArray# -> State# s -> (# State# s, MutableArrayArray# s #)
unInt# :: Int -> Int#
unWord# :: Word -> Word#
touch# :: a -> State# s -> State# s
keepAlive# :: a -> (State# s -> (# State# s, r #)) -> State# s -> (# State# s, r #)
indexWord8ArrayAsChar# :: ByteArray# -> Int# -> Char#
readWord8ArrayAsChar# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Char# #)
writeWord8ArrayAsChar# :: MutableByteArray# d -> Int# -> Char# -> State# d -> State# d
indexWord8ArrayAsWideChar# :: ByteArray# -> Int# -> Char#
readWord8ArrayAsWideChar# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Char# #)
writeWord8ArrayAsWideChar# :: MutableByteArray# d -> Int# -> Char# -> State# d -> State# d
indexWord8ArrayAsAddr# :: ByteArray# -> Int# -> Addr#
readWord8ArrayAsAddr# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Addr# #)
writeWord8ArrayAsAddr# :: MutableByteArray# d -> Int# -> Addr# -> State# d -> State# d
indexWord8ArrayAsStablePtr# :: ByteArray# -> Int# -> StablePtr# a
readWord8ArrayAsStablePtr# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, StablePtr# a #)
writeWord8ArrayAsStablePtr# :: MutableByteArray# d -> Int# -> StablePtr# a -> State# d -> State# d
indexWord8ArrayAsFloat# :: ByteArray# -> Int# -> Float#
readWord8ArrayAsFloat# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Float# #)
writeWord8ArrayAsFloat# :: MutableByteArray# d -> Int# -> Float# -> State# d -> State# d
indexWord8ArrayAsDouble# :: ByteArray# -> Int# -> Double#
readWord8ArrayAsDouble# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Double# #)
writeWord8ArrayAsDouble# :: MutableByteArray# d -> Int# -> Double# -> State# d -> State# d
indexWord8ArrayAsInt16# :: ByteArray# -> Int# -> Int#
readWord8ArrayAsInt16# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int# #)
writeWord8ArrayAsInt16# :: MutableByteArray# d -> Int# -> Int# -> State# d -> State# d
indexWord8ArrayAsInt32# :: ByteArray# -> Int# -> Int#
readWord8ArrayAsInt32# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int# #)
writeWord8ArrayAsInt32# :: MutableByteArray# d -> Int# -> Int# -> State# d -> State# d
indexWord8ArrayAsInt64# :: ByteArray# -> Int# -> Int#
readWord8ArrayAsInt64# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int# #)
writeWord8ArrayAsInt64# :: MutableByteArray# d -> Int# -> Int# -> State# d -> State# d
indexWord8ArrayAsInt# :: ByteArray# -> Int# -> Int#
readWord8ArrayAsInt# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int# #)
writeWord8ArrayAsInt# :: MutableByteArray# d -> Int# -> Int# -> State# d -> State# d
indexWord8ArrayAsWord16# :: ByteArray# -> Int# -> Word#
readWord8ArrayAsWord16# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Word# #)
writeWord8ArrayAsWord16# :: MutableByteArray# d -> Int# -> Word# -> State# d -> State# d
indexWord8ArrayAsWord32# :: ByteArray# -> Int# -> Word#
readWord8ArrayAsWord32# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Word# #)
writeWord8ArrayAsWord32# :: MutableByteArray# d -> Int# -> Word# -> State# d -> State# d
indexWord8ArrayAsWord64# :: ByteArray# -> Int# -> Word#
readWord8ArrayAsWord64# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Word# #)
writeWord8ArrayAsWord64# :: MutableByteArray# d -> Int# -> Word# -> State# d -> State# d
indexWord8ArrayAsWord# :: ByteArray# -> Int# -> Word#
readWord8ArrayAsWord# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Word# #)
writeWord8ArrayAsWord# :: MutableByteArray# d -> Int# -> Word# -> State# d -> State# d
atomicModifyMutVar_# :: MutVar# d a -> (a -> a) -> State# d -> (# State# d, a, a #)
atomicModifyMutVar2# :: MutVar# d a -> (a -> c) -> State# d -> (# State# d, a, c #)
compareByteArrays# :: ByteArray# -> Int# -> ByteArray# -> Int# -> Int# -> Int#
newtype CBool = CBool Word8
isByteArrayPinned# :: ByteArray# -> Int#
isMutableByteArrayPinned# :: MutableByteArray# d -> Int#
getSizeofMutableByteArray# :: MutableByteArray# d -> State# d -> (# State# d, Int# #)
syncXorFetchNewWord64ArrayIO :: MutableByteArray# s -> Int# -> Word64 -> IO Word64
syncXorFetchNewWord64AddrIO :: Addr# -> Int# -> Word64 -> IO Word64
syncXorFetchNewInt64ArrayIO :: MutableByteArray# s -> Int# -> Int64 -> IO Int64
syncXorFetchNewInt64AddrIO :: Addr# -> Int# -> Int64 -> IO Int64
syncXorFetchOldWord64ArrayIO :: MutableByteArray# s -> Int# -> Word64 -> IO Word64
syncXorFetchOldWord64AddrIO :: Addr# -> Int# -> Word64 -> IO Word64
syncXorFetchOldInt64ArrayIO :: MutableByteArray# s -> Int# -> Int64 -> IO Int64
syncXorFetchOldInt64AddrIO :: Addr# -> Int# -> Int64 -> IO Int64
syncOrFetchNewWord64ArrayIO :: MutableByteArray# s -> Int# -> Word64 -> IO Word64
syncOrFetchNewWord64AddrIO :: Addr# -> Int# -> Word64 -> IO Word64
syncOrFetchNewInt64ArrayIO :: MutableByteArray# s -> Int# -> Int64 -> IO Int64
syncOrFetchNewInt64AddrIO :: Addr# -> Int# -> Int64 -> IO Int64
syncOrFetchOldWord64ArrayIO :: MutableByteArray# s -> Int# -> Word64 -> IO Word64
syncOrFetchOldWord64AddrIO :: Addr# -> Int# -> Word64 -> IO Word64
syncOrFetchOldInt64ArrayIO :: MutableByteArray# s -> Int# -> Int64 -> IO Int64
syncOrFetchOldInt64AddrIO :: Addr# -> Int# -> Int64 -> IO Int64
syncNandFetchNewWord64ArrayIO :: MutableByteArray# s -> Int# -> Word64 -> IO Word64
syncNandFetchNewWord64AddrIO :: Addr# -> Int# -> Word64 -> IO Word64
syncNandFetchNewInt64ArrayIO :: MutableByteArray# s -> Int# -> Int64 -> IO Int64
syncNandFetchNewInt64AddrIO :: Addr# -> Int# -> Int64 -> IO Int64
syncNandFetchOldWord64ArrayIO :: MutableByteArray# s -> Int# -> Word64 -> IO Word64
syncNandFetchOldWord64AddrIO :: Addr# -> Int# -> Word64 -> IO Word64
syncNandFetchOldInt64ArrayIO :: MutableByteArray# s -> Int# -> Int64 -> IO Int64
syncNandFetchOldInt64AddrIO :: Addr# -> Int# -> Int64 -> IO Int64
syncAndFetchNewWord64ArrayIO :: MutableByteArray# s -> Int# -> Word64 -> IO Word64
syncAndFetchNewWord64AddrIO :: Addr# -> Int# -> Word64 -> IO Word64
syncAndFetchNewInt64ArrayIO :: MutableByteArray# s -> Int# -> Int64 -> IO Int64
syncAndFetchNewInt64AddrIO :: Addr# -> Int# -> Int64 -> IO Int64
syncAndFetchOldWord64ArrayIO :: MutableByteArray# s -> Int# -> Word64 -> IO Word64
syncAndFetchOldWord64AddrIO :: Addr# -> Int# -> Word64 -> IO Word64
syncAndFetchOldInt64ArrayIO :: MutableByteArray# s -> Int# -> Int64 -> IO Int64
syncAndFetchOldInt64AddrIO :: Addr# -> Int# -> Int64 -> IO Int64
syncSubFetchNewWord64ArrayIO :: MutableByteArray# s -> Int# -> Word64 -> IO Word64
syncSubFetchNewWord64AddrIO :: Addr# -> Int# -> Word64 -> IO Word64
syncSubFetchNewInt64ArrayIO :: MutableByteArray# s -> Int# -> Int64 -> IO Int64
syncSubFetchNewInt64AddrIO :: Addr# -> Int# -> Int64 -> IO Int64
syncSubFetchOldWord64ArrayIO :: MutableByteArray# s -> Int# -> Word64 -> IO Word64
syncSubFetchOldWord64AddrIO :: Addr# -> Int# -> Word64 -> IO Word64
syncSubFetchOldInt64ArrayIO :: MutableByteArray# s -> Int# -> Int64 -> IO Int64
syncSubFetchOldInt64AddrIO :: Addr# -> Int# -> Int64 -> IO Int64
syncAddFetchNewWord64ArrayIO :: MutableByteArray# s -> Int# -> Word64 -> IO Word64
syncAddFetchNewWord64AddrIO :: Addr# -> Int# -> Word64 -> IO Word64
syncAddFetchNewInt64ArrayIO :: MutableByteArray# s -> Int# -> Int64 -> IO Int64
syncAddFetchNewInt64AddrIO :: Addr# -> Int# -> Int64 -> IO Int64
syncAddFetchOldWord64ArrayIO :: MutableByteArray# s -> Int# -> Word64 -> IO Word64
syncAddFetchOldWord64AddrIO :: Addr# -> Int# -> Word64 -> IO Word64
syncAddFetchOldInt64ArrayIO :: MutableByteArray# s -> Int# -> Int64 -> IO Int64
syncAddFetchOldInt64AddrIO :: Addr# -> Int# -> Int64 -> IO Int64
syncCasWord64ArrayIO :: MutableByteArray# s -> Int# -> Word64 -> Word64 -> IO Word64
syncCasWord64AddrIO :: Addr# -> Int# -> Word64 -> Word64 -> IO Word64
syncCasInt64ArrayIO :: MutableByteArray# s -> Int# -> Int64 -> Int64 -> IO Int64
syncCasInt64AddrIO :: Addr# -> Int# -> Int64 -> Int64 -> IO Int64
syncCasWord64BoolArrayIO :: MutableByteArray# s -> Int# -> Word64 -> Word64 -> IO CBool
syncCasWord64BoolAddrIO :: Addr# -> Int# -> Word64 -> Word64 -> IO CBool
syncCasInt64BoolArrayIO :: MutableByteArray# s -> Int# -> Int64 -> Int64 -> IO CBool
syncCasInt64BoolAddrIO :: Addr# -> Int# -> Int64 -> Int64 -> IO CBool
syncXorFetchNewWordArrayIO :: MutableByteArray# s -> Int# -> Word -> IO Word
syncXorFetchNewWordAddrIO :: Addr# -> Int# -> Word -> IO Word
syncXorFetchNewIntArrayIO :: MutableByteArray# s -> Int# -> Int -> IO Int
syncXorFetchNewIntAddrIO :: Addr# -> Int# -> Int -> IO Int
syncXorFetchOldWordArrayIO :: MutableByteArray# s -> Int# -> Word -> IO Word
syncXorFetchOldWordAddrIO :: Addr# -> Int# -> Word -> IO Word
syncXorFetchOldIntArrayIO :: MutableByteArray# s -> Int# -> Int -> IO Int
syncXorFetchOldIntAddrIO :: Addr# -> Int# -> Int -> IO Int
syncOrFetchNewWordArrayIO :: MutableByteArray# s -> Int# -> Word -> IO Word
syncOrFetchNewWordAddrIO :: Addr# -> Int# -> Word -> IO Word
syncOrFetchNewIntArrayIO :: MutableByteArray# s -> Int# -> Int -> IO Int
syncOrFetchNewIntAddrIO :: Addr# -> Int# -> Int -> IO Int
syncOrFetchOldWordArrayIO :: MutableByteArray# s -> Int# -> Word -> IO Word
syncOrFetchOldWordAddrIO :: Addr# -> Int# -> Word -> IO Word
syncOrFetchOldIntArrayIO :: MutableByteArray# s -> Int# -> Int -> IO Int
syncOrFetchOldIntAddrIO :: Addr# -> Int# -> Int -> IO Int
syncNandFetchNewWordArrayIO :: MutableByteArray# s -> Int# -> Word -> IO Word
syncNandFetchNewWordAddrIO :: Addr# -> Int# -> Word -> IO Word
syncNandFetchNewIntArrayIO :: MutableByteArray# s -> Int# -> Int -> IO Int
syncNandFetchNewIntAddrIO :: Addr# -> Int# -> Int -> IO Int
syncNandFetchOldWordArrayIO :: MutableByteArray# s -> Int# -> Word -> IO Word
syncNandFetchOldWordAddrIO :: Addr# -> Int# -> Word -> IO Word
syncNandFetchOldIntArrayIO :: MutableByteArray# s -> Int# -> Int -> IO Int
syncNandFetchOldIntAddrIO :: Addr# -> Int# -> Int -> IO Int
syncAndFetchNewWordArrayIO :: MutableByteArray# s -> Int# -> Word -> IO Word
syncAndFetchNewWordAddrIO :: Addr# -> Int# -> Word -> IO Word
syncAndFetchNewIntArrayIO :: MutableByteArray# s -> Int# -> Int -> IO Int
syncAndFetchNewIntAddrIO :: Addr# -> Int# -> Int -> IO Int
syncAndFetchOldWordArrayIO :: MutableByteArray# s -> Int# -> Word -> IO Word
syncAndFetchOldWordAddrIO :: Addr# -> Int# -> Word -> IO Word
syncAndFetchOldIntArrayIO :: MutableByteArray# s -> Int# -> Int -> IO Int
syncAndFetchOldIntAddrIO :: Addr# -> Int# -> Int -> IO Int
syncSubFetchNewWordArrayIO :: MutableByteArray# s -> Int# -> Word -> IO Word
syncSubFetchNewWordAddrIO :: Addr# -> Int# -> Word -> IO Word
syncSubFetchNewIntArrayIO :: MutableByteArray# s -> Int# -> Int -> IO Int
syncSubFetchNewIntAddrIO :: Addr# -> Int# -> Int -> IO Int
syncSubFetchOldWordArrayIO :: MutableByteArray# s -> Int# -> Word -> IO Word
syncSubFetchOldWordAddrIO :: Addr# -> Int# -> Word -> IO Word
syncSubFetchOldIntArrayIO :: MutableByteArray# s -> Int# -> Int -> IO Int
syncSubFetchOldIntAddrIO :: Addr# -> Int# -> Int -> IO Int
syncAddFetchNewWordArrayIO :: MutableByteArray# s -> Int# -> Word -> IO Word
syncAddFetchNewWordAddrIO :: Addr# -> Int# -> Word -> IO Word
syncAddFetchNewIntArrayIO :: MutableByteArray# s -> Int# -> Int -> IO Int
syncAddFetchNewIntAddrIO :: Addr# -> Int# -> Int -> IO Int
syncAddFetchOldWordArrayIO :: MutableByteArray# s -> Int# -> Word -> IO Word
syncAddFetchOldWordAddrIO :: Addr# -> Int# -> Word -> IO Word
syncAddFetchOldIntArrayIO :: MutableByteArray# s -> Int# -> Int -> IO Int
syncAddFetchOldIntAddrIO :: Addr# -> Int# -> Int -> IO Int
syncCasWordArrayIO :: MutableByteArray# s -> Int# -> Word -> Word -> IO Word
syncCasWordAddrIO :: Addr# -> Int# -> Word -> Word -> IO Word
syncCasIntArrayIO :: MutableByteArray# s -> Int# -> Int -> Int -> IO Int
syncCasIntAddrIO :: Addr# -> Int# -> Int -> Int -> IO Int
syncCasWordBoolArrayIO :: MutableByteArray# s -> Int# -> Word -> Word -> IO CBool
syncCasWordBoolAddrIO :: Addr# -> Int# -> Word -> Word -> IO CBool
syncCasIntBoolArrayIO :: MutableByteArray# s -> Int# -> Int -> Int -> IO CBool
syncCasIntBoolAddrIO :: Addr# -> Int# -> Int -> Int -> IO CBool
syncXorFetchNewWord32ArrayIO :: MutableByteArray# s -> Int# -> Word32 -> IO Word32
syncXorFetchNewWord32AddrIO :: Addr# -> Int# -> Word32 -> IO Word32
syncXorFetchNewInt32ArrayIO :: MutableByteArray# s -> Int# -> Int32 -> IO Int32
syncXorFetchNewInt32AddrIO :: Addr# -> Int# -> Int32 -> IO Int32
syncXorFetchOldWord32ArrayIO :: MutableByteArray# s -> Int# -> Word32 -> IO Word32
syncXorFetchOldWord32AddrIO :: Addr# -> Int# -> Word32 -> IO Word32
syncXorFetchOldInt32ArrayIO :: MutableByteArray# s -> Int# -> Int32 -> IO Int32
syncXorFetchOldInt32AddrIO :: Addr# -> Int# -> Int32 -> IO Int32
syncOrFetchNewWord32ArrayIO :: MutableByteArray# s -> Int# -> Word32 -> IO Word32
syncOrFetchNewWord32AddrIO :: Addr# -> Int# -> Word32 -> IO Word32
syncOrFetchNewInt32ArrayIO :: MutableByteArray# s -> Int# -> Int32 -> IO Int32
syncOrFetchNewInt32AddrIO :: Addr# -> Int# -> Int32 -> IO Int32
syncOrFetchOldWord32ArrayIO :: MutableByteArray# s -> Int# -> Word32 -> IO Word32
syncOrFetchOldWord32AddrIO :: Addr# -> Int# -> Word32 -> IO Word32
syncOrFetchOldInt32ArrayIO :: MutableByteArray# s -> Int# -> Int32 -> IO Int32
syncOrFetchOldInt32AddrIO :: Addr# -> Int# -> Int32 -> IO Int32
syncNandFetchNewWord32ArrayIO :: MutableByteArray# s -> Int# -> Word32 -> IO Word32
syncNandFetchNewWord32AddrIO :: Addr# -> Int# -> Word32 -> IO Word32
syncNandFetchNewInt32ArrayIO :: MutableByteArray# s -> Int# -> Int32 -> IO Int32
syncNandFetchNewInt32AddrIO :: Addr# -> Int# -> Int32 -> IO Int32
syncNandFetchOldWord32ArrayIO :: MutableByteArray# s -> Int# -> Word32 -> IO Word32
syncNandFetchOldWord32AddrIO :: Addr# -> Int# -> Word32 -> IO Word32
syncNandFetchOldInt32ArrayIO :: MutableByteArray# s -> Int# -> Int32 -> IO Int32
syncNandFetchOldInt32AddrIO :: Addr# -> Int# -> Int32 -> IO Int32
syncAndFetchNewWord32ArrayIO :: MutableByteArray# s -> Int# -> Word32 -> IO Word32
syncAndFetchNewWord32AddrIO :: Addr# -> Int# -> Word32 -> IO Word32
syncAndFetchNewInt32ArrayIO :: MutableByteArray# s -> Int# -> Int32 -> IO Int32
syncAndFetchNewInt32AddrIO :: Addr# -> Int# -> Int32 -> IO Int32
syncAndFetchOldWord32ArrayIO :: MutableByteArray# s -> Int# -> Word32 -> IO Word32
syncAndFetchOldWord32AddrIO :: Addr# -> Int# -> Word32 -> IO Word32
syncAndFetchOldInt32ArrayIO :: MutableByteArray# s -> Int# -> Int32 -> IO Int32
syncAndFetchOldInt32AddrIO :: Addr# -> Int# -> Int32 -> IO Int32
syncSubFetchNewWord32ArrayIO :: MutableByteArray# s -> Int# -> Word32 -> IO Word32
syncSubFetchNewWord32AddrIO :: Addr# -> Int# -> Word32 -> IO Word32
syncSubFetchNewInt32ArrayIO :: MutableByteArray# s -> Int# -> Int32 -> IO Int32
syncSubFetchNewInt32AddrIO :: Addr# -> Int# -> Int32 -> IO Int32
syncSubFetchOldWord32ArrayIO :: MutableByteArray# s -> Int# -> Word32 -> IO Word32
syncSubFetchOldWord32AddrIO :: Addr# -> Int# -> Word32 -> IO Word32
syncSubFetchOldInt32ArrayIO :: MutableByteArray# s -> Int# -> Int32 -> IO Int32
syncSubFetchOldInt32AddrIO :: Addr# -> Int# -> Int32 -> IO Int32
syncAddFetchNewWord32ArrayIO :: MutableByteArray# s -> Int# -> Word32 -> IO Word32
syncAddFetchNewWord32AddrIO :: Addr# -> Int# -> Word32 -> IO Word32
syncAddFetchNewInt32ArrayIO :: MutableByteArray# s -> Int# -> Int32 -> IO Int32
syncAddFetchNewInt32AddrIO :: Addr# -> Int# -> Int32 -> IO Int32
syncAddFetchOldWord32ArrayIO :: MutableByteArray# s -> Int# -> Word32 -> IO Word32
syncAddFetchOldWord32AddrIO :: Addr# -> Int# -> Word32 -> IO Word32
syncAddFetchOldInt32ArrayIO :: MutableByteArray# s -> Int# -> Int32 -> IO Int32
syncAddFetchOldInt32AddrIO :: Addr# -> Int# -> Int32 -> IO Int32
syncCasWord32ArrayIO :: MutableByteArray# s -> Int# -> Word32 -> Word32 -> IO Word32
syncCasWord32AddrIO :: Addr# -> Int# -> Word32 -> Word32 -> IO Word32
syncCasInt32ArrayIO :: MutableByteArray# s -> Int# -> Int32 -> Int32 -> IO Int32
syncCasInt32AddrIO :: Addr# -> Int# -> Int32 -> Int32 -> IO Int32
syncCasWord32BoolArrayIO :: MutableByteArray# s -> Int# -> Word32 -> Word32 -> IO CBool
syncCasWord32BoolAddrIO :: Addr# -> Int# -> Word32 -> Word32 -> IO CBool
syncCasInt32BoolArrayIO :: MutableByteArray# s -> Int# -> Int32 -> Int32 -> IO CBool
syncCasInt32BoolAddrIO :: Addr# -> Int# -> Int32 -> Int32 -> IO CBool
syncXorFetchNewWord16ArrayIO :: MutableByteArray# s -> Int# -> Word16 -> IO Word16
syncXorFetchNewWord16AddrIO :: Addr# -> Int# -> Word16 -> IO Word16
syncXorFetchNewInt16ArrayIO :: MutableByteArray# s -> Int# -> Int16 -> IO Int16
syncXorFetchNewInt16AddrIO :: Addr# -> Int# -> Int16 -> IO Int16
syncXorFetchOldWord16ArrayIO :: MutableByteArray# s -> Int# -> Word16 -> IO Word16
syncXorFetchOldWord16AddrIO :: Addr# -> Int# -> Word16 -> IO Word16
syncXorFetchOldInt16ArrayIO :: MutableByteArray# s -> Int# -> Int16 -> IO Int16
syncXorFetchOldInt16AddrIO :: Addr# -> Int# -> Int16 -> IO Int16
syncOrFetchNewWord16ArrayIO :: MutableByteArray# s -> Int# -> Word16 -> IO Word16
syncOrFetchNewWord16AddrIO :: Addr# -> Int# -> Word16 -> IO Word16
syncOrFetchNewInt16ArrayIO :: MutableByteArray# s -> Int# -> Int16 -> IO Int16
syncOrFetchNewInt16AddrIO :: Addr# -> Int# -> Int16 -> IO Int16
syncOrFetchOldWord16ArrayIO :: MutableByteArray# s -> Int# -> Word16 -> IO Word16
syncOrFetchOldWord16AddrIO :: Addr# -> Int# -> Word16 -> IO Word16
syncOrFetchOldInt16ArrayIO :: MutableByteArray# s -> Int# -> Int16 -> IO Int16
syncOrFetchOldInt16AddrIO :: Addr# -> Int# -> Int16 -> IO Int16
syncNandFetchNewWord16ArrayIO :: MutableByteArray# s -> Int# -> Word16 -> IO Word16
syncNandFetchNewWord16AddrIO :: Addr# -> Int# -> Word16 -> IO Word16
syncNandFetchNewInt16ArrayIO :: MutableByteArray# s -> Int# -> Int16 -> IO Int16
syncNandFetchNewInt16AddrIO :: Addr# -> Int# -> Int16 -> IO Int16
syncNandFetchOldWord16ArrayIO :: MutableByteArray# s -> Int# -> Word16 -> IO Word16
syncNandFetchOldWord16AddrIO :: Addr# -> Int# -> Word16 -> IO Word16
syncNandFetchOldInt16ArrayIO :: MutableByteArray# s -> Int# -> Int16 -> IO Int16
syncNandFetchOldInt16AddrIO :: Addr# -> Int# -> Int16 -> IO Int16
syncAndFetchNewWord16ArrayIO :: MutableByteArray# s -> Int# -> Word16 -> IO Word16
syncAndFetchNewWord16AddrIO :: Addr# -> Int# -> Word16 -> IO Word16
syncAndFetchNewInt16ArrayIO :: MutableByteArray# s -> Int# -> Int16 -> IO Int16
syncAndFetchNewInt16AddrIO :: Addr# -> Int# -> Int16 -> IO Int16
syncAndFetchOldWord16ArrayIO :: MutableByteArray# s -> Int# -> Word16 -> IO Word16
syncAndFetchOldWord16AddrIO :: Addr# -> Int# -> Word16 -> IO Word16
syncAndFetchOldInt16ArrayIO :: MutableByteArray# s -> Int# -> Int16 -> IO Int16
syncAndFetchOldInt16AddrIO :: Addr# -> Int# -> Int16 -> IO Int16
syncSubFetchNewWord16ArrayIO :: MutableByteArray# s -> Int# -> Word16 -> IO Word16
syncSubFetchNewWord16AddrIO :: Addr# -> Int# -> Word16 -> IO Word16
syncSubFetchNewInt16ArrayIO :: MutableByteArray# s -> Int# -> Int16 -> IO Int16
syncSubFetchNewInt16AddrIO :: Addr# -> Int# -> Int16 -> IO Int16
syncSubFetchOldWord16ArrayIO :: MutableByteArray# s -> Int# -> Word16 -> IO Word16
syncSubFetchOldWord16AddrIO :: Addr# -> Int# -> Word16 -> IO Word16
syncSubFetchOldInt16ArrayIO :: MutableByteArray# s -> Int# -> Int16 -> IO Int16
syncSubFetchOldInt16AddrIO :: Addr# -> Int# -> Int16 -> IO Int16
syncAddFetchNewWord16ArrayIO :: MutableByteArray# s -> Int# -> Word16 -> IO Word16
syncAddFetchNewWord16AddrIO :: Addr# -> Int# -> Word16 -> IO Word16
syncAddFetchNewInt16ArrayIO :: MutableByteArray# s -> Int# -> Int16 -> IO Int16
syncAddFetchNewInt16AddrIO :: Addr# -> Int# -> Int16 -> IO Int16
syncAddFetchOldWord16ArrayIO :: MutableByteArray# s -> Int# -> Word16 -> IO Word16
syncAddFetchOldWord16AddrIO :: Addr# -> Int# -> Word16 -> IO Word16
syncAddFetchOldInt16ArrayIO :: MutableByteArray# s -> Int# -> Int16 -> IO Int16
syncAddFetchOldInt16AddrIO :: Addr# -> Int# -> Int16 -> IO Int16
syncCasWord16ArrayIO :: MutableByteArray# s -> Int# -> Word16 -> Word16 -> IO Word16
syncCasWord16AddrIO :: Addr# -> Int# -> Word16 -> Word16 -> IO Word16
syncCasInt16ArrayIO :: MutableByteArray# s -> Int# -> Int16 -> Int16 -> IO Int16
syncCasInt16AddrIO :: Addr# -> Int# -> Int16 -> Int16 -> IO Int16
syncCasWord16BoolArrayIO :: MutableByteArray# s -> Int# -> Word16 -> Word16 -> IO CBool
syncCasWord16BoolAddrIO :: Addr# -> Int# -> Word16 -> Word16 -> IO CBool
syncCasInt16BoolArrayIO :: MutableByteArray# s -> Int# -> Int16 -> Int16 -> IO CBool
syncCasInt16BoolAddrIO :: Addr# -> Int# -> Int16 -> Int16 -> IO CBool
syncXorFetchNewWord8ArrayIO :: MutableByteArray# s -> Int# -> Word8 -> IO Word8
syncXorFetchNewWord8AddrIO :: Addr# -> Int# -> Word8 -> IO Word8
syncXorFetchNewInt8ArrayIO :: MutableByteArray# s -> Int# -> Int8 -> IO Int8
syncXorFetchNewInt8AddrIO :: Addr# -> Int# -> Int8 -> IO Int8
syncXorFetchOldWord8ArrayIO :: MutableByteArray# s -> Int# -> Word8 -> IO Word8
syncXorFetchOldWord8AddrIO :: Addr# -> Int# -> Word8 -> IO Word8
syncXorFetchOldInt8ArrayIO :: MutableByteArray# s -> Int# -> Int8 -> IO Int8
syncXorFetchOldInt8AddrIO :: Addr# -> Int# -> Int8 -> IO Int8
syncOrFetchNewWord8ArrayIO :: MutableByteArray# s -> Int# -> Word8 -> IO Word8
syncOrFetchNewWord8AddrIO :: Addr# -> Int# -> Word8 -> IO Word8
syncOrFetchNewInt8ArrayIO :: MutableByteArray# s -> Int# -> Int8 -> IO Int8
syncOrFetchNewInt8AddrIO :: Addr# -> Int# -> Int8 -> IO Int8
syncOrFetchOldWord8ArrayIO :: MutableByteArray# s -> Int# -> Word8 -> IO Word8
syncOrFetchOldWord8AddrIO :: Addr# -> Int# -> Word8 -> IO Word8
syncOrFetchOldInt8ArrayIO :: MutableByteArray# s -> Int# -> Int8 -> IO Int8
syncOrFetchOldInt8AddrIO :: Addr# -> Int# -> Int8 -> IO Int8
syncNandFetchNewWord8ArrayIO :: MutableByteArray# s -> Int# -> Word8 -> IO Word8
syncNandFetchNewWord8AddrIO :: Addr# -> Int# -> Word8 -> IO Word8
syncNandFetchNewInt8ArrayIO :: MutableByteArray# s -> Int# -> Int8 -> IO Int8
syncNandFetchNewInt8AddrIO :: Addr# -> Int# -> Int8 -> IO Int8
syncNandFetchOldWord8ArrayIO :: MutableByteArray# s -> Int# -> Word8 -> IO Word8
syncNandFetchOldWord8AddrIO :: Addr# -> Int# -> Word8 -> IO Word8
syncNandFetchOldInt8ArrayIO :: MutableByteArray# s -> Int# -> Int8 -> IO Int8
syncNandFetchOldInt8AddrIO :: Addr# -> Int# -> Int8 -> IO Int8
syncAndFetchNewWord8ArrayIO :: MutableByteArray# s -> Int# -> Word8 -> IO Word8
syncAndFetchNewWord8AddrIO :: Addr# -> Int# -> Word8 -> IO Word8
syncAndFetchNewInt8ArrayIO :: MutableByteArray# s -> Int# -> Int8 -> IO Int8
syncAndFetchNewInt8AddrIO :: Addr# -> Int# -> Int8 -> IO Int8
syncAndFetchOldWord8ArrayIO :: MutableByteArray# s -> Int# -> Word8 -> IO Word8
syncAndFetchOldWord8AddrIO :: Addr# -> Int# -> Word8 -> IO Word8
syncAndFetchOldInt8ArrayIO :: MutableByteArray# s -> Int# -> Int8 -> IO Int8
syncAndFetchOldInt8AddrIO :: Addr# -> Int# -> Int8 -> IO Int8
syncSubFetchNewWord8ArrayIO :: MutableByteArray# s -> Int# -> Word8 -> IO Word8
syncSubFetchNewWord8AddrIO :: Addr# -> Int# -> Word8 -> IO Word8
syncSubFetchNewInt8ArrayIO :: MutableByteArray# s -> Int# -> Int8 -> IO Int8
syncSubFetchNewInt8AddrIO :: Addr# -> Int# -> Int8 -> IO Int8
syncSubFetchOldWord8ArrayIO :: MutableByteArray# s -> Int# -> Word8 -> IO Word8
syncSubFetchOldWord8AddrIO :: Addr# -> Int# -> Word8 -> IO Word8
syncSubFetchOldInt8ArrayIO :: MutableByteArray# s -> Int# -> Int8 -> IO Int8
syncSubFetchOldInt8AddrIO :: Addr# -> Int# -> Int8 -> IO Int8
syncAddFetchNewWord8ArrayIO :: MutableByteArray# s -> Int# -> Word8 -> IO Word8
syncAddFetchNewWord8AddrIO :: Addr# -> Int# -> Word8 -> IO Word8
syncAddFetchNewInt8ArrayIO :: MutableByteArray# s -> Int# -> Int8 -> IO Int8
syncAddFetchNewInt8AddrIO :: Addr# -> Int# -> Int8 -> IO Int8
syncAddFetchOldWord8ArrayIO :: MutableByteArray# s -> Int# -> Word8 -> IO Word8
syncAddFetchOldWord8AddrIO :: Addr# -> Int# -> Word8 -> IO Word8
syncAddFetchOldInt8ArrayIO :: MutableByteArray# s -> Int# -> Int8 -> IO Int8
syncAddFetchOldInt8AddrIO :: Addr# -> Int# -> Int8 -> IO Int8
syncCasWord8ArrayIO :: MutableByteArray# s -> Int# -> Word8 -> Word8 -> IO Word8
syncCasWord8AddrIO :: Addr# -> Int# -> Word8 -> Word8 -> IO Word8
syncCasInt8ArrayIO :: MutableByteArray# s -> Int# -> Int8 -> Int8 -> IO Int8
syncCasInt8AddrIO :: Addr# -> Int# -> Int8 -> Int8 -> IO Int8
syncCasWord8BoolArrayIO :: MutableByteArray# s -> Int# -> Word8 -> Word8 -> IO CBool
syncCasWord8BoolAddrIO :: Addr# -> Int# -> Word8 -> Word8 -> IO CBool
syncCasInt8BoolArrayIO :: MutableByteArray# s -> Int# -> Int8 -> Int8 -> IO CBool
syncCasInt8BoolAddrIO :: Addr# -> Int# -> Int8 -> Int8 -> IO CBool
syncLockReleaseInt8AddrIO :: Addr# -> Int# -> IO ()
syncLockReleaseInt8ArrayIO :: MutableByteArray# s -> Int# -> IO ()
syncLockTestSetInt8AddrIO :: Addr# -> Int# -> IO Int8
syncLockTestSetInt8ArrayIO :: MutableByteArray# s -> Int# -> IO Int8
syncSynchronize :: IO ()
ioCBoolToBoolBase :: IO CBool -> State# s -> (# State# s, Bool #)
syncSynchronize# :: State# s -> State# s
withMemBarrier# :: (State# s -> (# State# s, a #)) -> State# s -> (# State# s, a #)
withMemBarrier_# :: (State# s -> State# s) -> State# s -> State# s
isSameByteArray# :: ByteArray# -> ByteArray# -> Int#
isSameMutableByteArray# :: MutableByteArray# s -> MutableByteArray# s -> Int#
toOrdering# :: Int# -> Ordering
fromOrdering# :: Ordering -> Int#
memcmpAddr# :: Addr# -> Int# -> Addr# -> Int# -> Int# -> Int#
memcmpAddrByteArray# :: Addr# -> Int# -> ByteArray# -> Int# -> Int# -> Int#
memcmpByteArray# :: ByteArray# -> Int# -> ByteArray# -> Int# -> Int# -> Int#
memcmpByteArrayAddr# :: ByteArray# -> Int# -> Addr# -> Int# -> Int# -> Int#
memsetWord8MutableByteArray# :: MutableByteArray# s -> Int# -> Int# -> Word8 -> IO ()
memsetWord8Addr# :: Addr# -> Int# -> Int# -> Word8 -> IO ()
memsetInt8MutableByteArray# :: MutableByteArray# s -> Int# -> Int# -> Int8 -> IO ()
memsetInt8Addr# :: Addr# -> Int# -> Int# -> Int8 -> IO ()
memsetWord16MutableByteArray# :: MutableByteArray# s -> Int# -> Int# -> Word16 -> IO ()
memsetWord16Addr# :: Addr# -> Int# -> Int# -> Word16 -> IO ()
memsetInt16MutableByteArray# :: MutableByteArray# s -> Int# -> Int# -> Int16 -> IO ()
memsetInt16Addr# :: Addr# -> Int# -> Int# -> Int16 -> IO ()
memsetWord32MutableByteArray# :: MutableByteArray# s -> Int# -> Int# -> Word32 -> IO ()
memsetWord32Addr# :: Addr# -> Int# -> Int# -> Word32 -> IO ()
memsetInt32MutableByteArray# :: MutableByteArray# s -> Int# -> Int# -> Int32 -> IO ()
memsetInt32Addr# :: Addr# -> Int# -> Int# -> Int32 -> IO ()
memsetWord64MutableByteArray# :: MutableByteArray# s -> Int# -> Int# -> Word64 -> IO ()
memsetWord64Addr# :: Addr# -> Int# -> Int# -> Word64 -> IO ()
memsetInt64MutableByteArray# :: MutableByteArray# s -> Int# -> Int# -> Int64 -> IO ()
memsetInt64Addr# :: Addr# -> Int# -> Int# -> Int64 -> IO ()
memmoveAddr# :: Addr# -> Int# -> Addr# -> Int# -> Int# -> IO ()
memmoveMutableByteArray# :: MutableByteArray# s -> Int# -> MutableByteArray# s -> Int# -> Int# -> IO ()
memmoveMutableByteArrayToAddr# :: MutableByteArray# s -> Int# -> Addr# -> Int# -> Int# -> IO ()
memmoveMutableByteArrayFromAddr# :: Addr# -> Int# -> MutableByteArray# s -> Int# -> Int# -> IO ()
word32ToFloat# :: Word# -> Float#
floatToWord32# :: Float# -> Word#
word64ToDouble# :: Word# -> Double#
doubleToWord64# :: Double# -> Word#
getSizeofMutableArray# :: MutableArray# s a -> State# s -> (# State# s, Int# #)
shrinkMutableArray# :: MutableArray# s a -> Int# -> State# s -> State# s
resizeMutableArray# :: MutableArray# s a -> Int# -> a -> State# s -> (# State# s, MutableArray# s a #)
type RW = RealWorld
newtype IO a = IO (State# RealWorld -> (# State# RealWorld, a #))
unIO :: IO a -> State# RealWorld -> (# State# RealWorld, a #)
unIO_ :: IO () -> State# RW -> State# RW
newtype ST s a = ST (STRep s a)
unST :: ST s a -> State# s -> (# State# s, a #)
unST_ :: ST s () -> State# s -> State# s
module Foreign.C.Types
module System.Posix.Types
augment :: (forall b. (a -> b -> b) -> b -> b) -> [a] -> [a]
build :: (forall b. (a -> b -> b) -> b -> b) -> [a]
seq :: forall (r :: RuntimeRep) a (b :: TYPE r). a -> b -> b
realWorld# :: State# RealWorld
void# :: Void#
unsafeCoerce# :: forall (k0 :: RuntimeRep) (k1 :: RuntimeRep) (a :: TYPE k0) (b :: TYPE k1). a -> b
nullAddr# :: Addr#
lazy :: a -> a
oneShot :: forall (q :: RuntimeRep) (r :: RuntimeRep) (a :: TYPE q) (b :: TYPE r). (a -> b) -> a -> b
runRW# :: forall (r :: RuntimeRep) (o :: TYPE r). (State# RealWorld -> o) -> o
breakpoint :: a -> a
breakpointCond :: Bool -> a -> a
inline :: a -> a
groupWith :: Ord b => (a -> b) -> [a] -> [[a]]
magicDict :: a
coerce :: forall (k :: RuntimeRep) (a :: TYPE k) (b :: TYPE k). Coercible a b => a -> b
class IsList l where
- type Item l
- fromList :: [Item l] -> l
- fromListN :: Int -> [Item l] -> l
- toList :: l -> [Item l]
proxy# :: forall k (a :: k). Proxy# a
class IsString a where
- fromString :: String -> a
data Addr# :: TYPE 'AddrRep
data Array# a :: TYPE 'UnliftedRep
data ByteArray# :: TYPE 'UnliftedRep
data Char# :: TYPE 'WordRep
data Char = C# Char#
data Double# :: TYPE 'DoubleRep
data Double = D# Double#
data Float# :: TYPE 'FloatRep
data Float = F# Float#
data Int# :: TYPE 'IntRep
data Int = I# Int#
data Int8# :: TYPE 'Int8Rep
data Int16# :: TYPE 'Int16Rep
data Int32# :: TYPE 'Int32Rep
data Int64# :: TYPE 'Int64Rep
data Weak# a :: TYPE 'UnliftedRep
data MutableArray# a b :: TYPE 'UnliftedRep
data MutableByteArray# a :: TYPE 'UnliftedRep
data MVar# a b :: TYPE 'UnliftedRep
data RealWorld
data StablePtr# a :: TYPE 'AddrRep
class a ~# b => (a :: k0) ~~ (b :: k1)
data ArrayArray# :: TYPE 'UnliftedRep
data MutableArrayArray# a :: TYPE 'UnliftedRep
data State# a :: TYPE ('TupleRep ('[] :: [RuntimeRep]))
data StableName# a :: TYPE 'UnliftedRep
data MutVar# a b :: TYPE 'UnliftedRep
data Void# :: TYPE ('TupleRep ('[] :: [RuntimeRep]))
data Word# :: TYPE 'WordRep
data Word = W# Word#
data Word8# :: TYPE 'Word8Rep
data Word16# :: TYPE 'Word16Rep
data Word32# :: TYPE 'Word32Rep
data Word64# :: TYPE 'Word64Rep
data ThreadId# :: TYPE 'UnliftedRep
data BCO# :: TYPE 'UnliftedRep
data Ptr a = Ptr Addr#
data FunPtr a = FunPtr Addr#
data TVar# a b :: TYPE 'UnliftedRep
data Compact# :: TYPE 'UnliftedRep
data Constraint
data RuntimeRep
- = VecRep VecCount VecElem
- | TupleRep [RuntimeRep]
- | SumRep [RuntimeRep]
- | LiftedRep
- | UnliftedRep
- | IntRep
- | Int8Rep
- | Int16Rep
- | Int32Rep
- | Int64Rep
- | WordRep
- | Word8Rep
- | Word16Rep
- | Word32Rep
- | Word64Rep
- | AddrRep
- | FloatRep
- | DoubleRep
data VecCount
- = Vec2
- | Vec4
- | Vec8
- | Vec16
- | Vec32
- | Vec64
data VecElem
- = Int8ElemRep
- | Int16ElemRep
- | Int32ElemRep
- | Int64ElemRep
- | Word8ElemRep
- | Word16ElemRep
- | Word32ElemRep
- | Word64ElemRep
- | FloatElemRep
- | DoubleElemRep
class a ~R# b => Coercible (a :: k) (b :: k)
data Proxy# (a :: k) :: TYPE ('TupleRep ('[] :: [RuntimeRep]))
type family Any :: k where ...
data SmallArray# a :: TYPE 'UnliftedRep
data SmallMutableArray# a b :: TYPE 'UnliftedRep
data Int8X16# :: TYPE ('VecRep 'Vec16 'Int8ElemRep)
data Int16X8# :: TYPE ('VecRep 'Vec8 'Int16ElemRep)
data Int32X4# :: TYPE ('VecRep 'Vec4 'Int32ElemRep)
data Int64X2# :: TYPE ('VecRep 'Vec2 'Int64ElemRep)
data Int8X32# :: TYPE ('VecRep 'Vec32 'Int8ElemRep)
data Int16X16# :: TYPE ('VecRep 'Vec16 'Int16ElemRep)
data Int32X8# :: TYPE ('VecRep 'Vec8 'Int32ElemRep)
data Int64X4# :: TYPE ('VecRep 'Vec4 'Int64ElemRep)
data Int8X64# :: TYPE ('VecRep 'Vec64 'Int8ElemRep)
data Int16X32# :: TYPE ('VecRep 'Vec32 'Int16ElemRep)
data Int32X16# :: TYPE ('VecRep 'Vec16 'Int32ElemRep)
data Int64X8# :: TYPE ('VecRep 'Vec8 'Int64ElemRep)
data Word8X16# :: TYPE ('VecRep 'Vec16 'Word8ElemRep)
data Word16X8# :: TYPE ('VecRep 'Vec8 'Word16ElemRep)
data Word32X4# :: TYPE ('VecRep 'Vec4 'Word32ElemRep)
data Word64X2# :: TYPE ('VecRep 'Vec2 'Word64ElemRep)
data Word8X32# :: TYPE ('VecRep 'Vec32 'Word8ElemRep)
data Word16X16# :: TYPE ('VecRep 'Vec16 'Word16ElemRep)
data Word32X8# :: TYPE ('VecRep 'Vec8 'Word32ElemRep)
data Word64X4# :: TYPE ('VecRep 'Vec4 'Word64ElemRep)
data Word8X64# :: TYPE ('VecRep 'Vec64 'Word8ElemRep)
data Word16X32# :: TYPE ('VecRep 'Vec32 'Word16ElemRep)
data Word32X16# :: TYPE ('VecRep 'Vec16 'Word32ElemRep)
data Word64X8# :: TYPE ('VecRep 'Vec8 'Word64ElemRep)
data FloatX4# :: TYPE ('VecRep 'Vec4 'FloatElemRep)
data DoubleX2# :: TYPE ('VecRep 'Vec2 'DoubleElemRep)
data FloatX8# :: TYPE ('VecRep 'Vec8 'FloatElemRep)
data DoubleX4# :: TYPE ('VecRep 'Vec4 'DoubleElemRep)
data FloatX16# :: TYPE ('VecRep 'Vec16 'FloatElemRep)
data DoubleX8# :: TYPE ('VecRep 'Vec8 'DoubleElemRep)
gtChar# :: Char# -> Char# -> Int#
geChar# :: Char# -> Char# -> Int#
eqChar# :: Char# -> Char# -> Int#
neChar# :: Char# -> Char# -> Int#
ltChar# :: Char# -> Char# -> Int#
leChar# :: Char# -> Char# -> Int#
ord# :: Char# -> Int#
(+#) :: Int# -> Int# -> Int#
(-#) :: Int# -> Int# -> Int#
(*#) :: Int# -> Int# -> Int#
mulIntMayOflo# :: Int# -> Int# -> Int#
quotInt# :: Int# -> Int# -> Int#
remInt# :: Int# -> Int# -> Int#
quotRemInt# :: Int# -> Int# -> (# Int#, Int# #)
andI# :: Int# -> Int# -> Int#
orI# :: Int# -> Int# -> Int#
xorI# :: Int# -> Int# -> Int#
notI# :: Int# -> Int#
negateInt# :: Int# -> Int#
addIntC# :: Int# -> Int# -> (# Int#, Int# #)
subIntC# :: Int# -> Int# -> (# Int#, Int# #)
(>#) :: Int# -> Int# -> Int#
(>=#) :: Int# -> Int# -> Int#
(==#) :: Int# -> Int# -> Int#
(/=#) :: Int# -> Int# -> Int#
(<#) :: Int# -> Int# -> Int#
(<=#) :: Int# -> Int# -> Int#
chr# :: Int# -> Char#
int2Word# :: Int# -> Word#
int2Float# :: Int# -> Float#
int2Double# :: Int# -> Double#
word2Float# :: Word# -> Float#
word2Double# :: Word# -> Double#
uncheckedIShiftL# :: Int# -> Int# -> Int#
uncheckedIShiftRA# :: Int# -> Int# -> Int#
uncheckedIShiftRL# :: Int# -> Int# -> Int#
extendInt8# :: Int8# -> Int#
narrowInt8# :: Int# -> Int8#
negateInt8# :: Int8# -> Int8#
plusInt8# :: Int8# -> Int8# -> Int8#
subInt8# :: Int8# -> Int8# -> Int8#
timesInt8# :: Int8# -> Int8# -> Int8#
quotInt8# :: Int8# -> Int8# -> Int8#
remInt8# :: Int8# -> Int8# -> Int8#
quotRemInt8# :: Int8# -> Int8# -> (# Int8#, Int8# #)
eqInt8# :: Int8# -> Int8# -> Int#
geInt8# :: Int8# -> Int8# -> Int#
gtInt8# :: Int8# -> Int8# -> Int#
leInt8# :: Int8# -> Int8# -> Int#
ltInt8# :: Int8# -> Int8# -> Int#
neInt8# :: Int8# -> Int8# -> Int#
extendWord8# :: Word8# -> Word#
narrowWord8# :: Word# -> Word8#
notWord8# :: Word8# -> Word8#
plusWord8# :: Word8# -> Word8# -> Word8#
subWord8# :: Word8# -> Word8# -> Word8#
timesWord8# :: Word8# -> Word8# -> Word8#
quotWord8# :: Word8# -> Word8# -> Word8#
remWord8# :: Word8# -> Word8# -> Word8#
quotRemWord8# :: Word8# -> Word8# -> (# Word8#, Word8# #)
eqWord8# :: Word8# -> Word8# -> Int#
geWord8# :: Word8# -> Word8# -> Int#
gtWord8# :: Word8# -> Word8# -> Int#
leWord8# :: Word8# -> Word8# -> Int#
ltWord8# :: Word8# -> Word8# -> Int#
neWord8# :: Word8# -> Word8# -> Int#
extendInt16# :: Int16# -> Int#
narrowInt16# :: Int# -> Int16#
negateInt16# :: Int16# -> Int16#
plusInt16# :: Int16# -> Int16# -> Int16#
subInt16# :: Int16# -> Int16# -> Int16#
timesInt16# :: Int16# -> Int16# -> Int16#
quotInt16# :: Int16# -> Int16# -> Int16#
remInt16# :: Int16# -> Int16# -> Int16#
quotRemInt16# :: Int16# -> Int16# -> (# Int16#, Int16# #)
eqInt16# :: Int16# -> Int16# -> Int#
geInt16# :: Int16# -> Int16# -> Int#
gtInt16# :: Int16# -> Int16# -> Int#
leInt16# :: Int16# -> Int16# -> Int#
ltInt16# :: Int16# -> Int16# -> Int#
neInt16# :: Int16# -> Int16# -> Int#
extendWord16# :: Word16# -> Word#
narrowWord16# :: Word# -> Word16#
notWord16# :: Word16# -> Word16#
plusWord16# :: Word16# -> Word16# -> Word16#
subWord16# :: Word16# -> Word16# -> Word16#
timesWord16# :: Word16# -> Word16# -> Word16#
quotWord16# :: Word16# -> Word16# -> Word16#
remWord16# :: Word16# -> Word16# -> Word16#
quotRemWord16# :: Word16# -> Word16# -> (# Word16#, Word16# #)
eqWord16# :: Word16# -> Word16# -> Int#
geWord16# :: Word16# -> Word16# -> Int#
gtWord16# :: Word16# -> Word16# -> Int#
leWord16# :: Word16# -> Word16# -> Int#
ltWord16# :: Word16# -> Word16# -> Int#
neWord16# :: Word16# -> Word16# -> Int#
plusWord# :: Word# -> Word# -> Word#
addWordC# :: Word# -> Word# -> (# Word#, Int# #)
subWordC# :: Word# -> Word# -> (# Word#, Int# #)
plusWord2# :: Word# -> Word# -> (# Word#, Word# #)
minusWord# :: Word# -> Word# -> Word#
timesWord# :: Word# -> Word# -> Word#
timesWord2# :: Word# -> Word# -> (# Word#, Word# #)
quotWord# :: Word# -> Word# -> Word#
remWord# :: Word# -> Word# -> Word#
quotRemWord# :: Word# -> Word# -> (# Word#, Word# #)
quotRemWord2# :: Word# -> Word# -> Word# -> (# Word#, Word# #)
and# :: Word# -> Word# -> Word#
or# :: Word# -> Word# -> Word#
xor# :: Word# -> Word# -> Word#
not# :: Word# -> Word#
uncheckedShiftL# :: Word# -> Int# -> Word#
uncheckedShiftRL# :: Word# -> Int# -> Word#
word2Int# :: Word# -> Int#
gtWord# :: Word# -> Word# -> Int#
geWord# :: Word# -> Word# -> Int#
eqWord# :: Word# -> Word# -> Int#
neWord# :: Word# -> Word# -> Int#
ltWord# :: Word# -> Word# -> Int#
leWord# :: Word# -> Word# -> Int#
popCnt8# :: Word# -> Word#
popCnt16# :: Word# -> Word#
popCnt32# :: Word# -> Word#
popCnt64# :: Word# -> Word#
popCnt# :: Word# -> Word#
pdep8# :: Word# -> Word# -> Word#
pdep16# :: Word# -> Word# -> Word#
pdep32# :: Word# -> Word# -> Word#
pdep64# :: Word# -> Word# -> Word#
pdep# :: Word# -> Word# -> Word#
pext8# :: Word# -> Word# -> Word#
pext16# :: Word# -> Word# -> Word#
pext32# :: Word# -> Word# -> Word#
pext64# :: Word# -> Word# -> Word#
pext# :: Word# -> Word# -> Word#
clz8# :: Word# -> Word#
clz16# :: Word# -> Word#
clz32# :: Word# -> Word#
clz64# :: Word# -> Word#
clz# :: Word# -> Word#
ctz8# :: Word# -> Word#
ctz16# :: Word# -> Word#
ctz32# :: Word# -> Word#
ctz64# :: Word# -> Word#
ctz# :: Word# -> Word#
byteSwap16# :: Word# -> Word#
byteSwap32# :: Word# -> Word#
byteSwap64# :: Word# -> Word#
byteSwap# :: Word# -> Word#
bitReverse8# :: Word# -> Word#
bitReverse16# :: Word# -> Word#
bitReverse32# :: Word# -> Word#
bitReverse64# :: Word# -> Word#
bitReverse# :: Word# -> Word#
narrow8Int# :: Int# -> Int#
narrow16Int# :: Int# -> Int#
narrow32Int# :: Int# -> Int#
narrow8Word# :: Word# -> Word#
narrow16Word# :: Word# -> Word#
narrow32Word# :: Word# -> Word#
(>##) :: Double# -> Double# -> Int#
(>=##) :: Double# -> Double# -> Int#
(==##) :: Double# -> Double# -> Int#
(/=##) :: Double# -> Double# -> Int#
(<##) :: Double# -> Double# -> Int#
(<=##) :: Double# -> Double# -> Int#
(+##) :: Double# -> Double# -> Double#
(-##) :: Double# -> Double# -> Double#
(*##) :: Double# -> Double# -> Double#
(/##) :: Double# -> Double# -> Double#
negateDouble# :: Double# -> Double#
fabsDouble# :: Double# -> Double#
double2Int# :: Double# -> Int#
double2Float# :: Double# -> Float#
expDouble# :: Double# -> Double#
expm1Double# :: Double# -> Double#
logDouble# :: Double# -> Double#
log1pDouble# :: Double# -> Double#
sqrtDouble# :: Double# -> Double#
sinDouble# :: Double# -> Double#
cosDouble# :: Double# -> Double#
tanDouble# :: Double# -> Double#
asinDouble# :: Double# -> Double#
acosDouble# :: Double# -> Double#
atanDouble# :: Double# -> Double#
sinhDouble# :: Double# -> Double#
coshDouble# :: Double# -> Double#
tanhDouble# :: Double# -> Double#
asinhDouble# :: Double# -> Double#
acoshDouble# :: Double# -> Double#
atanhDouble# :: Double# -> Double#
(**##) :: Double# -> Double# -> Double#
decodeDouble_2Int# :: Double# -> (# Int#, Word#, Word#, Int# #)
decodeDouble_Int64# :: Double# -> (# Int#, Int# #)
gtFloat# :: Float# -> Float# -> Int#
geFloat# :: Float# -> Float# -> Int#
eqFloat# :: Float# -> Float# -> Int#
neFloat# :: Float# -> Float# -> Int#
ltFloat# :: Float# -> Float# -> Int#
leFloat# :: Float# -> Float# -> Int#
plusFloat# :: Float# -> Float# -> Float#
minusFloat# :: Float# -> Float# -> Float#
timesFloat# :: Float# -> Float# -> Float#
divideFloat# :: Float# -> Float# -> Float#
negateFloat# :: Float# -> Float#
fabsFloat# :: Float# -> Float#
float2Int# :: Float# -> Int#
expFloat# :: Float# -> Float#
expm1Float# :: Float# -> Float#
logFloat# :: Float# -> Float#
log1pFloat# :: Float# -> Float#
sqrtFloat# :: Float# -> Float#
sinFloat# :: Float# -> Float#
cosFloat# :: Float# -> Float#
tanFloat# :: Float# -> Float#
asinFloat# :: Float# -> Float#
acosFloat# :: Float# -> Float#
atanFloat# :: Float# -> Float#
sinhFloat# :: Float# -> Float#
coshFloat# :: Float# -> Float#
tanhFloat# :: Float# -> Float#
asinhFloat# :: Float# -> Float#
acoshFloat# :: Float# -> Float#
atanhFloat# :: Float# -> Float#
powerFloat# :: Float# -> Float# -> Float#
float2Double# :: Float# -> Double#
decodeFloat_Int# :: Float# -> (# Int#, Int# #)
newArray# :: Int# -> a -> State# d -> (# State# d, MutableArray# d a #)
sameMutableArray# :: MutableArray# d a -> MutableArray# d a -> Int#
readArray# :: MutableArray# d a -> Int# -> State# d -> (# State# d, a #)
writeArray# :: MutableArray# d a -> Int# -> a -> State# d -> State# d
sizeofArray# :: Array# a -> Int#
sizeofMutableArray# :: MutableArray# d a -> Int#
indexArray# :: Array# a -> Int# -> (# a #)
unsafeFreezeArray# :: MutableArray# d a -> State# d -> (# State# d, Array# a #)
unsafeThawArray# :: Array# a -> State# d -> (# State# d, MutableArray# d a #)
copyArray# :: Array# a -> Int# -> MutableArray# d a -> Int# -> Int# -> State# d -> State# d
copyMutableArray# :: MutableArray# d a -> Int# -> MutableArray# d a -> Int# -> Int# -> State# d -> State# d
cloneArray# :: Array# a -> Int# -> Int# -> Array# a
cloneMutableArray# :: MutableArray# d a -> Int# -> Int# -> State# d -> (# State# d, MutableArray# d a #)
freezeArray# :: MutableArray# d a -> Int# -> Int# -> State# d -> (# State# d, Array# a #)
thawArray# :: Array# a -> Int# -> Int# -> State# d -> (# State# d, MutableArray# d a #)
casArray# :: MutableArray# d a -> Int# -> a -> a -> State# d -> (# State# d, Int#, a #)
newSmallArray# :: Int# -> a -> State# d -> (# State# d, SmallMutableArray# d a #)
sameSmallMutableArray# :: SmallMutableArray# d a -> SmallMutableArray# d a -> Int#
shrinkSmallMutableArray# :: SmallMutableArray# d a -> Int# -> State# d -> State# d
readSmallArray# :: SmallMutableArray# d a -> Int# -> State# d -> (# State# d, a #)
writeSmallArray# :: SmallMutableArray# d a -> Int# -> a -> State# d -> State# d
sizeofSmallArray# :: SmallArray# a -> Int#
sizeofSmallMutableArray# :: SmallMutableArray# d a -> Int#
getSizeofSmallMutableArray# :: SmallMutableArray# d a -> State# d -> (# State# d, Int# #)
indexSmallArray# :: SmallArray# a -> Int# -> (# a #)
unsafeFreezeSmallArray# :: SmallMutableArray# d a -> State# d -> (# State# d, SmallArray# a #)
unsafeThawSmallArray# :: SmallArray# a -> State# d -> (# State# d, SmallMutableArray# d a #)
copySmallArray# :: SmallArray# a -> Int# -> SmallMutableArray# d a -> Int# -> Int# -> State# d -> State# d
copySmallMutableArray# :: SmallMutableArray# d a -> Int# -> SmallMutableArray# d a -> Int# -> Int# -> State# d -> State# d
cloneSmallArray# :: SmallArray# a -> Int# -> Int# -> SmallArray# a
cloneSmallMutableArray# :: SmallMutableArray# d a -> Int# -> Int# -> State# d -> (# State# d, SmallMutableArray# d a #)
freezeSmallArray# :: SmallMutableArray# d a -> Int# -> Int# -> State# d -> (# State# d, SmallArray# a #)
thawSmallArray# :: SmallArray# a -> Int# -> Int# -> State# d -> (# State# d, SmallMutableArray# d a #)
casSmallArray# :: SmallMutableArray# d a -> Int# -> a -> a -> State# d -> (# State# d, Int#, a #)
newByteArray# :: Int# -> State# d -> (# State# d, MutableByteArray# d #)
newPinnedByteArray# :: Int# -> State# d -> (# State# d, MutableByteArray# d #)
newAlignedPinnedByteArray# :: Int# -> Int# -> State# d -> (# State# d, MutableByteArray# d #)
isMutableByteArrayPinned# :: MutableByteArray# d -> Int#
isByteArrayPinned# :: ByteArray# -> Int#
byteArrayContents# :: ByteArray# -> Addr#
sameMutableByteArray# :: MutableByteArray# d -> MutableByteArray# d -> Int#
shrinkMutableByteArray# :: MutableByteArray# d -> Int# -> State# d -> State# d
resizeMutableByteArray# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, MutableByteArray# d #)
unsafeFreezeByteArray# :: MutableByteArray# d -> State# d -> (# State# d, ByteArray# #)
sizeofByteArray# :: ByteArray# -> Int#
sizeofMutableByteArray# :: MutableByteArray# d -> Int#
getSizeofMutableByteArray# :: MutableByteArray# d -> State# d -> (# State# d, Int# #)
indexCharArray# :: ByteArray# -> Int# -> Char#
indexWideCharArray# :: ByteArray# -> Int# -> Char#
indexIntArray# :: ByteArray# -> Int# -> Int#
indexWordArray# :: ByteArray# -> Int# -> Word#
indexAddrArray# :: ByteArray# -> Int# -> Addr#
indexFloatArray# :: ByteArray# -> Int# -> Float#
indexDoubleArray# :: ByteArray# -> Int# -> Double#
indexStablePtrArray# :: ByteArray# -> Int# -> StablePtr# a
indexInt8Array# :: ByteArray# -> Int# -> Int#
indexInt16Array# :: ByteArray# -> Int# -> Int#
indexInt32Array# :: ByteArray# -> Int# -> Int#
indexInt64Array# :: ByteArray# -> Int# -> Int#
indexWord8Array# :: ByteArray# -> Int# -> Word#
indexWord16Array# :: ByteArray# -> Int# -> Word#
indexWord32Array# :: ByteArray# -> Int# -> Word#
indexWord64Array# :: ByteArray# -> Int# -> Word#
indexWord8ArrayAsChar# :: ByteArray# -> Int# -> Char#
indexWord8ArrayAsWideChar# :: ByteArray# -> Int# -> Char#
indexWord8ArrayAsAddr# :: ByteArray# -> Int# -> Addr#
indexWord8ArrayAsFloat# :: ByteArray# -> Int# -> Float#
indexWord8ArrayAsDouble# :: ByteArray# -> Int# -> Double#
indexWord8ArrayAsStablePtr# :: ByteArray# -> Int# -> StablePtr# a
indexWord8ArrayAsInt16# :: ByteArray# -> Int# -> Int#
indexWord8ArrayAsInt32# :: ByteArray# -> Int# -> Int#
indexWord8ArrayAsInt64# :: ByteArray# -> Int# -> Int#
indexWord8ArrayAsInt# :: ByteArray# -> Int# -> Int#
indexWord8ArrayAsWord16# :: ByteArray# -> Int# -> Word#
indexWord8ArrayAsWord32# :: ByteArray# -> Int# -> Word#
indexWord8ArrayAsWord64# :: ByteArray# -> Int# -> Word#
indexWord8ArrayAsWord# :: ByteArray# -> Int# -> Word#
readCharArray# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Char# #)
readWideCharArray# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Char# #)
readIntArray# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int# #)
readWordArray# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Word# #)
readAddrArray# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Addr# #)
readFloatArray# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Float# #)
readDoubleArray# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Double# #)
readStablePtrArray# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, StablePtr# a #)
readInt8Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int# #)
readInt16Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int# #)
readInt32Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int# #)
readInt64Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int# #)
readWord8Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Word# #)
readWord16Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Word# #)
readWord32Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Word# #)
readWord64Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Word# #)
readWord8ArrayAsChar# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Char# #)
readWord8ArrayAsWideChar# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Char# #)
readWord8ArrayAsAddr# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Addr# #)
readWord8ArrayAsFloat# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Float# #)
readWord8ArrayAsDouble# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Double# #)
readWord8ArrayAsStablePtr# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, StablePtr# a #)
readWord8ArrayAsInt16# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int# #)
readWord8ArrayAsInt32# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int# #)
readWord8ArrayAsInt64# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int# #)
readWord8ArrayAsInt# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int# #)
readWord8ArrayAsWord16# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Word# #)
readWord8ArrayAsWord32# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Word# #)
readWord8ArrayAsWord64# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Word# #)
readWord8ArrayAsWord# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Word# #)
writeCharArray# :: MutableByteArray# d -> Int# -> Char# -> State# d -> State# d
writeWideCharArray# :: MutableByteArray# d -> Int# -> Char# -> State# d -> State# d
writeIntArray# :: MutableByteArray# d -> Int# -> Int# -> State# d -> State# d
writeWordArray# :: MutableByteArray# d -> Int# -> Word# -> State# d -> State# d
writeAddrArray# :: MutableByteArray# d -> Int# -> Addr# -> State# d -> State# d
writeFloatArray# :: MutableByteArray# d -> Int# -> Float# -> State# d -> State# d
writeDoubleArray# :: MutableByteArray# d -> Int# -> Double# -> State# d -> State# d
writeStablePtrArray# :: MutableByteArray# d -> Int# -> StablePtr# a -> State# d -> State# d
writeInt8Array# :: MutableByteArray# d -> Int# -> Int# -> State# d -> State# d
writeInt16Array# :: MutableByteArray# d -> Int# -> Int# -> State# d -> State# d
writeInt32Array# :: MutableByteArray# d -> Int# -> Int# -> State# d -> State# d
writeInt64Array# :: MutableByteArray# d -> Int# -> Int# -> State# d -> State# d
writeWord8Array# :: MutableByteArray# d -> Int# -> Word# -> State# d -> State# d
writeWord16Array# :: MutableByteArray# d -> Int# -> Word# -> State# d -> State# d
writeWord32Array# :: MutableByteArray# d -> Int# -> Word# -> State# d -> State# d
writeWord64Array# :: MutableByteArray# d -> Int# -> Word# -> State# d -> State# d
writeWord8ArrayAsChar# :: MutableByteArray# d -> Int# -> Char# -> State# d -> State# d
writeWord8ArrayAsWideChar# :: MutableByteArray# d -> Int# -> Char# -> State# d -> State# d
writeWord8ArrayAsAddr# :: MutableByteArray# d -> Int# -> Addr# -> State# d -> State# d
writeWord8ArrayAsFloat# :: MutableByteArray# d -> Int# -> Float# -> State# d -> State# d
writeWord8ArrayAsDouble# :: MutableByteArray# d -> Int# -> Double# -> State# d -> State# d
writeWord8ArrayAsStablePtr# :: MutableByteArray# d -> Int# -> StablePtr# a -> State# d -> State# d
writeWord8ArrayAsInt16# :: MutableByteArray# d -> Int# -> Int# -> State# d -> State# d
writeWord8ArrayAsInt32# :: MutableByteArray# d -> Int# -> Int# -> State# d -> State# d
writeWord8ArrayAsInt64# :: MutableByteArray# d -> Int# -> Int# -> State# d -> State# d
writeWord8ArrayAsInt# :: MutableByteArray# d -> Int# -> Int# -> State# d -> State# d
writeWord8ArrayAsWord16# :: MutableByteArray# d -> Int# -> Word# -> State# d -> State# d
writeWord8ArrayAsWord32# :: MutableByteArray# d -> Int# -> Word# -> State# d -> State# d
writeWord8ArrayAsWord64# :: MutableByteArray# d -> Int# -> Word# -> State# d -> State# d
writeWord8ArrayAsWord# :: MutableByteArray# d -> Int# -> Word# -> State# d -> State# d
compareByteArrays# :: ByteArray# -> Int# -> ByteArray# -> Int# -> Int# -> Int#
copyByteArray# :: ByteArray# -> Int# -> MutableByteArray# d -> Int# -> Int# -> State# d -> State# d
copyMutableByteArray# :: MutableByteArray# d -> Int# -> MutableByteArray# d -> Int# -> Int# -> State# d -> State# d
copyByteArrayToAddr# :: ByteArray# -> Int# -> Addr# -> Int# -> State# d -> State# d
copyMutableByteArrayToAddr# :: MutableByteArray# d -> Int# -> Addr# -> Int# -> State# d -> State# d
copyAddrToByteArray# :: Addr# -> MutableByteArray# d -> Int# -> Int# -> State# d -> State# d
setByteArray# :: MutableByteArray# d -> Int# -> Int# -> Int# -> State# d -> State# d
atomicReadIntArray# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int# #)
atomicWriteIntArray# :: MutableByteArray# d -> Int# -> Int# -> State# d -> State# d
casIntArray# :: MutableByteArray# d -> Int# -> Int# -> Int# -> State# d -> (# State# d, Int# #)
fetchAddIntArray# :: MutableByteArray# d -> Int# -> Int# -> State# d -> (# State# d, Int# #)
fetchSubIntArray# :: MutableByteArray# d -> Int# -> Int# -> State# d -> (# State# d, Int# #)
fetchAndIntArray# :: MutableByteArray# d -> Int# -> Int# -> State# d -> (# State# d, Int# #)
fetchNandIntArray# :: MutableByteArray# d -> Int# -> Int# -> State# d -> (# State# d, Int# #)
fetchOrIntArray# :: MutableByteArray# d -> Int# -> Int# -> State# d -> (# State# d, Int# #)
fetchXorIntArray# :: MutableByteArray# d -> Int# -> Int# -> State# d -> (# State# d, Int# #)
newArrayArray# :: Int# -> State# d -> (# State# d, MutableArrayArray# d #)
sameMutableArrayArray# :: MutableArrayArray# d -> MutableArrayArray# d -> Int#
unsafeFreezeArrayArray# :: MutableArrayArray# d -> State# d -> (# State# d, ArrayArray# #)
sizeofArrayArray# :: ArrayArray# -> Int#
sizeofMutableArrayArray# :: MutableArrayArray# d -> Int#
indexByteArrayArray# :: ArrayArray# -> Int# -> ByteArray#
indexArrayArrayArray# :: ArrayArray# -> Int# -> ArrayArray#
readByteArrayArray# :: MutableArrayArray# d -> Int# -> State# d -> (# State# d, ByteArray# #)
readMutableByteArrayArray# :: MutableArrayArray# d -> Int# -> State# d -> (# State# d, MutableByteArray# d #)
readArrayArrayArray# :: MutableArrayArray# d -> Int# -> State# d -> (# State# d, ArrayArray# #)
readMutableArrayArrayArray# :: MutableArrayArray# d -> Int# -> State# d -> (# State# d, MutableArrayArray# d #)
writeByteArrayArray# :: MutableArrayArray# d -> Int# -> ByteArray# -> State# d -> State# d
writeMutableByteArrayArray# :: MutableArrayArray# d -> Int# -> MutableByteArray# d -> State# d -> State# d
writeArrayArrayArray# :: MutableArrayArray# d -> Int# -> ArrayArray# -> State# d -> State# d
writeMutableArrayArrayArray# :: MutableArrayArray# d -> Int# -> MutableArrayArray# d -> State# d -> State# d
copyArrayArray# :: ArrayArray# -> Int# -> MutableArrayArray# d -> Int# -> Int# -> State# d -> State# d
copyMutableArrayArray# :: MutableArrayArray# d -> Int# -> MutableArrayArray# d -> Int# -> Int# -> State# d -> State# d
plusAddr# :: Addr# -> Int# -> Addr#
minusAddr# :: Addr# -> Addr# -> Int#
remAddr# :: Addr# -> Int# -> Int#
addr2Int# :: Addr# -> Int#
int2Addr# :: Int# -> Addr#
gtAddr# :: Addr# -> Addr# -> Int#
geAddr# :: Addr# -> Addr# -> Int#
eqAddr# :: Addr# -> Addr# -> Int#
neAddr# :: Addr# -> Addr# -> Int#
ltAddr# :: Addr# -> Addr# -> Int#
leAddr# :: Addr# -> Addr# -> Int#
indexCharOffAddr# :: Addr# -> Int# -> Char#
indexWideCharOffAddr# :: Addr# -> Int# -> Char#
indexIntOffAddr# :: Addr# -> Int# -> Int#
indexWordOffAddr# :: Addr# -> Int# -> Word#
indexAddrOffAddr# :: Addr# -> Int# -> Addr#
indexFloatOffAddr# :: Addr# -> Int# -> Float#
indexDoubleOffAddr# :: Addr# -> Int# -> Double#
indexStablePtrOffAddr# :: Addr# -> Int# -> StablePtr# a
indexInt8OffAddr# :: Addr# -> Int# -> Int#
indexInt16OffAddr# :: Addr# -> Int# -> Int#
indexInt32OffAddr# :: Addr# -> Int# -> Int#
indexInt64OffAddr# :: Addr# -> Int# -> Int#
indexWord8OffAddr# :: Addr# -> Int# -> Word#
indexWord16OffAddr# :: Addr# -> Int# -> Word#
indexWord32OffAddr# :: Addr# -> Int# -> Word#
indexWord64OffAddr# :: Addr# -> Int# -> Word#
readCharOffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Char# #)
readWideCharOffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Char# #)
readIntOffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Int# #)
readWordOffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Word# #)
readAddrOffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Addr# #)
readFloatOffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Float# #)
readDoubleOffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Double# #)
readStablePtrOffAddr# :: Addr# -> Int# -> State# d -> (# State# d, StablePtr# a #)
readInt8OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Int# #)
readInt16OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Int# #)
readInt32OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Int# #)
readInt64OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Int# #)
readWord8OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Word# #)
readWord16OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Word# #)
readWord32OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Word# #)
readWord64OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Word# #)
writeCharOffAddr# :: Addr# -> Int# -> Char# -> State# d -> State# d
writeWideCharOffAddr# :: Addr# -> Int# -> Char# -> State# d -> State# d
writeIntOffAddr# :: Addr# -> Int# -> Int# -> State# d -> State# d
writeWordOffAddr# :: Addr# -> Int# -> Word# -> State# d -> State# d
writeAddrOffAddr# :: Addr# -> Int# -> Addr# -> State# d -> State# d
writeFloatOffAddr# :: Addr# -> Int# -> Float# -> State# d -> State# d
writeDoubleOffAddr# :: Addr# -> Int# -> Double# -> State# d -> State# d
writeStablePtrOffAddr# :: Addr# -> Int# -> StablePtr# a -> State# d -> State# d
writeInt8OffAddr# :: Addr# -> Int# -> Int# -> State# d -> State# d
writeInt16OffAddr# :: Addr# -> Int# -> Int# -> State# d -> State# d
writeInt32OffAddr# :: Addr# -> Int# -> Int# -> State# d -> State# d
writeInt64OffAddr# :: Addr# -> Int# -> Int# -> State# d -> State# d
writeWord8OffAddr# :: Addr# -> Int# -> Word# -> State# d -> State# d
writeWord16OffAddr# :: Addr# -> Int# -> Word# -> State# d -> State# d
writeWord32OffAddr# :: Addr# -> Int# -> Word# -> State# d -> State# d
writeWord64OffAddr# :: Addr# -> Int# -> Word# -> State# d -> State# d
newMutVar# :: a -> State# d -> (# State# d, MutVar# d a #)
readMutVar# :: MutVar# d a -> State# d -> (# State# d, a #)
writeMutVar# :: MutVar# d a -> a -> State# d -> State# d
sameMutVar# :: MutVar# d a -> MutVar# d a -> Int#
atomicModifyMutVar2# :: MutVar# d a -> (a -> c) -> State# d -> (# State# d, a, c #)
atomicModifyMutVar_# :: MutVar# d a -> (a -> a) -> State# d -> (# State# d, a, a #)
casMutVar# :: MutVar# d a -> a -> a -> State# d -> (# State# d, Int#, a #)
catch# :: (State# RealWorld -> (# State# RealWorld, a #)) -> (b -> State# RealWorld -> (# State# RealWorld, a #)) -> State# RealWorld -> (# State# RealWorld, a #)
raise# :: forall b (q :: RuntimeRep) (a :: TYPE q). b -> a
raiseIO# :: a -> State# RealWorld -> (# State# RealWorld, b #)
maskAsyncExceptions# :: (State# RealWorld -> (# State# RealWorld, a #)) -> State# RealWorld -> (# State# RealWorld, a #)
maskUninterruptible# :: (State# RealWorld -> (# State# RealWorld, a #)) -> State# RealWorld -> (# State# RealWorld, a #)
unmaskAsyncExceptions# :: (State# RealWorld -> (# State# RealWorld, a #)) -> State# RealWorld -> (# State# RealWorld, a #)
getMaskingState# :: State# RealWorld -> (# State# RealWorld, Int# #)
atomically# :: (State# RealWorld -> (# State# RealWorld, a #)) -> State# RealWorld -> (# State# RealWorld, a #)
retry# :: State# RealWorld -> (# State# RealWorld, a #)
catchRetry# :: (State# RealWorld -> (# State# RealWorld, a #)) -> (State# RealWorld -> (# State# RealWorld, a #)) -> State# RealWorld -> (# State# RealWorld, a #)
catchSTM# :: (State# RealWorld -> (# State# RealWorld, a #)) -> (b -> State# RealWorld -> (# State# RealWorld, a #)) -> State# RealWorld -> (# State# RealWorld, a #)
newTVar# :: a -> State# d -> (# State# d, TVar# d a #)
readTVar# :: TVar# d a -> State# d -> (# State# d, a #)
readTVarIO# :: TVar# d a -> State# d -> (# State# d, a #)
writeTVar# :: TVar# d a -> a -> State# d -> State# d
sameTVar# :: TVar# d a -> TVar# d a -> Int#
newMVar# :: State# d -> (# State# d, MVar# d a #)
takeMVar# :: MVar# d a -> State# d -> (# State# d, a #)
tryTakeMVar# :: MVar# d a -> State# d -> (# State# d, Int#, a #)
putMVar# :: MVar# d a -> a -> State# d -> State# d
tryPutMVar# :: MVar# d a -> a -> State# d -> (# State# d, Int# #)
readMVar# :: MVar# d a -> State# d -> (# State# d, a #)
tryReadMVar# :: MVar# d a -> State# d -> (# State# d, Int#, a #)
sameMVar# :: MVar# d a -> MVar# d a -> Int#
isEmptyMVar# :: MVar# d a -> State# d -> (# State# d, Int# #)
delay# :: Int# -> State# d -> State# d
waitRead# :: Int# -> State# d -> State# d
waitWrite# :: Int# -> State# d -> State# d
fork# :: a -> State# RealWorld -> (# State# RealWorld, ThreadId# #)
forkOn# :: Int# -> a -> State# RealWorld -> (# State# RealWorld, ThreadId# #)
killThread# :: ThreadId# -> a -> State# RealWorld -> State# RealWorld
yield# :: State# RealWorld -> State# RealWorld
myThreadId# :: State# RealWorld -> (# State# RealWorld, ThreadId# #)
labelThread# :: ThreadId# -> Addr# -> State# RealWorld -> State# RealWorld
isCurrentThreadBound# :: State# RealWorld -> (# State# RealWorld, Int# #)
noDuplicate# :: State# d -> State# d
threadStatus# :: ThreadId# -> State# RealWorld -> (# State# RealWorld, Int#, Int#, Int# #)
mkWeak# :: forall (q :: RuntimeRep) (a :: TYPE q) b c. a -> b -> (State# RealWorld -> (# State# RealWorld, c #)) -> State# RealWorld -> (# State# RealWorld, Weak# b #)
mkWeakNoFinalizer# :: forall (q :: RuntimeRep) (a :: TYPE q) b. a -> b -> State# RealWorld -> (# State# RealWorld, Weak# b #)
addCFinalizerToWeak# :: Addr# -> Addr# -> Int# -> Addr# -> Weak# b -> State# RealWorld -> (# State# RealWorld, Int# #)
deRefWeak# :: Weak# a -> State# RealWorld -> (# State# RealWorld, Int#, a #)
finalizeWeak# :: Weak# a -> State# RealWorld -> (# State# RealWorld, Int#, State# RealWorld -> (# State# RealWorld, b #) #)
makeStablePtr# :: a -> State# RealWorld -> (# State# RealWorld, StablePtr# a #)
deRefStablePtr# :: StablePtr# a -> State# RealWorld -> (# State# RealWorld, a #)
eqStablePtr# :: StablePtr# a -> StablePtr# a -> Int#
makeStableName# :: a -> State# RealWorld -> (# State# RealWorld, StableName# a #)
eqStableName# :: StableName# a -> StableName# b -> Int#
stableNameToInt# :: StableName# a -> Int#
compactNew# :: Word# -> State# RealWorld -> (# State# RealWorld, Compact# #)
compactResize# :: Compact# -> Word# -> State# RealWorld -> State# RealWorld
compactContains# :: Compact# -> a -> State# RealWorld -> (# State# RealWorld, Int# #)
compactContainsAny# :: a -> State# RealWorld -> (# State# RealWorld, Int# #)
compactGetFirstBlock# :: Compact# -> State# RealWorld -> (# State# RealWorld, Addr#, Word# #)
compactGetNextBlock# :: Compact# -> Addr# -> State# RealWorld -> (# State# RealWorld, Addr#, Word# #)
compactAllocateBlock# :: Word# -> Addr# -> State# RealWorld -> (# State# RealWorld, Addr# #)
compactFixupPointers# :: Addr# -> Addr# -> State# RealWorld -> (# State# RealWorld, Compact#, Addr# #)
compactAdd# :: Compact# -> a -> State# RealWorld -> (# State# RealWorld, a #)
compactAddWithSharing# :: Compact# -> a -> State# RealWorld -> (# State# RealWorld, a #)
compactSize# :: Compact# -> State# RealWorld -> (# State# RealWorld, Word# #)
reallyUnsafePtrEquality# :: a -> a -> Int#
par# :: a -> Int#
spark# :: a -> State# d -> (# State# d, a #)
seq# :: a -> State# d -> (# State# d, a #)
getSpark# :: State# d -> (# State# d, Int#, a #)
numSparks# :: State# d -> (# State# d, Int# #)
dataToTag# :: a -> Int#
tagToEnum# :: Int# -> a
addrToAny# :: Addr# -> (# a #)
anyToAddr# :: a -> State# RealWorld -> (# State# RealWorld, Addr# #)
mkApUpd0# :: BCO# -> (# a #)
newBCO# :: ByteArray# -> ByteArray# -> Array# a -> Int# -> ByteArray# -> State# d -> (# State# d, BCO# #)
unpackClosure# :: a -> (# Addr#, ByteArray#, Array# b #)
closureSize# :: a -> Int#
getApStackVal# :: a -> Int# -> (# Int#, b #)
getCCSOf# :: a -> State# d -> (# State# d, Addr# #)
getCurrentCCS# :: a -> State# d -> (# State# d, Addr# #)
clearCCS# :: (State# d -> (# State# d, a #)) -> State# d -> (# State# d, a #)
traceEvent# :: Addr# -> State# d -> State# d
traceBinaryEvent# :: Addr# -> Int# -> State# d -> State# d
traceMarker# :: Addr# -> State# d -> State# d
setThreadAllocationCounter# :: Int# -> State# RealWorld -> State# RealWorld
broadcastInt8X16# :: Int# -> Int8X16#
broadcastInt16X8# :: Int# -> Int16X8#
broadcastInt32X4# :: Int# -> Int32X4#
broadcastInt64X2# :: Int# -> Int64X2#
broadcastInt8X32# :: Int# -> Int8X32#
broadcastInt16X16# :: Int# -> Int16X16#
broadcastInt32X8# :: Int# -> Int32X8#
broadcastInt64X4# :: Int# -> Int64X4#
broadcastInt8X64# :: Int# -> Int8X64#
broadcastInt16X32# :: Int# -> Int16X32#
broadcastInt32X16# :: Int# -> Int32X16#
broadcastInt64X8# :: Int# -> Int64X8#
broadcastWord8X16# :: Word# -> Word8X16#
broadcastWord16X8# :: Word# -> Word16X8#
broadcastWord32X4# :: Word# -> Word32X4#
broadcastWord64X2# :: Word# -> Word64X2#
broadcastWord8X32# :: Word# -> Word8X32#
broadcastWord16X16# :: Word# -> Word16X16#
broadcastWord32X8# :: Word# -> Word32X8#
broadcastWord64X4# :: Word# -> Word64X4#
broadcastWord8X64# :: Word# -> Word8X64#
broadcastWord16X32# :: Word# -> Word16X32#
broadcastWord32X16# :: Word# -> Word32X16#
broadcastWord64X8# :: Word# -> Word64X8#
broadcastFloatX4# :: Float# -> FloatX4#
broadcastDoubleX2# :: Double# -> DoubleX2#
broadcastFloatX8# :: Float# -> FloatX8#
broadcastDoubleX4# :: Double# -> DoubleX4#
broadcastFloatX16# :: Float# -> FloatX16#
broadcastDoubleX8# :: Double# -> DoubleX8#
packInt8X16# :: (# Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int# #) -> Int8X16#
packInt16X8# :: (# Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int# #) -> Int16X8#
packInt32X4# :: (# Int#, Int#, Int#, Int# #) -> Int32X4#
packInt64X2# :: (# Int#, Int# #) -> Int64X2#
packInt8X32# :: (# Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int# #) -> Int8X32#
packInt16X16# :: (# Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int# #) -> Int16X16#
packInt32X8# :: (# Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int# #) -> Int32X8#
packInt64X4# :: (# Int#, Int#, Int#, Int# #) -> Int64X4#
packInt8X64# :: (# Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int# #) -> Int8X64#
packInt16X32# :: (# Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int# #) -> Int16X32#
packInt32X16# :: (# Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int# #) -> Int32X16#
packInt64X8# :: (# Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int# #) -> Int64X8#
packWord8X16# :: (# Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word# #) -> Word8X16#
packWord16X8# :: (# Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word# #) -> Word16X8#
packWord32X4# :: (# Word#, Word#, Word#, Word# #) -> Word32X4#
packWord64X2# :: (# Word#, Word# #) -> Word64X2#
packWord8X32# :: (# Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word# #) -> Word8X32#
packWord16X16# :: (# Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word# #) -> Word16X16#
packWord32X8# :: (# Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word# #) -> Word32X8#
packWord64X4# :: (# Word#, Word#, Word#, Word# #) -> Word64X4#
packWord8X64# :: (# Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word# #) -> Word8X64#
packWord16X32# :: (# Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word# #) -> Word16X32#
packWord32X16# :: (# Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word# #) -> Word32X16#
packWord64X8# :: (# Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word# #) -> Word64X8#
packFloatX4# :: (# Float#, Float#, Float#, Float# #) -> FloatX4#
packDoubleX2# :: (# Double#, Double# #) -> DoubleX2#
packFloatX8# :: (# Float#, Float#, Float#, Float#, Float#, Float#, Float#, Float# #) -> FloatX8#
packDoubleX4# :: (# Double#, Double#, Double#, Double# #) -> DoubleX4#
packFloatX16# :: (# Float#, Float#, Float#, Float#, Float#, Float#, Float#, Float#, Float#, Float#, Float#, Float#, Float#, Float#, Float#, Float# #) -> FloatX16#
packDoubleX8# :: (# Double#, Double#, Double#, Double#, Double#, Double#, Double#, Double# #) -> DoubleX8#
unpackInt8X16# :: Int8X16# -> (# Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int# #)
unpackInt16X8# :: Int16X8# -> (# Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int# #)
unpackInt32X4# :: Int32X4# -> (# Int#, Int#, Int#, Int# #)
unpackInt64X2# :: Int64X2# -> (# Int#, Int# #)
unpackInt8X32# :: Int8X32# -> (# Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int# #)
unpackInt16X16# :: Int16X16# -> (# Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int# #)
unpackInt32X8# :: Int32X8# -> (# Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int# #)
unpackInt64X4# :: Int64X4# -> (# Int#, Int#, Int#, Int# #)
unpackInt8X64# :: Int8X64# -> (# Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int# #)
unpackInt16X32# :: Int16X32# -> (# Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int# #)
unpackInt32X16# :: Int32X16# -> (# Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int# #)
unpackInt64X8# :: Int64X8# -> (# Int#, Int#, Int#, Int#, Int#, Int#, Int#, Int# #)
unpackWord8X16# :: Word8X16# -> (# Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word# #)
unpackWord16X8# :: Word16X8# -> (# Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word# #)
unpackWord32X4# :: Word32X4# -> (# Word#, Word#, Word#, Word# #)
unpackWord64X2# :: Word64X2# -> (# Word#, Word# #)
unpackWord8X32# :: Word8X32# -> (# Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word# #)
unpackWord16X16# :: Word16X16# -> (# Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word# #)
unpackWord32X8# :: Word32X8# -> (# Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word# #)
unpackWord64X4# :: Word64X4# -> (# Word#, Word#, Word#, Word# #)
unpackWord8X64# :: Word8X64# -> (# Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word# #)
unpackWord16X32# :: Word16X32# -> (# Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word# #)
unpackWord32X16# :: Word32X16# -> (# Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word# #)
unpackWord64X8# :: Word64X8# -> (# Word#, Word#, Word#, Word#, Word#, Word#, Word#, Word# #)
unpackFloatX4# :: FloatX4# -> (# Float#, Float#, Float#, Float# #)
unpackDoubleX2# :: DoubleX2# -> (# Double#, Double# #)
unpackFloatX8# :: FloatX8# -> (# Float#, Float#, Float#, Float#, Float#, Float#, Float#, Float# #)
unpackDoubleX4# :: DoubleX4# -> (# Double#, Double#, Double#, Double# #)
unpackFloatX16# :: FloatX16# -> (# Float#, Float#, Float#, Float#, Float#, Float#, Float#, Float#, Float#, Float#, Float#, Float#, Float#, Float#, Float#, Float# #)
unpackDoubleX8# :: DoubleX8# -> (# Double#, Double#, Double#, Double#, Double#, Double#, Double#, Double# #)
insertInt8X16# :: Int8X16# -> Int# -> Int# -> Int8X16#
insertInt16X8# :: Int16X8# -> Int# -> Int# -> Int16X8#
insertInt32X4# :: Int32X4# -> Int# -> Int# -> Int32X4#
insertInt64X2# :: Int64X2# -> Int# -> Int# -> Int64X2#
insertInt8X32# :: Int8X32# -> Int# -> Int# -> Int8X32#
insertInt16X16# :: Int16X16# -> Int# -> Int# -> Int16X16#
insertInt32X8# :: Int32X8# -> Int# -> Int# -> Int32X8#
insertInt64X4# :: Int64X4# -> Int# -> Int# -> Int64X4#
insertInt8X64# :: Int8X64# -> Int# -> Int# -> Int8X64#
insertInt16X32# :: Int16X32# -> Int# -> Int# -> Int16X32#
insertInt32X16# :: Int32X16# -> Int# -> Int# -> Int32X16#
insertInt64X8# :: Int64X8# -> Int# -> Int# -> Int64X8#
insertWord8X16# :: Word8X16# -> Word# -> Int# -> Word8X16#
insertWord16X8# :: Word16X8# -> Word# -> Int# -> Word16X8#
insertWord32X4# :: Word32X4# -> Word# -> Int# -> Word32X4#
insertWord64X2# :: Word64X2# -> Word# -> Int# -> Word64X2#
insertWord8X32# :: Word8X32# -> Word# -> Int# -> Word8X32#
insertWord16X16# :: Word16X16# -> Word# -> Int# -> Word16X16#
insertWord32X8# :: Word32X8# -> Word# -> Int# -> Word32X8#
insertWord64X4# :: Word64X4# -> Word# -> Int# -> Word64X4#
insertWord8X64# :: Word8X64# -> Word# -> Int# -> Word8X64#
insertWord16X32# :: Word16X32# -> Word# -> Int# -> Word16X32#
insertWord32X16# :: Word32X16# -> Word# -> Int# -> Word32X16#
insertWord64X8# :: Word64X8# -> Word# -> Int# -> Word64X8#
insertFloatX4# :: FloatX4# -> Float# -> Int# -> FloatX4#
insertDoubleX2# :: DoubleX2# -> Double# -> Int# -> DoubleX2#
insertFloatX8# :: FloatX8# -> Float# -> Int# -> FloatX8#
insertDoubleX4# :: DoubleX4# -> Double# -> Int# -> DoubleX4#
insertFloatX16# :: FloatX16# -> Float# -> Int# -> FloatX16#
insertDoubleX8# :: DoubleX8# -> Double# -> Int# -> DoubleX8#
plusInt8X16# :: Int8X16# -> Int8X16# -> Int8X16#
plusInt16X8# :: Int16X8# -> Int16X8# -> Int16X8#
plusInt32X4# :: Int32X4# -> Int32X4# -> Int32X4#
plusInt64X2# :: Int64X2# -> Int64X2# -> Int64X2#
plusInt8X32# :: Int8X32# -> Int8X32# -> Int8X32#
plusInt16X16# :: Int16X16# -> Int16X16# -> Int16X16#
plusInt32X8# :: Int32X8# -> Int32X8# -> Int32X8#
plusInt64X4# :: Int64X4# -> Int64X4# -> Int64X4#
plusInt8X64# :: Int8X64# -> Int8X64# -> Int8X64#
plusInt16X32# :: Int16X32# -> Int16X32# -> Int16X32#
plusInt32X16# :: Int32X16# -> Int32X16# -> Int32X16#
plusInt64X8# :: Int64X8# -> Int64X8# -> Int64X8#
plusWord8X16# :: Word8X16# -> Word8X16# -> Word8X16#
plusWord16X8# :: Word16X8# -> Word16X8# -> Word16X8#
plusWord32X4# :: Word32X4# -> Word32X4# -> Word32X4#
plusWord64X2# :: Word64X2# -> Word64X2# -> Word64X2#
plusWord8X32# :: Word8X32# -> Word8X32# -> Word8X32#
plusWord16X16# :: Word16X16# -> Word16X16# -> Word16X16#
plusWord32X8# :: Word32X8# -> Word32X8# -> Word32X8#
plusWord64X4# :: Word64X4# -> Word64X4# -> Word64X4#
plusWord8X64# :: Word8X64# -> Word8X64# -> Word8X64#
plusWord16X32# :: Word16X32# -> Word16X32# -> Word16X32#
plusWord32X16# :: Word32X16# -> Word32X16# -> Word32X16#
plusWord64X8# :: Word64X8# -> Word64X8# -> Word64X8#
plusFloatX4# :: FloatX4# -> FloatX4# -> FloatX4#
plusDoubleX2# :: DoubleX2# -> DoubleX2# -> DoubleX2#
plusFloatX8# :: FloatX8# -> FloatX8# -> FloatX8#
plusDoubleX4# :: DoubleX4# -> DoubleX4# -> DoubleX4#
plusFloatX16# :: FloatX16# -> FloatX16# -> FloatX16#
plusDoubleX8# :: DoubleX8# -> DoubleX8# -> DoubleX8#
minusInt8X16# :: Int8X16# -> Int8X16# -> Int8X16#
minusInt16X8# :: Int16X8# -> Int16X8# -> Int16X8#
minusInt32X4# :: Int32X4# -> Int32X4# -> Int32X4#
minusInt64X2# :: Int64X2# -> Int64X2# -> Int64X2#
minusInt8X32# :: Int8X32# -> Int8X32# -> Int8X32#
minusInt16X16# :: Int16X16# -> Int16X16# -> Int16X16#
minusInt32X8# :: Int32X8# -> Int32X8# -> Int32X8#
minusInt64X4# :: Int64X4# -> Int64X4# -> Int64X4#
minusInt8X64# :: Int8X64# -> Int8X64# -> Int8X64#
minusInt16X32# :: Int16X32# -> Int16X32# -> Int16X32#
minusInt32X16# :: Int32X16# -> Int32X16# -> Int32X16#
minusInt64X8# :: Int64X8# -> Int64X8# -> Int64X8#
minusWord8X16# :: Word8X16# -> Word8X16# -> Word8X16#
minusWord16X8# :: Word16X8# -> Word16X8# -> Word16X8#
minusWord32X4# :: Word32X4# -> Word32X4# -> Word32X4#
minusWord64X2# :: Word64X2# -> Word64X2# -> Word64X2#
minusWord8X32# :: Word8X32# -> Word8X32# -> Word8X32#
minusWord16X16# :: Word16X16# -> Word16X16# -> Word16X16#
minusWord32X8# :: Word32X8# -> Word32X8# -> Word32X8#
minusWord64X4# :: Word64X4# -> Word64X4# -> Word64X4#
minusWord8X64# :: Word8X64# -> Word8X64# -> Word8X64#
minusWord16X32# :: Word16X32# -> Word16X32# -> Word16X32#
minusWord32X16# :: Word32X16# -> Word32X16# -> Word32X16#
minusWord64X8# :: Word64X8# -> Word64X8# -> Word64X8#
minusFloatX4# :: FloatX4# -> FloatX4# -> FloatX4#
minusDoubleX2# :: DoubleX2# -> DoubleX2# -> DoubleX2#
minusFloatX8# :: FloatX8# -> FloatX8# -> FloatX8#
minusDoubleX4# :: DoubleX4# -> DoubleX4# -> DoubleX4#
minusFloatX16# :: FloatX16# -> FloatX16# -> FloatX16#
minusDoubleX8# :: DoubleX8# -> DoubleX8# -> DoubleX8#
timesInt8X16# :: Int8X16# -> Int8X16# -> Int8X16#
timesInt16X8# :: Int16X8# -> Int16X8# -> Int16X8#
timesInt32X4# :: Int32X4# -> Int32X4# -> Int32X4#
timesInt64X2# :: Int64X2# -> Int64X2# -> Int64X2#
timesInt8X32# :: Int8X32# -> Int8X32# -> Int8X32#
timesInt16X16# :: Int16X16# -> Int16X16# -> Int16X16#
timesInt32X8# :: Int32X8# -> Int32X8# -> Int32X8#
timesInt64X4# :: Int64X4# -> Int64X4# -> Int64X4#
timesInt8X64# :: Int8X64# -> Int8X64# -> Int8X64#
timesInt16X32# :: Int16X32# -> Int16X32# -> Int16X32#
timesInt32X16# :: Int32X16# -> Int32X16# -> Int32X16#
timesInt64X8# :: Int64X8# -> Int64X8# -> Int64X8#
timesWord8X16# :: Word8X16# -> Word8X16# -> Word8X16#
timesWord16X8# :: Word16X8# -> Word16X8# -> Word16X8#
timesWord32X4# :: Word32X4# -> Word32X4# -> Word32X4#
timesWord64X2# :: Word64X2# -> Word64X2# -> Word64X2#
timesWord8X32# :: Word8X32# -> Word8X32# -> Word8X32#
timesWord16X16# :: Word16X16# -> Word16X16# -> Word16X16#
timesWord32X8# :: Word32X8# -> Word32X8# -> Word32X8#
timesWord64X4# :: Word64X4# -> Word64X4# -> Word64X4#
timesWord8X64# :: Word8X64# -> Word8X64# -> Word8X64#
timesWord16X32# :: Word16X32# -> Word16X32# -> Word16X32#
timesWord32X16# :: Word32X16# -> Word32X16# -> Word32X16#
timesWord64X8# :: Word64X8# -> Word64X8# -> Word64X8#
timesFloatX4# :: FloatX4# -> FloatX4# -> FloatX4#
timesDoubleX2# :: DoubleX2# -> DoubleX2# -> DoubleX2#
timesFloatX8# :: FloatX8# -> FloatX8# -> FloatX8#
timesDoubleX4# :: DoubleX4# -> DoubleX4# -> DoubleX4#
timesFloatX16# :: FloatX16# -> FloatX16# -> FloatX16#
timesDoubleX8# :: DoubleX8# -> DoubleX8# -> DoubleX8#
divideFloatX4# :: FloatX4# -> FloatX4# -> FloatX4#
divideDoubleX2# :: DoubleX2# -> DoubleX2# -> DoubleX2#
divideFloatX8# :: FloatX8# -> FloatX8# -> FloatX8#
divideDoubleX4# :: DoubleX4# -> DoubleX4# -> DoubleX4#
divideFloatX16# :: FloatX16# -> FloatX16# -> FloatX16#
divideDoubleX8# :: DoubleX8# -> DoubleX8# -> DoubleX8#
quotInt8X16# :: Int8X16# -> Int8X16# -> Int8X16#
quotInt16X8# :: Int16X8# -> Int16X8# -> Int16X8#
quotInt32X4# :: Int32X4# -> Int32X4# -> Int32X4#
quotInt64X2# :: Int64X2# -> Int64X2# -> Int64X2#
quotInt8X32# :: Int8X32# -> Int8X32# -> Int8X32#
quotInt16X16# :: Int16X16# -> Int16X16# -> Int16X16#
quotInt32X8# :: Int32X8# -> Int32X8# -> Int32X8#
quotInt64X4# :: Int64X4# -> Int64X4# -> Int64X4#
quotInt8X64# :: Int8X64# -> Int8X64# -> Int8X64#
quotInt16X32# :: Int16X32# -> Int16X32# -> Int16X32#
quotInt32X16# :: Int32X16# -> Int32X16# -> Int32X16#
quotInt64X8# :: Int64X8# -> Int64X8# -> Int64X8#
quotWord8X16# :: Word8X16# -> Word8X16# -> Word8X16#
quotWord16X8# :: Word16X8# -> Word16X8# -> Word16X8#
quotWord32X4# :: Word32X4# -> Word32X4# -> Word32X4#
quotWord64X2# :: Word64X2# -> Word64X2# -> Word64X2#
quotWord8X32# :: Word8X32# -> Word8X32# -> Word8X32#
quotWord16X16# :: Word16X16# -> Word16X16# -> Word16X16#
quotWord32X8# :: Word32X8# -> Word32X8# -> Word32X8#
quotWord64X4# :: Word64X4# -> Word64X4# -> Word64X4#
quotWord8X64# :: Word8X64# -> Word8X64# -> Word8X64#
quotWord16X32# :: Word16X32# -> Word16X32# -> Word16X32#
quotWord32X16# :: Word32X16# -> Word32X16# -> Word32X16#
quotWord64X8# :: Word64X8# -> Word64X8# -> Word64X8#
remInt8X16# :: Int8X16# -> Int8X16# -> Int8X16#
remInt16X8# :: Int16X8# -> Int16X8# -> Int16X8#
remInt32X4# :: Int32X4# -> Int32X4# -> Int32X4#
remInt64X2# :: Int64X2# -> Int64X2# -> Int64X2#
remInt8X32# :: Int8X32# -> Int8X32# -> Int8X32#
remInt16X16# :: Int16X16# -> Int16X16# -> Int16X16#
remInt32X8# :: Int32X8# -> Int32X8# -> Int32X8#
remInt64X4# :: Int64X4# -> Int64X4# -> Int64X4#
remInt8X64# :: Int8X64# -> Int8X64# -> Int8X64#
remInt16X32# :: Int16X32# -> Int16X32# -> Int16X32#
remInt32X16# :: Int32X16# -> Int32X16# -> Int32X16#
remInt64X8# :: Int64X8# -> Int64X8# -> Int64X8#
remWord8X16# :: Word8X16# -> Word8X16# -> Word8X16#
remWord16X8# :: Word16X8# -> Word16X8# -> Word16X8#
remWord32X4# :: Word32X4# -> Word32X4# -> Word32X4#
remWord64X2# :: Word64X2# -> Word64X2# -> Word64X2#
remWord8X32# :: Word8X32# -> Word8X32# -> Word8X32#
remWord16X16# :: Word16X16# -> Word16X16# -> Word16X16#
remWord32X8# :: Word32X8# -> Word32X8# -> Word32X8#
remWord64X4# :: Word64X4# -> Word64X4# -> Word64X4#
remWord8X64# :: Word8X64# -> Word8X64# -> Word8X64#
remWord16X32# :: Word16X32# -> Word16X32# -> Word16X32#
remWord32X16# :: Word32X16# -> Word32X16# -> Word32X16#
remWord64X8# :: Word64X8# -> Word64X8# -> Word64X8#
negateInt8X16# :: Int8X16# -> Int8X16#
negateInt16X8# :: Int16X8# -> Int16X8#
negateInt32X4# :: Int32X4# -> Int32X4#
negateInt64X2# :: Int64X2# -> Int64X2#
negateInt8X32# :: Int8X32# -> Int8X32#
negateInt16X16# :: Int16X16# -> Int16X16#
negateInt32X8# :: Int32X8# -> Int32X8#
negateInt64X4# :: Int64X4# -> Int64X4#
negateInt8X64# :: Int8X64# -> Int8X64#
negateInt16X32# :: Int16X32# -> Int16X32#
negateInt32X16# :: Int32X16# -> Int32X16#
negateInt64X8# :: Int64X8# -> Int64X8#
negateFloatX4# :: FloatX4# -> FloatX4#
negateDoubleX2# :: DoubleX2# -> DoubleX2#
negateFloatX8# :: FloatX8# -> FloatX8#
negateDoubleX4# :: DoubleX4# -> DoubleX4#
negateFloatX16# :: FloatX16# -> FloatX16#
negateDoubleX8# :: DoubleX8# -> DoubleX8#
indexInt8X16Array# :: ByteArray# -> Int# -> Int8X16#
indexInt16X8Array# :: ByteArray# -> Int# -> Int16X8#
indexInt32X4Array# :: ByteArray# -> Int# -> Int32X4#
indexInt64X2Array# :: ByteArray# -> Int# -> Int64X2#
indexInt8X32Array# :: ByteArray# -> Int# -> Int8X32#
indexInt16X16Array# :: ByteArray# -> Int# -> Int16X16#
indexInt32X8Array# :: ByteArray# -> Int# -> Int32X8#
indexInt64X4Array# :: ByteArray# -> Int# -> Int64X4#
indexInt8X64Array# :: ByteArray# -> Int# -> Int8X64#
indexInt16X32Array# :: ByteArray# -> Int# -> Int16X32#
indexInt32X16Array# :: ByteArray# -> Int# -> Int32X16#
indexInt64X8Array# :: ByteArray# -> Int# -> Int64X8#
indexWord8X16Array# :: ByteArray# -> Int# -> Word8X16#
indexWord16X8Array# :: ByteArray# -> Int# -> Word16X8#
indexWord32X4Array# :: ByteArray# -> Int# -> Word32X4#
indexWord64X2Array# :: ByteArray# -> Int# -> Word64X2#
indexWord8X32Array# :: ByteArray# -> Int# -> Word8X32#
indexWord16X16Array# :: ByteArray# -> Int# -> Word16X16#
indexWord32X8Array# :: ByteArray# -> Int# -> Word32X8#
indexWord64X4Array# :: ByteArray# -> Int# -> Word64X4#
indexWord8X64Array# :: ByteArray# -> Int# -> Word8X64#
indexWord16X32Array# :: ByteArray# -> Int# -> Word16X32#
indexWord32X16Array# :: ByteArray# -> Int# -> Word32X16#
indexWord64X8Array# :: ByteArray# -> Int# -> Word64X8#
indexFloatX4Array# :: ByteArray# -> Int# -> FloatX4#
indexDoubleX2Array# :: ByteArray# -> Int# -> DoubleX2#
indexFloatX8Array# :: ByteArray# -> Int# -> FloatX8#
indexDoubleX4Array# :: ByteArray# -> Int# -> DoubleX4#
indexFloatX16Array# :: ByteArray# -> Int# -> FloatX16#
indexDoubleX8Array# :: ByteArray# -> Int# -> DoubleX8#
readInt8X16Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int8X16# #)
readInt16X8Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int16X8# #)
readInt32X4Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int32X4# #)
readInt64X2Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int64X2# #)
readInt8X32Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int8X32# #)
readInt16X16Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int16X16# #)
readInt32X8Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int32X8# #)
readInt64X4Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int64X4# #)
readInt8X64Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int8X64# #)
readInt16X32Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int16X32# #)
readInt32X16Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int32X16# #)
readInt64X8Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int64X8# #)
readWord8X16Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Word8X16# #)
readWord16X8Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Word16X8# #)
readWord32X4Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Word32X4# #)
readWord64X2Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Word64X2# #)
readWord8X32Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Word8X32# #)
readWord16X16Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Word16X16# #)
readWord32X8Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Word32X8# #)
readWord64X4Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Word64X4# #)
readWord8X64Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Word8X64# #)
readWord16X32Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Word16X32# #)
readWord32X16Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Word32X16# #)
readWord64X8Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Word64X8# #)
readFloatX4Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, FloatX4# #)
readDoubleX2Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, DoubleX2# #)
readFloatX8Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, FloatX8# #)
readDoubleX4Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, DoubleX4# #)
readFloatX16Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, FloatX16# #)
readDoubleX8Array# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, DoubleX8# #)
writeInt8X16Array# :: MutableByteArray# d -> Int# -> Int8X16# -> State# d -> State# d
writeInt16X8Array# :: MutableByteArray# d -> Int# -> Int16X8# -> State# d -> State# d
writeInt32X4Array# :: MutableByteArray# d -> Int# -> Int32X4# -> State# d -> State# d
writeInt64X2Array# :: MutableByteArray# d -> Int# -> Int64X2# -> State# d -> State# d
writeInt8X32Array# :: MutableByteArray# d -> Int# -> Int8X32# -> State# d -> State# d
writeInt16X16Array# :: MutableByteArray# d -> Int# -> Int16X16# -> State# d -> State# d
writeInt32X8Array# :: MutableByteArray# d -> Int# -> Int32X8# -> State# d -> State# d
writeInt64X4Array# :: MutableByteArray# d -> Int# -> Int64X4# -> State# d -> State# d
writeInt8X64Array# :: MutableByteArray# d -> Int# -> Int8X64# -> State# d -> State# d
writeInt16X32Array# :: MutableByteArray# d -> Int# -> Int16X32# -> State# d -> State# d
writeInt32X16Array# :: MutableByteArray# d -> Int# -> Int32X16# -> State# d -> State# d
writeInt64X8Array# :: MutableByteArray# d -> Int# -> Int64X8# -> State# d -> State# d
writeWord8X16Array# :: MutableByteArray# d -> Int# -> Word8X16# -> State# d -> State# d
writeWord16X8Array# :: MutableByteArray# d -> Int# -> Word16X8# -> State# d -> State# d
writeWord32X4Array# :: MutableByteArray# d -> Int# -> Word32X4# -> State# d -> State# d
writeWord64X2Array# :: MutableByteArray# d -> Int# -> Word64X2# -> State# d -> State# d
writeWord8X32Array# :: MutableByteArray# d -> Int# -> Word8X32# -> State# d -> State# d
writeWord16X16Array# :: MutableByteArray# d -> Int# -> Word16X16# -> State# d -> State# d
writeWord32X8Array# :: MutableByteArray# d -> Int# -> Word32X8# -> State# d -> State# d
writeWord64X4Array# :: MutableByteArray# d -> Int# -> Word64X4# -> State# d -> State# d
writeWord8X64Array# :: MutableByteArray# d -> Int# -> Word8X64# -> State# d -> State# d
writeWord16X32Array# :: MutableByteArray# d -> Int# -> Word16X32# -> State# d -> State# d
writeWord32X16Array# :: MutableByteArray# d -> Int# -> Word32X16# -> State# d -> State# d
writeWord64X8Array# :: MutableByteArray# d -> Int# -> Word64X8# -> State# d -> State# d
writeFloatX4Array# :: MutableByteArray# d -> Int# -> FloatX4# -> State# d -> State# d
writeDoubleX2Array# :: MutableByteArray# d -> Int# -> DoubleX2# -> State# d -> State# d
writeFloatX8Array# :: MutableByteArray# d -> Int# -> FloatX8# -> State# d -> State# d
writeDoubleX4Array# :: MutableByteArray# d -> Int# -> DoubleX4# -> State# d -> State# d
writeFloatX16Array# :: MutableByteArray# d -> Int# -> FloatX16# -> State# d -> State# d
writeDoubleX8Array# :: MutableByteArray# d -> Int# -> DoubleX8# -> State# d -> State# d
indexInt8X16OffAddr# :: Addr# -> Int# -> Int8X16#
indexInt16X8OffAddr# :: Addr# -> Int# -> Int16X8#
indexInt32X4OffAddr# :: Addr# -> Int# -> Int32X4#
indexInt64X2OffAddr# :: Addr# -> Int# -> Int64X2#
indexInt8X32OffAddr# :: Addr# -> Int# -> Int8X32#
indexInt16X16OffAddr# :: Addr# -> Int# -> Int16X16#
indexInt32X8OffAddr# :: Addr# -> Int# -> Int32X8#
indexInt64X4OffAddr# :: Addr# -> Int# -> Int64X4#
indexInt8X64OffAddr# :: Addr# -> Int# -> Int8X64#
indexInt16X32OffAddr# :: Addr# -> Int# -> Int16X32#
indexInt32X16OffAddr# :: Addr# -> Int# -> Int32X16#
indexInt64X8OffAddr# :: Addr# -> Int# -> Int64X8#
indexWord8X16OffAddr# :: Addr# -> Int# -> Word8X16#
indexWord16X8OffAddr# :: Addr# -> Int# -> Word16X8#
indexWord32X4OffAddr# :: Addr# -> Int# -> Word32X4#
indexWord64X2OffAddr# :: Addr# -> Int# -> Word64X2#
indexWord8X32OffAddr# :: Addr# -> Int# -> Word8X32#
indexWord16X16OffAddr# :: Addr# -> Int# -> Word16X16#
indexWord32X8OffAddr# :: Addr# -> Int# -> Word32X8#
indexWord64X4OffAddr# :: Addr# -> Int# -> Word64X4#
indexWord8X64OffAddr# :: Addr# -> Int# -> Word8X64#
indexWord16X32OffAddr# :: Addr# -> Int# -> Word16X32#
indexWord32X16OffAddr# :: Addr# -> Int# -> Word32X16#
indexWord64X8OffAddr# :: Addr# -> Int# -> Word64X8#
indexFloatX4OffAddr# :: Addr# -> Int# -> FloatX4#
indexDoubleX2OffAddr# :: Addr# -> Int# -> DoubleX2#
indexFloatX8OffAddr# :: Addr# -> Int# -> FloatX8#
indexDoubleX4OffAddr# :: Addr# -> Int# -> DoubleX4#
indexFloatX16OffAddr# :: Addr# -> Int# -> FloatX16#
indexDoubleX8OffAddr# :: Addr# -> Int# -> DoubleX8#
readInt8X16OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Int8X16# #)
readInt16X8OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Int16X8# #)
readInt32X4OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Int32X4# #)
readInt64X2OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Int64X2# #)
readInt8X32OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Int8X32# #)
readInt16X16OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Int16X16# #)
readInt32X8OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Int32X8# #)
readInt64X4OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Int64X4# #)
readInt8X64OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Int8X64# #)
readInt16X32OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Int16X32# #)
readInt32X16OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Int32X16# #)
readInt64X8OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Int64X8# #)
readWord8X16OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Word8X16# #)
readWord16X8OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Word16X8# #)
readWord32X4OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Word32X4# #)
readWord64X2OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Word64X2# #)
readWord8X32OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Word8X32# #)
readWord16X16OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Word16X16# #)
readWord32X8OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Word32X8# #)
readWord64X4OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Word64X4# #)
readWord8X64OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Word8X64# #)
readWord16X32OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Word16X32# #)
readWord32X16OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Word32X16# #)
readWord64X8OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, Word64X8# #)
readFloatX4OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, FloatX4# #)
readDoubleX2OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, DoubleX2# #)
readFloatX8OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, FloatX8# #)
readDoubleX4OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, DoubleX4# #)
readFloatX16OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, FloatX16# #)
readDoubleX8OffAddr# :: Addr# -> Int# -> State# d -> (# State# d, DoubleX8# #)
writeInt8X16OffAddr# :: Addr# -> Int# -> Int8X16# -> State# d -> State# d
writeInt16X8OffAddr# :: Addr# -> Int# -> Int16X8# -> State# d -> State# d
writeInt32X4OffAddr# :: Addr# -> Int# -> Int32X4# -> State# d -> State# d
writeInt64X2OffAddr# :: Addr# -> Int# -> Int64X2# -> State# d -> State# d
writeInt8X32OffAddr# :: Addr# -> Int# -> Int8X32# -> State# d -> State# d
writeInt16X16OffAddr# :: Addr# -> Int# -> Int16X16# -> State# d -> State# d
writeInt32X8OffAddr# :: Addr# -> Int# -> Int32X8# -> State# d -> State# d
writeInt64X4OffAddr# :: Addr# -> Int# -> Int64X4# -> State# d -> State# d
writeInt8X64OffAddr# :: Addr# -> Int# -> Int8X64# -> State# d -> State# d
writeInt16X32OffAddr# :: Addr# -> Int# -> Int16X32# -> State# d -> State# d
writeInt32X16OffAddr# :: Addr# -> Int# -> Int32X16# -> State# d -> State# d
writeInt64X8OffAddr# :: Addr# -> Int# -> Int64X8# -> State# d -> State# d
writeWord8X16OffAddr# :: Addr# -> Int# -> Word8X16# -> State# d -> State# d
writeWord16X8OffAddr# :: Addr# -> Int# -> Word16X8# -> State# d -> State# d
writeWord32X4OffAddr# :: Addr# -> Int# -> Word32X4# -> State# d -> State# d
writeWord64X2OffAddr# :: Addr# -> Int# -> Word64X2# -> State# d -> State# d
writeWord8X32OffAddr# :: Addr# -> Int# -> Word8X32# -> State# d -> State# d
writeWord16X16OffAddr# :: Addr# -> Int# -> Word16X16# -> State# d -> State# d
writeWord32X8OffAddr# :: Addr# -> Int# -> Word32X8# -> State# d -> State# d
writeWord64X4OffAddr# :: Addr# -> Int# -> Word64X4# -> State# d -> State# d
writeWord8X64OffAddr# :: Addr# -> Int# -> Word8X64# -> State# d -> State# d
writeWord16X32OffAddr# :: Addr# -> Int# -> Word16X32# -> State# d -> State# d
writeWord32X16OffAddr# :: Addr# -> Int# -> Word32X16# -> State# d -> State# d
writeWord64X8OffAddr# :: Addr# -> Int# -> Word64X8# -> State# d -> State# d
writeFloatX4OffAddr# :: Addr# -> Int# -> FloatX4# -> State# d -> State# d
writeDoubleX2OffAddr# :: Addr# -> Int# -> DoubleX2# -> State# d -> State# d
writeFloatX8OffAddr# :: Addr# -> Int# -> FloatX8# -> State# d -> State# d
writeDoubleX4OffAddr# :: Addr# -> Int# -> DoubleX4# -> State# d -> State# d
writeFloatX16OffAddr# :: Addr# -> Int# -> FloatX16# -> State# d -> State# d
writeDoubleX8OffAddr# :: Addr# -> Int# -> DoubleX8# -> State# d -> State# d
indexInt8ArrayAsInt8X16# :: ByteArray# -> Int# -> Int8X16#
indexInt16ArrayAsInt16X8# :: ByteArray# -> Int# -> Int16X8#
indexInt32ArrayAsInt32X4# :: ByteArray# -> Int# -> Int32X4#
indexInt64ArrayAsInt64X2# :: ByteArray# -> Int# -> Int64X2#
indexInt8ArrayAsInt8X32# :: ByteArray# -> Int# -> Int8X32#
indexInt16ArrayAsInt16X16# :: ByteArray# -> Int# -> Int16X16#
indexInt32ArrayAsInt32X8# :: ByteArray# -> Int# -> Int32X8#
indexInt64ArrayAsInt64X4# :: ByteArray# -> Int# -> Int64X4#
indexInt8ArrayAsInt8X64# :: ByteArray# -> Int# -> Int8X64#
indexInt16ArrayAsInt16X32# :: ByteArray# -> Int# -> Int16X32#
indexInt32ArrayAsInt32X16# :: ByteArray# -> Int# -> Int32X16#
indexInt64ArrayAsInt64X8# :: ByteArray# -> Int# -> Int64X8#
indexWord8ArrayAsWord8X16# :: ByteArray# -> Int# -> Word8X16#
indexWord16ArrayAsWord16X8# :: ByteArray# -> Int# -> Word16X8#
indexWord32ArrayAsWord32X4# :: ByteArray# -> Int# -> Word32X4#
indexWord64ArrayAsWord64X2# :: ByteArray# -> Int# -> Word64X2#
indexWord8ArrayAsWord8X32# :: ByteArray# -> Int# -> Word8X32#
indexWord16ArrayAsWord16X16# :: ByteArray# -> Int# -> Word16X16#
indexWord32ArrayAsWord32X8# :: ByteArray# -> Int# -> Word32X8#
indexWord64ArrayAsWord64X4# :: ByteArray# -> Int# -> Word64X4#
indexWord8ArrayAsWord8X64# :: ByteArray# -> Int# -> Word8X64#
indexWord16ArrayAsWord16X32# :: ByteArray# -> Int# -> Word16X32#
indexWord32ArrayAsWord32X16# :: ByteArray# -> Int# -> Word32X16#
indexWord64ArrayAsWord64X8# :: ByteArray# -> Int# -> Word64X8#
indexFloatArrayAsFloatX4# :: ByteArray# -> Int# -> FloatX4#
indexDoubleArrayAsDoubleX2# :: ByteArray# -> Int# -> DoubleX2#
indexFloatArrayAsFloatX8# :: ByteArray# -> Int# -> FloatX8#
indexDoubleArrayAsDoubleX4# :: ByteArray# -> Int# -> DoubleX4#
indexFloatArrayAsFloatX16# :: ByteArray# -> Int# -> FloatX16#
indexDoubleArrayAsDoubleX8# :: ByteArray# -> Int# -> DoubleX8#
readInt8ArrayAsInt8X16# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int8X16# #)
readInt16ArrayAsInt16X8# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int16X8# #)
readInt32ArrayAsInt32X4# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int32X4# #)
readInt64ArrayAsInt64X2# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int64X2# #)
readInt8ArrayAsInt8X32# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int8X32# #)
readInt16ArrayAsInt16X16# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int16X16# #)
readInt32ArrayAsInt32X8# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int32X8# #)
readInt64ArrayAsInt64X4# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int64X4# #)
readInt8ArrayAsInt8X64# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int8X64# #)
readInt16ArrayAsInt16X32# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int16X32# #)
readInt32ArrayAsInt32X16# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int32X16# #)
readInt64ArrayAsInt64X8# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Int64X8# #)
readWord8ArrayAsWord8X16# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Word8X16# #)
readWord16ArrayAsWord16X8# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Word16X8# #)
readWord32ArrayAsWord32X4# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Word32X4# #)
readWord64ArrayAsWord64X2# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Word64X2# #)
readWord8ArrayAsWord8X32# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Word8X32# #)
readWord16ArrayAsWord16X16# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Word16X16# #)
readWord32ArrayAsWord32X8# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Word32X8# #)
readWord64ArrayAsWord64X4# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Word64X4# #)
readWord8ArrayAsWord8X64# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Word8X64# #)
readWord16ArrayAsWord16X32# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Word16X32# #)
readWord32ArrayAsWord32X16# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Word32X16# #)
readWord64ArrayAsWord64X8# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, Word64X8# #)
readFloatArrayAsFloatX4# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, FloatX4# #)
readDoubleArrayAsDoubleX2# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, DoubleX2# #)
readFloatArrayAsFloatX8# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, FloatX8# #)
readDoubleArrayAsDoubleX4# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, DoubleX4# #)
readFloatArrayAsFloatX16# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, FloatX16# #)
readDoubleArrayAsDoubleX8# :: MutableByteArray# d -> Int# -> State# d -> (# State# d, DoubleX8# #)
writeInt8ArrayAsInt8X16# :: MutableByteArray# d -> Int# -> Int8X16# -> State# d -> State# d
writeInt16ArrayAsInt16X8# :: MutableByteArray# d -> Int# -> Int16X8# -> State# d -> State# d
writeInt32ArrayAsInt32X4# :: MutableByteArray# d -> Int# -> Int32X4# -> State# d -> State# d
writeInt64ArrayAsInt64X2# :: MutableByteArray# d -> Int# -> Int64X2# -> State# d -> State# d
writeInt8ArrayAsInt8X32# :: MutableByteArray# d -> Int# -> Int8X32# -> State# d -> State# d
writeInt16ArrayAsInt16X16# :: MutableByteArray# d -> Int# -> Int16X16# -> State# d -> State# d
writeInt32ArrayAsInt32X8# :: MutableByteArray# d -> Int# -> Int32X8# -> State# d -> State# d
writeInt64ArrayAsInt64X4# :: MutableByteArray# d -> Int# -> Int64X4# -> State# d -> State# d
writeInt8ArrayAsInt8X64# :: MutableByteArray# d -> Int# -> Int8X64# -> State# d -> State# d
writeInt16ArrayAsInt16X32# :: MutableByteArray# d -> Int# -> Int16X32# -> State# d -> State# d
writeInt32ArrayAsInt32X16# :: MutableByteArray# d -> Int# -> Int32X16# -> State# d -> State# d
writeInt64ArrayAsInt64X8# :: MutableByteArray# d -> Int# -> Int64X8# -> State# d -> State# d
writeWord8ArrayAsWord8X16# :: MutableByteArray# d -> Int# -> Word8X16# -> State# d -> State# d
writeWord16ArrayAsWord16X8# :: MutableByteArray# d -> Int# -> Word16X8# -> State# d -> State# d
writeWord32ArrayAsWord32X4# :: MutableByteArray# d -> Int# -> Word32X4# -> State# d -> State# d
writeWord64ArrayAsWord64X2# :: MutableByteArray# d -> Int# -> Word64X2# -> State# d -> State# d
writeWord8ArrayAsWord8X32# :: MutableByteArray# d -> Int# -> Word8X32# -> State# d -> State# d
writeWord16ArrayAsWord16X16# :: MutableByteArray# d -> Int# -> Word16X16# -> State# d -> State# d
writeWord32ArrayAsWord32X8# :: MutableByteArray# d -> Int# -> Word32X8# -> State# d -> State# d
writeWord64ArrayAsWord64X4# :: MutableByteArray# d -> Int# -> Word64X4# -> State# d -> State# d
writeWord8ArrayAsWord8X64# :: MutableByteArray# d -> Int# -> Word8X64# -> State# d -> State# d
writeWord16ArrayAsWord16X32# :: MutableByteArray# d -> Int# -> Word16X32# -> State# d -> State# d
writeWord32ArrayAsWord32X16# :: MutableByteArray# d -> Int# -> Word32X16# -> State# d -> State# d
writeWord64ArrayAsWord64X8# :: MutableByteArray# d -> Int# -> Word64X8# -> State# d -> State# d
writeFloatArrayAsFloatX4# :: MutableByteArray# d -> Int# -> FloatX4# -> State# d -> State# d
writeDoubleArrayAsDoubleX2# :: MutableByteArray# d -> Int# -> DoubleX2# -> State# d -> State# d
writeFloatArrayAsFloatX8# :: MutableByteArray# d -> Int# -> FloatX8# -> State# d -> State# d
writeDoubleArrayAsDoubleX4# :: MutableByteArray# d -> Int# -> DoubleX4# -> State# d -> State# d
writeFloatArrayAsFloatX16# :: MutableByteArray# d -> Int# -> FloatX16# -> State# d -> State# d
writeDoubleArrayAsDoubleX8# :: MutableByteArray# d -> Int# -> DoubleX8# -> State# d -> State# d
indexInt8OffAddrAsInt8X16# :: Addr# -> Int# -> Int8X16#
indexInt16OffAddrAsInt16X8# :: Addr# -> Int# -> Int16X8#
indexInt32OffAddrAsInt32X4# :: Addr# -> Int# -> Int32X4#
indexInt64OffAddrAsInt64X2# :: Addr# -> Int# -> Int64X2#
indexInt8OffAddrAsInt8X32# :: Addr# -> Int# -> Int8X32#
indexInt16OffAddrAsInt16X16# :: Addr# -> Int# -> Int16X16#
indexInt32OffAddrAsInt32X8# :: Addr# -> Int# -> Int32X8#
indexInt64OffAddrAsInt64X4# :: Addr# -> Int# -> Int64X4#
indexInt8OffAddrAsInt8X64# :: Addr# -> Int# -> Int8X64#
indexInt16OffAddrAsInt16X32# :: Addr# -> Int# -> Int16X32#
indexInt32OffAddrAsInt32X16# :: Addr# -> Int# -> Int32X16#
indexInt64OffAddrAsInt64X8# :: Addr# -> Int# -> Int64X8#
indexWord8OffAddrAsWord8X16# :: Addr# -> Int# -> Word8X16#
indexWord16OffAddrAsWord16X8# :: Addr# -> Int# -> Word16X8#
indexWord32OffAddrAsWord32X4# :: Addr# -> Int# -> Word32X4#
indexWord64OffAddrAsWord64X2# :: Addr# -> Int# -> Word64X2#
indexWord8OffAddrAsWord8X32# :: Addr# -> Int# -> Word8X32#
indexWord16OffAddrAsWord16X16# :: Addr# -> Int# -> Word16X16#
indexWord32OffAddrAsWord32X8# :: Addr# -> Int# -> Word32X8#
indexWord64OffAddrAsWord64X4# :: Addr# -> Int# -> Word64X4#
indexWord8OffAddrAsWord8X64# :: Addr# -> Int# -> Word8X64#
indexWord16OffAddrAsWord16X32# :: Addr# -> Int# -> Word16X32#
indexWord32OffAddrAsWord32X16# :: Addr# -> Int# -> Word32X16#
indexWord64OffAddrAsWord64X8# :: Addr# -> Int# -> Word64X8#
indexFloatOffAddrAsFloatX4# :: Addr# -> Int# -> FloatX4#
indexDoubleOffAddrAsDoubleX2# :: Addr# -> Int# -> DoubleX2#
indexFloatOffAddrAsFloatX8# :: Addr# -> Int# -> FloatX8#
indexDoubleOffAddrAsDoubleX4# :: Addr# -> Int# -> DoubleX4#
indexFloatOffAddrAsFloatX16# :: Addr# -> Int# -> FloatX16#
indexDoubleOffAddrAsDoubleX8# :: Addr# -> Int# -> DoubleX8#
readInt8OffAddrAsInt8X16# :: Addr# -> Int# -> State# d -> (# State# d, Int8X16# #)
readInt16OffAddrAsInt16X8# :: Addr# -> Int# -> State# d -> (# State# d, Int16X8# #)
readInt32OffAddrAsInt32X4# :: Addr# -> Int# -> State# d -> (# State# d, Int32X4# #)
readInt64OffAddrAsInt64X2# :: Addr# -> Int# -> State# d -> (# State# d, Int64X2# #)
readInt8OffAddrAsInt8X32# :: Addr# -> Int# -> State# d -> (# State# d, Int8X32# #)
readInt16OffAddrAsInt16X16# :: Addr# -> Int# -> State# d -> (# State# d, Int16X16# #)
readInt32OffAddrAsInt32X8# :: Addr# -> Int# -> State# d -> (# State# d, Int32X8# #)
readInt64OffAddrAsInt64X4# :: Addr# -> Int# -> State# d -> (# State# d, Int64X4# #)
readInt8OffAddrAsInt8X64# :: Addr# -> Int# -> State# d -> (# State# d, Int8X64# #)
readInt16OffAddrAsInt16X32# :: Addr# -> Int# -> State# d -> (# State# d, Int16X32# #)
readInt32OffAddrAsInt32X16# :: Addr# -> Int# -> State# d -> (# State# d, Int32X16# #)
readInt64OffAddrAsInt64X8# :: Addr# -> Int# -> State# d -> (# State# d, Int64X8# #)
readWord8OffAddrAsWord8X16# :: Addr# -> Int# -> State# d -> (# State# d, Word8X16# #)
readWord16OffAddrAsWord16X8# :: Addr# -> Int# -> State# d -> (# State# d, Word16X8# #)
readWord32OffAddrAsWord32X4# :: Addr# -> Int# -> State# d -> (# State# d, Word32X4# #)
readWord64OffAddrAsWord64X2# :: Addr# -> Int# -> State# d -> (# State# d, Word64X2# #)
readWord8OffAddrAsWord8X32# :: Addr# -> Int# -> State# d -> (# State# d, Word8X32# #)
readWord16OffAddrAsWord16X16# :: Addr# -> Int# -> State# d -> (# State# d, Word16X16# #)
readWord32OffAddrAsWord32X8# :: Addr# -> Int# -> State# d -> (# State# d, Word32X8# #)
readWord64OffAddrAsWord64X4# :: Addr# -> Int# -> State# d -> (# State# d, Word64X4# #)
readWord8OffAddrAsWord8X64# :: Addr# -> Int# -> State# d -> (# State# d, Word8X64# #)
readWord16OffAddrAsWord16X32# :: Addr# -> Int# -> State# d -> (# State# d, Word16X32# #)
readWord32OffAddrAsWord32X16# :: Addr# -> Int# -> State# d -> (# State# d, Word32X16# #)
readWord64OffAddrAsWord64X8# :: Addr# -> Int# -> State# d -> (# State# d, Word64X8# #)
readFloatOffAddrAsFloatX4# :: Addr# -> Int# -> State# d -> (# State# d, FloatX4# #)
readDoubleOffAddrAsDoubleX2# :: Addr# -> Int# -> State# d -> (# State# d, DoubleX2# #)
readFloatOffAddrAsFloatX8# :: Addr# -> Int# -> State# d -> (# State# d, FloatX8# #)
readDoubleOffAddrAsDoubleX4# :: Addr# -> Int# -> State# d -> (# State# d, DoubleX4# #)
readFloatOffAddrAsFloatX16# :: Addr# -> Int# -> State# d -> (# State# d, FloatX16# #)
readDoubleOffAddrAsDoubleX8# :: Addr# -> Int# -> State# d -> (# State# d, DoubleX8# #)
writeInt8OffAddrAsInt8X16# :: Addr# -> Int# -> Int8X16# -> State# d -> State# d
writeInt16OffAddrAsInt16X8# :: Addr# -> Int# -> Int16X8# -> State# d -> State# d
writeInt32OffAddrAsInt32X4# :: Addr# -> Int# -> Int32X4# -> State# d -> State# d
writeInt64OffAddrAsInt64X2# :: Addr# -> Int# -> Int64X2# -> State# d -> State# d
writeInt8OffAddrAsInt8X32# :: Addr# -> Int# -> Int8X32# -> State# d -> State# d
writeInt16OffAddrAsInt16X16# :: Addr# -> Int# -> Int16X16# -> State# d -> State# d
writeInt32OffAddrAsInt32X8# :: Addr# -> Int# -> Int32X8# -> State# d -> State# d
writeInt64OffAddrAsInt64X4# :: Addr# -> Int# -> Int64X4# -> State# d -> State# d
writeInt8OffAddrAsInt8X64# :: Addr# -> Int# -> Int8X64# -> State# d -> State# d
writeInt16OffAddrAsInt16X32# :: Addr# -> Int# -> Int16X32# -> State# d -> State# d
writeInt32OffAddrAsInt32X16# :: Addr# -> Int# -> Int32X16# -> State# d -> State# d
writeInt64OffAddrAsInt64X8# :: Addr# -> Int# -> Int64X8# -> State# d -> State# d
writeWord8OffAddrAsWord8X16# :: Addr# -> Int# -> Word8X16# -> State# d -> State# d
writeWord16OffAddrAsWord16X8# :: Addr# -> Int# -> Word16X8# -> State# d -> State# d
writeWord32OffAddrAsWord32X4# :: Addr# -> Int# -> Word32X4# -> State# d -> State# d
writeWord64OffAddrAsWord64X2# :: Addr# -> Int# -> Word64X2# -> State# d -> State# d
writeWord8OffAddrAsWord8X32# :: Addr# -> Int# -> Word8X32# -> State# d -> State# d
writeWord16OffAddrAsWord16X16# :: Addr# -> Int# -> Word16X16# -> State# d -> State# d
writeWord32OffAddrAsWord32X8# :: Addr# -> Int# -> Word32X8# -> State# d -> State# d
writeWord64OffAddrAsWord64X4# :: Addr# -> Int# -> Word64X4# -> State# d -> State# d
writeWord8OffAddrAsWord8X64# :: Addr# -> Int# -> Word8X64# -> State# d -> State# d
writeWord16OffAddrAsWord16X32# :: Addr# -> Int# -> Word16X32# -> State# d -> State# d
writeWord32OffAddrAsWord32X16# :: Addr# -> Int# -> Word32X16# -> State# d -> State# d
writeWord64OffAddrAsWord64X8# :: Addr# -> Int# -> Word64X8# -> State# d -> State# d
writeFloatOffAddrAsFloatX4# :: Addr# -> Int# -> FloatX4# -> State# d -> State# d
writeDoubleOffAddrAsDoubleX2# :: Addr# -> Int# -> DoubleX2# -> State# d -> State# d
writeFloatOffAddrAsFloatX8# :: Addr# -> Int# -> FloatX8# -> State# d -> State# d
writeDoubleOffAddrAsDoubleX4# :: Addr# -> Int# -> DoubleX4# -> State# d -> State# d
writeFloatOffAddrAsFloatX16# :: Addr# -> Int# -> FloatX16# -> State# d -> State# d
writeDoubleOffAddrAsDoubleX8# :: Addr# -> Int# -> DoubleX8# -> State# d -> State# d
prefetchByteArray3# :: ByteArray# -> Int# -> State# d -> State# d
prefetchMutableByteArray3# :: MutableByteArray# d -> Int# -> State# d -> State# d
prefetchAddr3# :: Addr# -> Int# -> State# d -> State# d
prefetchValue3# :: a -> State# d -> State# d
prefetchByteArray2# :: ByteArray# -> Int# -> State# d -> State# d
prefetchMutableByteArray2# :: MutableByteArray# d -> Int# -> State# d -> State# d
prefetchAddr2# :: Addr# -> Int# -> State# d -> State# d
prefetchValue2# :: a -> State# d -> State# d
prefetchByteArray1# :: ByteArray# -> Int# -> State# d -> State# d
prefetchMutableByteArray1# :: MutableByteArray# d -> Int# -> State# d -> State# d
prefetchAddr1# :: Addr# -> Int# -> State# d -> State# d
prefetchValue1# :: a -> State# d -> State# d
prefetchByteArray0# :: ByteArray# -> Int# -> State# d -> State# d
prefetchMutableByteArray0# :: MutableByteArray# d -> Int# -> State# d -> State# d
prefetchAddr0# :: Addr# -> Int# -> State# d -> State# d
prefetchValue0# :: a -> State# d -> State# d
type WORD64 = Word#
type INT64 = Int#
getThreadAllocationCounter# :: State# RealWorld -> (# State# RealWorld, INT64 #)
resizeSmallMutableArray# :: SmallMutableArray# s a -> Int# -> a -> State# s -> (# State# s, SmallMutableArray# s a #)
atomicModifyMutVar# :: MutVar# s a -> (a -> b) -> State# s -> (# State# s, c #)
traceEvent :: String -> IO ()
sortWith :: Ord b => (a -> b) -> [a] -> [a]
the :: Eq a => [a] -> a
maxTupleSize :: Int
data SpecConstrAnnotation
- = NoSpecConstr
- | ForceSpecConstr
type family Item l
newtype Down a = Down {
- getDown :: a
}
uncheckedIShiftRA64# :: Int# -> Int# -> Int#
uncheckedIShiftL64# :: Int# -> Int# -> Int#
uncheckedShiftRL64# :: Word# -> Int# -> Word#
uncheckedShiftL64# :: Word# -> Int# -> Word#
currentCallStack :: IO [String]
iShiftRL# :: Int# -> Int# -> Int#
iShiftRA# :: Int# -> Int# -> Int#
iShiftL# :: Int# -> Int# -> Int#
shiftRL# :: Word# -> Int# -> Word#
shiftL# :: Word# -> Int# -> Word#
isTrue# :: Int# -> Bool
module GHC.Int
module GHC.Word

Missing primitives

unsafeThawByteArray# :: ByteArray# -> State# s -> (# State# s, MutableByteArray# s #) Source #

mutableByteArrayContents# :: MutableByteArray# s -> Addr# Source #

unsafeThawArrayArray# :: ArrayArray# -> State# s -> (# State# s, MutableArrayArray# s #) Source #

unInt# :: Int -> Int# Source #

unWord# :: Word -> Word# Source #

touch# :: a -> State# s -> State# s Source #

Same as touch#, except it is not restricted to RealWorld state token.

keepAlive# Source #

Arguments

:: a	The value to preserve
-> (State# s -> (# State# s, r #))	The continuation in which the value will be preserved
-> State# s
-> (# State# s, r #)

Forward compatible operator that might be introduced in some future ghc version.

See: #17760

Current version is not as efficient as the version that will be introduced in the future, because it works around the ghc bug by simply preventing inlining and relying on the touch function.

Since: 0.1.0

Primitive

Backwards compatibility