ghc-prim-0.5.1.1: GHC primitives

Safe Haskell | None
Language | Haskell2010

GHC.PrimopWrappers

# Documentation

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# #

plusWord# :: Word# -> Word# -> Word# #

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# #

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# #

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# #

logDouble# :: 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# #

(**##) :: 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# #

logFloat# :: 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# #

powerFloat# :: Float# -> Float# -> Float# #

float2Double# :: Float# -> Double# #

decodeFloat_Int# :: Float# -> (#Int#, Int##) #

newArray# :: Int# -> a -> State# s -> (#State# s, MutableArray# s a#) #

sameMutableArray# :: MutableArray# s a -> MutableArray# s a -> Int# #

readArray# :: MutableArray# s a -> Int# -> State# s -> (#State# s, a#) #

writeArray# :: MutableArray# s a -> Int# -> a -> State# s -> State# s #

sizeofArray# :: Array# a -> Int# #

sizeofMutableArray# :: MutableArray# s a -> Int# #

indexArray# :: Array# a -> Int# -> (#a#) #

unsafeFreezeArray# :: MutableArray# s a -> State# s -> (#State# s, Array# a#) #

unsafeThawArray# :: Array# a -> State# s -> (#State# s, MutableArray# s a#) #

copyArray# :: Array# a -> Int# -> MutableArray# s a -> Int# -> Int# -> State# s -> State# s #

copyMutableArray# :: MutableArray# s a -> Int# -> MutableArray# s a -> Int# -> Int# -> State# s -> State# s #

cloneArray# :: Array# a -> Int# -> Int# -> Array# a #

cloneMutableArray# :: MutableArray# s a -> Int# -> Int# -> State# s -> (#State# s, MutableArray# s a#) #

freezeArray# :: MutableArray# s a -> Int# -> Int# -> State# s -> (#State# s, Array# a#) #

thawArray# :: Array# a -> Int# -> Int# -> State# s -> (#State# s, MutableArray# s a#) #

casArray# :: MutableArray# s a -> Int# -> a -> a -> State# s -> (#State# s, Int#, a#) #

newSmallArray# :: Int# -> a -> State# s -> (#State# s, SmallMutableArray# s a#) #

sameSmallMutableArray# :: SmallMutableArray# s a -> SmallMutableArray# s a -> Int# #

readSmallArray# :: SmallMutableArray# s a -> Int# -> State# s -> (#State# s, a#) #

writeSmallArray# :: SmallMutableArray# s a -> Int# -> a -> State# s -> State# s #

sizeofSmallArray# :: SmallArray# a -> Int# #

sizeofSmallMutableArray# :: SmallMutableArray# s a -> Int# #

indexSmallArray# :: SmallArray# a -> Int# -> (#a#) #

unsafeFreezeSmallArray# :: SmallMutableArray# s a -> State# s -> (#State# s, SmallArray# a#) #

unsafeThawSmallArray# :: SmallArray# a -> State# s -> (#State# s, SmallMutableArray# s a#) #

copySmallArray# :: SmallArray# a -> Int# -> SmallMutableArray# s a -> Int# -> Int# -> State# s -> State# s #

copySmallMutableArray# :: SmallMutableArray# s a -> Int# -> SmallMutableArray# s a -> Int# -> Int# -> State# s -> State# s #

cloneSmallArray# :: SmallArray# a -> Int# -> Int# -> SmallArray# a #

cloneSmallMutableArray# :: SmallMutableArray# s a -> Int# -> Int# -> State# s -> (#State# s, SmallMutableArray# s a#) #

freezeSmallArray# :: SmallMutableArray# s a -> Int# -> Int# -> State# s -> (#State# s, SmallArray# a#) #

thawSmallArray# :: SmallArray# a -> Int# -> Int# -> State# s -> (#State# s, SmallMutableArray# s a#) #

casSmallArray# :: SmallMutableArray# s a -> Int# -> a -> a -> State# s -> (#State# s, Int#, a#) #

newByteArray# :: Int# -> State# s -> (#State# s, MutableByteArray# s#) #

newPinnedByteArray# :: Int# -> State# s -> (#State# s, MutableByteArray# s#) #

newAlignedPinnedByteArray# :: Int# -> Int# -> State# s -> (#State# s, MutableByteArray# s#) #

isMutableByteArrayPinned# :: MutableByteArray# s -> Int# #

isByteArrayPinned# :: ByteArray# -> Int# #

byteArrayContents# :: ByteArray# -> Addr# #

sameMutableByteArray# :: MutableByteArray# s -> MutableByteArray# s -> Int# #

shrinkMutableByteArray# :: MutableByteArray# s -> Int# -> State# s -> State# s #

resizeMutableByteArray# :: MutableByteArray# s -> Int# -> State# s -> (#State# s, MutableByteArray# s#) #

unsafeFreezeByteArray# :: MutableByteArray# s -> State# s -> (#State# s, ByteArray##) #

sizeofByteArray# :: ByteArray# -> Int# #

sizeofMutableByteArray# :: MutableByteArray# s -> Int# #

getSizeofMutableByteArray# :: MutableByteArray# s -> State# s -> (#State# s, 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# #

readCharArray# :: MutableByteArray# s -> Int# -> State# s -> (#State# s, Char##) #

readWideCharArray# :: MutableByteArray# s -> Int# -> State# s -> (#State# s, Char##) #

readIntArray# :: MutableByteArray# s -> Int# -> State# s -> (#State# s, Int##) #

readWordArray# :: MutableByteArray# s -> Int# -> State# s -> (#State# s, Word##) #

readAddrArray# :: MutableByteArray# s -> Int# -> State# s -> (#State# s, Addr##) #

readFloatArray# :: MutableByteArray# s -> Int# -> State# s -> (#State# s, Float##) #

readDoubleArray# :: MutableByteArray# s -> Int# -> State# s -> (#State# s, Double##) #

readStablePtrArray# :: MutableByteArray# s -> Int# -> State# s -> (#State# s, StablePtr# a#) #

readInt8Array# :: MutableByteArray# s -> Int# -> State# s -> (#State# s, Int##) #

readInt16Array# :: MutableByteArray# s -> Int# -> State# s -> (#State# s, Int##) #

readInt32Array# :: MutableByteArray# s -> Int# -> State# s -> (#State# s, Int##) #

readInt64Array# :: MutableByteArray# s -> Int# -> State# s -> (#State# s, Int##) #

readWord8Array# :: MutableByteArray# s -> Int# -> State# s -> (#State# s, Word##) #

readWord16Array# :: MutableByteArray# s -> Int# -> State# s -> (#State# s, Word##) #

readWord32Array# :: MutableByteArray# s -> Int# -> State# s -> (#State# s, Word##) #

readWord64Array# :: MutableByteArray# s -> Int# -> State# s -> (#State# s, Word##) #

writeCharArray# :: MutableByteArray# s -> Int# -> Char# -> State# s -> State# s #

writeWideCharArray# :: MutableByteArray# s -> Int# -> Char# -> State# s -> State# s #

writeIntArray# :: MutableByteArray# s -> Int# -> Int# -> State# s -> State# s #

writeWordArray# :: MutableByteArray# s -> Int# -> Word# -> State# s -> State# s #

writeAddrArray# :: MutableByteArray# s -> Int# -> Addr# -> State# s -> State# s #

writeFloatArray# :: MutableByteArray# s -> Int# -> Float# -> State# s -> State# s #

writeDoubleArray# :: MutableByteArray# s -> Int# -> Double# -> State# s -> State# s #

writeStablePtrArray# :: MutableByteArray# s -> Int# -> StablePtr# a -> State# s -> State# s #

writeInt8Array# :: MutableByteArray# s -> Int# -> Int# -> State# s -> State# s #

writeInt16Array# :: MutableByteArray# s -> Int# -> Int# -> State# s -> State# s #

writeInt32Array# :: MutableByteArray# s -> Int# -> Int# -> State# s -> State# s #

writeInt64Array# :: MutableByteArray# s -> Int# -> Int# -> State# s -> State# s #

writeWord8Array# :: MutableByteArray# s -> Int# -> Word# -> State# s -> State# s #

writeWord16Array# :: MutableByteArray# s -> Int# -> Word# -> State# s -> State# s #

writeWord32Array# :: MutableByteArray# s -> Int# -> Word# -> State# s -> State# s #

writeWord64Array# :: MutableByteArray# s -> Int# -> Word# -> State# s -> State# s #

copyByteArray# :: ByteArray# -> Int# -> MutableByteArray# s -> Int# -> Int# -> State# s -> State# s #

copyMutableByteArray# :: MutableByteArray# s -> Int# -> MutableByteArray# s -> Int# -> Int# -> State# s -> State# s #

copyByteArrayToAddr# :: ByteArray# -> Int# -> Addr# -> Int# -> State# s -> State# s #

copyMutableByteArrayToAddr# :: MutableByteArray# s -> Int# -> Addr# -> Int# -> State# s -> State# s #

copyAddrToByteArray# :: Addr# -> MutableByteArray# s -> Int# -> Int# -> State# s -> State# s #

setByteArray# :: MutableByteArray# s -> Int# -> Int# -> Int# -> State# s -> State# s #

atomicReadIntArray# :: MutableByteArray# s -> Int# -> State# s -> (#State# s, Int##) #

atomicWriteIntArray# :: MutableByteArray# s -> Int# -> Int# -> State# s -> State# s #

casIntArray# :: MutableByteArray# s -> Int# -> Int# -> Int# -> State# s -> (#State# s, Int##) #

fetchAddIntArray# :: MutableByteArray# s -> Int# -> Int# -> State# s -> (#State# s, Int##) #

fetchSubIntArray# :: MutableByteArray# s -> Int# -> Int# -> State# s -> (#State# s, Int##) #

fetchAndIntArray# :: MutableByteArray# s -> Int# -> Int# -> State# s -> (#State# s, Int##) #

fetchNandIntArray# :: MutableByteArray# s -> Int# -> Int# -> State# s -> (#State# s, Int##) #

fetchOrIntArray# :: MutableByteArray# s -> Int# -> Int# -> State# s -> (#State# s, Int##) #

fetchXorIntArray# :: MutableByteArray# s -> Int# -> Int# -> State# s -> (#State# s, Int##) #

newArrayArray# :: Int# -> State# s -> (#State# s, MutableArrayArray# s#) #

sameMutableArrayArray# :: MutableArrayArray# s -> MutableArrayArray# s -> Int# #

unsafeFreezeArrayArray# :: MutableArrayArray# s -> State# s -> (#State# s, ArrayArray##) #

sizeofArrayArray# :: ArrayArray# -> Int# #

sizeofMutableArrayArray# :: MutableArrayArray# s -> Int# #

indexByteArrayArray# :: ArrayArray# -> Int# -> ByteArray# #

indexArrayArrayArray# :: ArrayArray# -> Int# -> ArrayArray# #

readByteArrayArray# :: MutableArrayArray# s -> Int# -> State# s -> (#State# s, ByteArray##) #

readMutableByteArrayArray# :: MutableArrayArray# s -> Int# -> State# s -> (#State# s, MutableByteArray# s#) #

readArrayArrayArray# :: MutableArrayArray# s -> Int# -> State# s -> (#State# s, ArrayArray##) #

readMutableArrayArrayArray# :: MutableArrayArray# s -> Int# -> State# s -> (#State# s, MutableArrayArray# s#) #

writeByteArrayArray# :: MutableArrayArray# s -> Int# -> ByteArray# -> State# s -> State# s #

writeMutableByteArrayArray# :: MutableArrayArray# s -> Int# -> MutableByteArray# s -> State# s -> State# s #

writeArrayArrayArray# :: MutableArrayArray# s -> Int# -> ArrayArray# -> State# s -> State# s #

writeMutableArrayArrayArray# :: MutableArrayArray# s -> Int# -> MutableArrayArray# s -> State# s -> State# s #

copyArrayArray# :: ArrayArray# -> Int# -> MutableArrayArray# s -> Int# -> Int# -> State# s -> State# s #

copyMutableArrayArray# :: MutableArrayArray# s -> Int# -> MutableArrayArray# s -> Int# -> Int# -> State# s -> State# s #

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# s -> (#State# s, Char##) #

readWideCharOffAddr# :: Addr# -> Int# -> State# s -> (#State# s, Char##) #

readIntOffAddr# :: Addr# -> Int# -> State# s -> (#State# s, Int##) #

readWordOffAddr# :: Addr# -> Int# -> State# s -> (#State# s, Word##) #

readAddrOffAddr# :: Addr# -> Int# -> State# s -> (#State# s, Addr##) #

readFloatOffAddr# :: Addr# -> Int# -> State# s -> (#State# s, Float##) #

readDoubleOffAddr# :: Addr# -> Int# -> State# s -> (#State# s, Double##) #

readStablePtrOffAddr# :: Addr# -> Int# -> State# s -> (#State# s, StablePtr# a#) #

readInt8OffAddr# :: Addr# -> Int# -> State# s -> (#State# s, Int##) #

readInt16OffAddr# :: Addr# -> Int# -> State# s -> (#State# s, Int##) #

readInt32OffAddr# :: Addr# -> Int# -> State# s -> (#State# s, Int##) #

readInt64OffAddr# :: Addr# -> Int# -> State# s -> (#State# s, Int##) #

readWord8OffAddr# :: Addr# -> Int# -> State# s -> (#State# s, Word##) #

readWord16OffAddr# :: Addr# -> Int# -> State# s -> (#State# s, Word##) #

readWord32OffAddr# :: Addr# -> Int# -> State# s -> (#State# s, Word##) #

readWord64OffAddr# :: Addr# -> Int# -> State# s -> (#State# s, Word##) #

writeCharOffAddr# :: Addr# -> Int# -> Char# -> State# s -> State# s #

writeWideCharOffAddr# :: Addr# -> Int# -> Char# -> State# s -> State# s #

writeIntOffAddr# :: Addr# -> Int# -> Int# -> State# s -> State# s #

writeWordOffAddr# :: Addr# -> Int# -> Word# -> State# s -> State# s #

writeAddrOffAddr# :: Addr# -> Int# -> Addr# -> State# s -> State# s #

writeFloatOffAddr# :: Addr# -> Int# -> Float# -> State# s -> State# s #

writeDoubleOffAddr# :: Addr# -> Int# -> Double# -> State# s -> State# s #

writeStablePtrOffAddr# :: Addr# -> Int# -> StablePtr# a -> State# s -> State# s #

writeInt8OffAddr# :: Addr# -> Int# -> Int# -> State# s -> State# s #

writeInt16OffAddr# :: Addr# -> Int# -> Int# -> State# s -> State# s #

writeInt32OffAddr# :: Addr# -> Int# -> Int# -> State# s -> State# s #

writeInt64OffAddr# :: Addr# -> Int# -> Int# -> State# s -> State# s #

writeWord8OffAddr# :: Addr# -> Int# -> Word# -> State# s -> State# s #

writeWord16OffAddr# :: Addr# -> Int# -> Word# -> State# s -> State# s #

writeWord32OffAddr# :: Addr# -> Int# -> Word# -> State# s -> State# s #

writeWord64OffAddr# :: Addr# -> Int# -> Word# -> State# s -> State# s #

newMutVar# :: a -> State# s -> (#State# s, MutVar# s a#) #

readMutVar# :: MutVar# s a -> State# s -> (#State# s, a#) #

writeMutVar# :: MutVar# s a -> a -> State# s -> State# s #

sameMutVar# :: MutVar# s a -> MutVar# s a -> Int# #

atomicModifyMutVar# :: MutVar# s a -> (a -> b) -> State# s -> (#State# s, c#) #

casMutVar# :: MutVar# s a -> a -> a -> State# s -> (#State# s, Int#, a#) #

catch# :: (State# RealWorld -> (#State# RealWorld, a#)) -> (b -> State# RealWorld -> (#State# RealWorld, a#)) -> State# RealWorld -> (#State# RealWorld, a#) #

raise# :: b -> o #

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#) #

check# :: (State# RealWorld -> (#State# RealWorld, a#)) -> State# RealWorld -> State# RealWorld #

newTVar# :: a -> State# s -> (#State# s, TVar# s a#) #

readTVar# :: TVar# s a -> State# s -> (#State# s, a#) #

readTVarIO# :: TVar# s a -> State# s -> (#State# s, a#) #

writeTVar# :: TVar# s a -> a -> State# s -> State# s #

sameTVar# :: TVar# s a -> TVar# s a -> Int# #

newMVar# :: State# s -> (#State# s, MVar# s a#) #

takeMVar# :: MVar# s a -> State# s -> (#State# s, a#) #

tryTakeMVar# :: MVar# s a -> State# s -> (#State# s, Int#, a#) #

putMVar# :: MVar# s a -> a -> State# s -> State# s #

tryPutMVar# :: MVar# s a -> a -> State# s -> (#State# s, Int##) #

readMVar# :: MVar# s a -> State# s -> (#State# s, a#) #

tryReadMVar# :: MVar# s a -> State# s -> (#State# s, Int#, a#) #

sameMVar# :: MVar# s a -> MVar# s a -> Int# #

isEmptyMVar# :: MVar# s a -> State# s -> (#State# s, Int##) #

delay# :: Int# -> State# s -> State# s #

waitRead# :: Int# -> State# s -> State# s #

waitWrite# :: Int# -> State# s -> State# s #

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# s -> State# s #

threadStatus# :: ThreadId# -> State# RealWorld -> (#State# RealWorld, Int#, Int#, Int##) #

mkWeak# :: o -> b -> (State# RealWorld -> (#State# RealWorld, c#)) -> State# RealWorld -> (#State# RealWorld, Weak# b#) #

mkWeakNoFinalizer# :: o -> 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#)#) #

touch# :: o -> State# RealWorld -> State# RealWorld #

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# s -> (#State# s, a#) #

seq# :: a -> State# s -> (#State# s, a#) #

getSpark# :: State# s -> (#State# s, Int#, a#) #

numSparks# :: State# s -> (#State# s, Int##) #

dataToTag# :: a -> Int# #

addrToAny# :: Addr# -> (#a#) #

anyToAddr# :: a -> State# RealWorld -> (#State# RealWorld, Addr##) #

mkApUpd0# :: BCO# -> (#a#) #

newBCO# :: ByteArray# -> ByteArray# -> Array# a -> Int# -> ByteArray# -> State# s -> (#State# s, BCO##) #

unpackClosure# :: a -> (#Addr#, Array# b, ByteArray##) #

getApStackVal# :: a -> Int# -> (#Int#, b#) #

getCCSOf# :: a -> State# s -> (#State# s, Addr##) #

getCurrentCCS# :: a -> State# s -> (#State# s, Addr##) #

clearCCS# :: (State# s -> (#State# s, a#)) -> State# s -> (#State# s, a#) #

traceEvent# :: Addr# -> State# s -> State# s #

traceMarker# :: Addr# -> State# s -> State# s #

prefetchByteArray3# :: ByteArray# -> Int# -> State# s -> State# s #

prefetchMutableByteArray3# :: MutableByteArray# s -> Int# -> State# s -> State# s #

prefetchAddr3# :: Addr# -> Int# -> State# s -> State# s #

prefetchValue3# :: a -> State# s -> State# s #

prefetchByteArray2# :: ByteArray# -> Int# -> State# s -> State# s #

prefetchMutableByteArray2# :: MutableByteArray# s -> Int# -> State# s -> State# s #

prefetchAddr2# :: Addr# -> Int# -> State# s -> State# s #

prefetchValue2# :: a -> State# s -> State# s #

prefetchByteArray1# :: ByteArray# -> Int# -> State# s -> State# s #

prefetchMutableByteArray1# :: MutableByteArray# s -> Int# -> State# s -> State# s #

prefetchAddr1# :: Addr# -> Int# -> State# s -> State# s #

prefetchValue1# :: a -> State# s -> State# s #

prefetchByteArray0# :: ByteArray# -> Int# -> State# s -> State# s #

prefetchMutableByteArray0# :: MutableByteArray# s -> Int# -> State# s -> State# s #

prefetchAddr0# :: Addr# -> Int# -> State# s -> State# s #

prefetchValue0# :: a -> State# s -> State# s #