GHC.PrimopWrappers

ghc-prim-0.4.0.0: 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#

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#

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#

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

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#

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# :: a -> b

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

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

mkWeak# :: o -> b -> 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, ()#)#)

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#

reallyUnsafePtrEquality# :: a -> a -> Int#

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

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

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