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

int8ToInt# :: Int8# -> Int# #

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

uncheckedShiftLInt8# :: Int8# -> Int# -> Int8# #

uncheckedShiftRAInt8# :: Int8# -> Int# -> Int8# #

uncheckedShiftRLInt8# :: Int8# -> Int# -> Int8# #

int8ToWord8# :: Int8# -> Word8# #

eqInt8# :: Int8# -> Int8# -> Int# #

geInt8# :: Int8# -> Int8# -> Int# #

gtInt8# :: Int8# -> Int8# -> Int# #

leInt8# :: Int8# -> Int8# -> Int# #

ltInt8# :: Int8# -> Int8# -> Int# #

neInt8# :: Int8# -> Int8# -> Int# #

word8ToWord# :: Word8# -> Word# #

wordToWord8# :: Word# -> 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# #) #

andWord8# :: Word8# -> Word8# -> Word8# #

orWord8# :: Word8# -> Word8# -> Word8# #

xorWord8# :: Word8# -> Word8# -> Word8# #

notWord8# :: Word8# -> Word8# #

uncheckedShiftLWord8# :: Word8# -> Int# -> Word8# #

uncheckedShiftRLWord8# :: Word8# -> Int# -> Word8# #

word8ToInt8# :: Word8# -> Int8# #

eqWord8# :: Word8# -> Word8# -> Int# #

geWord8# :: Word8# -> Word8# -> Int# #

gtWord8# :: Word8# -> Word8# -> Int# #

leWord8# :: Word8# -> Word8# -> Int# #

ltWord8# :: Word8# -> Word8# -> Int# #

neWord8# :: Word8# -> Word8# -> Int# #

int16ToInt# :: Int16# -> Int# #

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

uncheckedShiftLInt16# :: Int16# -> Int# -> Int16# #

uncheckedShiftRAInt16# :: Int16# -> Int# -> Int16# #

uncheckedShiftRLInt16# :: Int16# -> Int# -> Int16# #

int16ToWord16# :: Int16# -> Word16# #

eqInt16# :: Int16# -> Int16# -> Int# #

geInt16# :: Int16# -> Int16# -> Int# #

gtInt16# :: Int16# -> Int16# -> Int# #

leInt16# :: Int16# -> Int16# -> Int# #

ltInt16# :: Int16# -> Int16# -> Int# #

neInt16# :: Int16# -> Int16# -> Int# #

word16ToWord# :: Word16# -> Word# #

wordToWord16# :: Word# -> 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# #) #

andWord16# :: Word16# -> Word16# -> Word16# #

orWord16# :: Word16# -> Word16# -> Word16# #

xorWord16# :: Word16# -> Word16# -> Word16# #

notWord16# :: Word16# -> Word16# #

uncheckedShiftLWord16# :: Word16# -> Int# -> Word16# #

uncheckedShiftRLWord16# :: Word16# -> Int# -> Word16# #

word16ToInt16# :: Word16# -> Int16# #

eqWord16# :: Word16# -> Word16# -> Int# #

geWord16# :: Word16# -> Word16# -> Int# #

gtWord16# :: Word16# -> Word16# -> Int# #

leWord16# :: Word16# -> Word16# -> Int# #

ltWord16# :: Word16# -> Word16# -> Int# #

neWord16# :: Word16# -> Word16# -> Int# #

int32ToInt# :: Int32# -> Int# #

intToInt32# :: Int# -> Int32# #

negateInt32# :: Int32# -> Int32# #

plusInt32# :: Int32# -> Int32# -> Int32# #

subInt32# :: Int32# -> Int32# -> Int32# #

timesInt32# :: Int32# -> Int32# -> Int32# #

quotInt32# :: Int32# -> Int32# -> Int32# #

remInt32# :: Int32# -> Int32# -> Int32# #

quotRemInt32# :: Int32# -> Int32# -> (# Int32#, Int32# #) #

uncheckedShiftLInt32# :: Int32# -> Int# -> Int32# #

uncheckedShiftRAInt32# :: Int32# -> Int# -> Int32# #

uncheckedShiftRLInt32# :: Int32# -> Int# -> Int32# #

int32ToWord32# :: Int32# -> Word32# #

eqInt32# :: Int32# -> Int32# -> Int# #

geInt32# :: Int32# -> Int32# -> Int# #

gtInt32# :: Int32# -> Int32# -> Int# #

leInt32# :: Int32# -> Int32# -> Int# #

ltInt32# :: Int32# -> Int32# -> Int# #

neInt32# :: Int32# -> Int32# -> Int# #

word32ToWord# :: Word32# -> Word# #

wordToWord32# :: Word# -> Word32# #

plusWord32# :: Word32# -> Word32# -> Word32# #

subWord32# :: Word32# -> Word32# -> Word32# #

timesWord32# :: Word32# -> Word32# -> Word32# #

quotWord32# :: Word32# -> Word32# -> Word32# #

remWord32# :: Word32# -> Word32# -> Word32# #

quotRemWord32# :: Word32# -> Word32# -> (# Word32#, Word32# #) #

andWord32# :: Word32# -> Word32# -> Word32# #

orWord32# :: Word32# -> Word32# -> Word32# #

xorWord32# :: Word32# -> Word32# -> Word32# #

notWord32# :: Word32# -> Word32# #

uncheckedShiftLWord32# :: Word32# -> Int# -> Word32# #

uncheckedShiftRLWord32# :: Word32# -> Int# -> Word32# #

word32ToInt32# :: Word32# -> Int32# #

eqWord32# :: Word32# -> Word32# -> Int# #

geWord32# :: Word32# -> Word32# -> Int# #

gtWord32# :: Word32# -> Word32# -> Int# #

leWord32# :: Word32# -> Word32# -> Int# #

ltWord32# :: Word32# -> Word32# -> Int# #

neWord32# :: Word32# -> Word32# -> Int# #

int64ToInt# :: Int64# -> Int# #

intToInt64# :: Int# -> Int64# #

negateInt64# :: Int64# -> Int64# #

plusInt64# :: Int64# -> Int64# -> Int64# #

subInt64# :: Int64# -> Int64# -> Int64# #

timesInt64# :: Int64# -> Int64# -> Int64# #

quotInt64# :: Int64# -> Int64# -> Int64# #

remInt64# :: Int64# -> Int64# -> Int64# #

uncheckedIShiftL64# :: Int64# -> Int# -> Int64# #

uncheckedIShiftRA64# :: Int64# -> Int# -> Int64# #

uncheckedIShiftRL64# :: Int64# -> Int# -> Int64# #

int64ToWord64# :: Int64# -> Word64# #

eqInt64# :: Int64# -> Int64# -> Int# #

geInt64# :: Int64# -> Int64# -> Int# #

gtInt64# :: Int64# -> Int64# -> Int# #

leInt64# :: Int64# -> Int64# -> Int# #

ltInt64# :: Int64# -> Int64# -> Int# #

neInt64# :: Int64# -> Int64# -> Int# #

word64ToWord# :: Word64# -> Word# #

wordToWord64# :: Word# -> Word64# #

plusWord64# :: Word64# -> Word64# -> Word64# #

subWord64# :: Word64# -> Word64# -> Word64# #

timesWord64# :: Word64# -> Word64# -> Word64# #

quotWord64# :: Word64# -> Word64# -> Word64# #

remWord64# :: Word64# -> Word64# -> Word64# #

and64# :: Word64# -> Word64# -> Word64# #

or64# :: Word64# -> Word64# -> Word64# #

xor64# :: Word64# -> Word64# -> Word64# #

not64# :: Word64# -> Word64# #

uncheckedShiftL64# :: Word64# -> Int# -> Word64# #

uncheckedShiftRL64# :: Word64# -> Int# -> Word64# #

word64ToInt64# :: Word64# -> Int64# #

eqWord64# :: Word64# -> Word64# -> Int# #

geWord64# :: Word64# -> Word64# -> Int# #

gtWord64# :: Word64# -> Word64# -> Int# #

leWord64# :: Word64# -> Word64# -> Int# #

ltWord64# :: Word64# -> Word64# -> Int# #

neWord64# :: Word64# -> Word64# -> Int# #

(+#) :: Int# -> Int# -> Int# #

(-#) :: Int# -> Int# -> Int# #

(*#) :: Int# -> Int# -> Int# #

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

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# :: Word64# -> Word# #

popCnt# :: Word# -> Word# #

pdep8# :: Word# -> Word# -> Word# #

pdep16# :: Word# -> Word# -> Word# #

pdep32# :: Word# -> Word# -> Word# #

pdep64# :: Word64# -> Word64# -> Word64# #

pdep# :: Word# -> Word# -> Word# #

pext8# :: Word# -> Word# -> Word# #

pext16# :: Word# -> Word# -> Word# #

pext32# :: Word# -> Word# -> Word# #

pext64# :: Word64# -> Word64# -> Word64# #

pext# :: Word# -> Word# -> Word# #

clz8# :: Word# -> Word# #

clz16# :: Word# -> Word# #

clz32# :: Word# -> Word# #

clz64# :: Word64# -> Word# #

clz# :: Word# -> Word# #

ctz8# :: Word# -> Word# #

ctz16# :: Word# -> Word# #

ctz32# :: Word# -> Word# #

ctz64# :: Word64# -> Word# #

ctz# :: Word# -> Word# #

byteSwap16# :: Word# -> Word# #

byteSwap32# :: Word# -> Word# #

byteSwap64# :: Word64# -> Word64# #

byteSwap# :: Word# -> Word# #

bitReverse8# :: Word# -> Word# #

bitReverse16# :: Word# -> Word# #

bitReverse32# :: Word# -> Word# #

bitReverse64# :: Word64# -> Word64# #

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

minDouble# :: Double# -> Double# -> Double# #

maxDouble# :: Double# -> Double# -> Double# #

(+##) :: 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# -> (# Int64#, Int# #) #

castDoubleToWord64# :: Double# -> Word64# #

castWord64ToDouble# :: Word64# -> Double# #

gtFloat# :: Float# -> Float# -> Int# #

geFloat# :: Float# -> Float# -> Int# #

eqFloat# :: Float# -> Float# -> Int# #

neFloat# :: Float# -> Float# -> Int# #

ltFloat# :: Float# -> Float# -> Int# #

leFloat# :: Float# -> Float# -> Int# #

minFloat# :: Float# -> Float# -> Float# #

maxFloat# :: Float# -> Float# -> Float# #

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

castFloatToWord32# :: Float# -> Word32# #

castWord32ToFloat# :: Word32# -> Float# #

fmaddFloat# :: Float# -> Float# -> Float# -> Float# #

fmsubFloat# :: Float# -> Float# -> Float# -> Float# #

fnmaddFloat# :: Float# -> Float# -> Float# -> Float# #

fnmsubFloat# :: Float# -> Float# -> Float# -> Float# #

fmaddDouble# :: Double# -> Double# -> Double# -> Double# #

fmsubDouble# :: Double# -> Double# -> Double# -> Double# #

fnmaddDouble# :: Double# -> Double# -> Double# -> Double# #

fnmsubDouble# :: Double# -> Double# -> Double# -> Double# #

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

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

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

sizeofArray# :: Array# a_levpoly -> Int# #

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

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

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

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

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

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

cloneArray# :: Array# a_levpoly -> Int# -> Int# -> Array# a_levpoly #

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

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

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

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

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

shrinkSmallMutableArray# :: SmallMutableArray# s a_levpoly -> Int# -> State# s -> State# s #

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

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

sizeofSmallArray# :: SmallArray# a_levpoly -> Int# #

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

getSizeofSmallMutableArray# :: SmallMutableArray# s a_levpoly -> State# s -> (# State# s, Int# #) #

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

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

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

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

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

cloneSmallArray# :: SmallArray# a_levpoly -> Int# -> Int# -> SmallArray# a_levpoly #

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

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

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

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

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

isByteArrayWeaklyPinned# :: ByteArray# -> Int# #

isMutableByteArrayWeaklyPinned# :: MutableByteArray# s -> Int# #

byteArrayContents# :: ByteArray# -> Addr# #

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

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

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

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

indexWord8Array# :: ByteArray# -> Int# -> Word8# #

indexInt16Array# :: ByteArray# -> Int# -> Int16# #

indexWord16Array# :: ByteArray# -> Int# -> Word16# #

indexInt32Array# :: ByteArray# -> Int# -> Int32# #

indexWord32Array# :: ByteArray# -> Int# -> Word32# #

indexInt64Array# :: ByteArray# -> Int# -> Int64# #

indexWord64Array# :: ByteArray# -> Int# -> Word64# #

indexWord8ArrayAsChar# :: ByteArray# -> Int# -> Char# #

indexWord8ArrayAsWideChar# :: ByteArray# -> Int# -> Char# #

indexWord8ArrayAsInt# :: ByteArray# -> Int# -> Int# #

indexWord8ArrayAsWord# :: ByteArray# -> Int# -> Word# #

indexWord8ArrayAsAddr# :: ByteArray# -> Int# -> Addr# #

indexWord8ArrayAsFloat# :: ByteArray# -> Int# -> Float# #

indexWord8ArrayAsDouble# :: ByteArray# -> Int# -> Double# #

indexWord8ArrayAsStablePtr# :: ByteArray# -> Int# -> StablePtr# a #

indexWord8ArrayAsInt16# :: ByteArray# -> Int# -> Int16# #

indexWord8ArrayAsWord16# :: ByteArray# -> Int# -> Word16# #

indexWord8ArrayAsInt32# :: ByteArray# -> Int# -> Int32# #

indexWord8ArrayAsWord32# :: ByteArray# -> Int# -> Word32# #

indexWord8ArrayAsInt64# :: ByteArray# -> Int# -> Int64# #

indexWord8ArrayAsWord64# :: ByteArray# -> Int# -> Word64# #

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

readWord8ArrayAsInt16# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, Int16# #) #

readWord8ArrayAsWord16# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, Word16# #) #

readWord8ArrayAsInt32# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, Int32# #) #

readWord8ArrayAsWord32# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, Word32# #) #

readWord8ArrayAsInt64# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, Int64# #) #

readWord8ArrayAsWord64# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, Word64# #) #

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

writeWord8ArrayAsInt16# :: MutableByteArray# s -> Int# -> Int16# -> State# s -> State# s #

writeWord8ArrayAsWord16# :: MutableByteArray# s -> Int# -> Word16# -> State# s -> State# s #

writeWord8ArrayAsInt32# :: MutableByteArray# s -> Int# -> Int32# -> State# s -> State# s #

writeWord8ArrayAsWord32# :: MutableByteArray# s -> Int# -> Word32# -> State# s -> State# s #

writeWord8ArrayAsInt64# :: MutableByteArray# s -> Int# -> Int64# -> State# s -> State# s #

writeWord8ArrayAsWord64# :: MutableByteArray# s -> Int# -> Word64# -> State# s -> State# s #

compareByteArrays# :: ByteArray# -> Int# -> ByteArray# -> Int# -> Int# -> Int# #

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

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

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

copyAddrToAddr# :: Addr# -> Addr# -> Int# -> State# RealWorld -> State# RealWorld #

copyAddrToAddrNonOverlapping# :: Addr# -> Addr# -> Int# -> State# RealWorld -> State# RealWorld #

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

setAddrRange# :: Addr# -> Int# -> Int# -> State# RealWorld -> State# RealWorld #

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

casInt8Array# :: MutableByteArray# s -> Int# -> Int8# -> Int8# -> State# s -> (# State# s, Int8# #) #

casInt16Array# :: MutableByteArray# s -> Int# -> Int16# -> Int16# -> State# s -> (# State# s, Int16# #) #

casInt32Array# :: MutableByteArray# s -> Int# -> Int32# -> Int32# -> State# s -> (# State# s, Int32# #) #

casInt64Array# :: MutableByteArray# s -> Int# -> Int64# -> Int64# -> State# s -> (# State# s, Int64# #) #

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

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

indexWord8OffAddr# :: Addr# -> Int# -> Word8# #

indexInt16OffAddr# :: Addr# -> Int# -> Int16# #

indexWord16OffAddr# :: Addr# -> Int# -> Word16# #

indexInt32OffAddr# :: Addr# -> Int# -> Int32# #

indexWord32OffAddr# :: Addr# -> Int# -> Word32# #

indexInt64OffAddr# :: Addr# -> Int# -> Int64# #

indexWord64OffAddr# :: Addr# -> Int# -> Word64# #

indexWord8OffAddrAsChar# :: Addr# -> Int# -> Char# #

indexWord8OffAddrAsWideChar# :: Addr# -> Int# -> Char# #

indexWord8OffAddrAsInt# :: Addr# -> Int# -> Int# #

indexWord8OffAddrAsWord# :: Addr# -> Int# -> Word# #

indexWord8OffAddrAsAddr# :: Addr# -> Int# -> Addr# #

indexWord8OffAddrAsFloat# :: Addr# -> Int# -> Float# #

indexWord8OffAddrAsDouble# :: Addr# -> Int# -> Double# #

indexWord8OffAddrAsStablePtr# :: Addr# -> Int# -> StablePtr# a #

indexWord8OffAddrAsInt16# :: Addr# -> Int# -> Int16# #

indexWord8OffAddrAsWord16# :: Addr# -> Int# -> Word16# #

indexWord8OffAddrAsInt32# :: Addr# -> Int# -> Int32# #

indexWord8OffAddrAsWord32# :: Addr# -> Int# -> Word32# #

indexWord8OffAddrAsInt64# :: Addr# -> Int# -> Int64# #

indexWord8OffAddrAsWord64# :: Addr# -> Int# -> Word64# #

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

readWord8OffAddrAsInt16# :: Addr# -> Int# -> State# s -> (# State# s, Int16# #) #

readWord8OffAddrAsWord16# :: Addr# -> Int# -> State# s -> (# State# s, Word16# #) #

readWord8OffAddrAsInt32# :: Addr# -> Int# -> State# s -> (# State# s, Int32# #) #

readWord8OffAddrAsWord32# :: Addr# -> Int# -> State# s -> (# State# s, Word32# #) #

readWord8OffAddrAsInt64# :: Addr# -> Int# -> State# s -> (# State# s, Int64# #) #

readWord8OffAddrAsWord64# :: Addr# -> Int# -> State# s -> (# State# s, Word64# #) #

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

writeWord8OffAddrAsInt16# :: Addr# -> Int# -> Int16# -> State# s -> State# s #

writeWord8OffAddrAsWord16# :: Addr# -> Int# -> Word16# -> State# s -> State# s #

writeWord8OffAddrAsInt32# :: Addr# -> Int# -> Int32# -> State# s -> State# s #

writeWord8OffAddrAsWord32# :: Addr# -> Int# -> Word32# -> State# s -> State# s #

writeWord8OffAddrAsInt64# :: Addr# -> Int# -> Int64# -> State# s -> State# s #

writeWord8OffAddrAsWord64# :: Addr# -> Int# -> Word64# -> State# s -> State# s #

atomicExchangeAddrAddr# :: Addr# -> Addr# -> State# s -> (# State# s, Addr# #) #

atomicExchangeWordAddr# :: Addr# -> Word# -> State# s -> (# State# s, Word# #) #

atomicCasAddrAddr# :: Addr# -> Addr# -> Addr# -> State# s -> (# State# s, Addr# #) #

atomicCasWordAddr# :: Addr# -> Word# -> Word# -> State# s -> (# State# s, Word# #) #

atomicCasWord8Addr# :: Addr# -> Word8# -> Word8# -> State# s -> (# State# s, Word8# #) #

atomicCasWord16Addr# :: Addr# -> Word16# -> Word16# -> State# s -> (# State# s, Word16# #) #

atomicCasWord32Addr# :: Addr# -> Word32# -> Word32# -> State# s -> (# State# s, Word32# #) #

atomicCasWord64Addr# :: Addr# -> Word64# -> Word64# -> State# s -> (# State# s, Word64# #) #

fetchAddWordAddr# :: Addr# -> Word# -> State# s -> (# State# s, Word# #) #

fetchSubWordAddr# :: Addr# -> Word# -> State# s -> (# State# s, Word# #) #

fetchAndWordAddr# :: Addr# -> Word# -> State# s -> (# State# s, Word# #) #

fetchNandWordAddr# :: Addr# -> Word# -> State# s -> (# State# s, Word# #) #

fetchOrWordAddr# :: Addr# -> Word# -> State# s -> (# State# s, Word# #) #

fetchXorWordAddr# :: Addr# -> Word# -> State# s -> (# State# s, Word# #) #

atomicReadWordAddr# :: Addr# -> State# s -> (# State# s, Word# #) #

atomicWriteWordAddr# :: Addr# -> Word# -> State# s -> State# s #

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

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

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

atomicSwapMutVar# :: MutVar# s a_levpoly -> a_levpoly -> State# s -> (# State# s, a_levpoly #) #

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

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

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

catch# :: (State# RealWorld -> (# State# RealWorld, a_reppoly #)) -> (b_levpoly -> State# RealWorld -> (# State# RealWorld, a_reppoly #)) -> State# RealWorld -> (# State# RealWorld, a_reppoly #) #

raise# :: a_levpoly -> b_reppoly #

raiseUnderflow# :: (# #) -> b_reppoly #

raiseOverflow# :: (# #) -> b_reppoly #

raiseDivZero# :: (# #) -> b_reppoly #

raiseIO# :: a_levpoly -> State# RealWorld -> (# State# RealWorld, b_reppoly #) #

maskAsyncExceptions# :: (State# RealWorld -> (# State# RealWorld, a_reppoly #)) -> State# RealWorld -> (# State# RealWorld, a_reppoly #) #

maskUninterruptible# :: (State# RealWorld -> (# State# RealWorld, a_reppoly #)) -> State# RealWorld -> (# State# RealWorld, a_reppoly #) #

unmaskAsyncExceptions# :: (State# RealWorld -> (# State# RealWorld, a_reppoly #)) -> State# RealWorld -> (# State# RealWorld, a_reppoly #) #

getMaskingState# :: State# RealWorld -> (# State# RealWorld, Int# #) #

newPromptTag# :: State# RealWorld -> (# State# RealWorld, PromptTag# a #) #

prompt# :: PromptTag# a -> (State# RealWorld -> (# State# RealWorld, a #)) -> State# RealWorld -> (# State# RealWorld, a #) #

control0# :: PromptTag# a -> (((State# RealWorld -> (# State# RealWorld, b_reppoly #)) -> State# RealWorld -> (# State# RealWorld, a #)) -> State# RealWorld -> (# State# RealWorld, a #)) -> State# RealWorld -> (# State# RealWorld, b_reppoly #) #

atomically# :: (State# RealWorld -> (# State# RealWorld, a_levpoly #)) -> State# RealWorld -> (# State# RealWorld, a_levpoly #) #

retry# :: State# RealWorld -> (# State# RealWorld, a_levpoly #) #

catchRetry# :: (State# RealWorld -> (# State# RealWorld, a_levpoly #)) -> (State# RealWorld -> (# State# RealWorld, a_levpoly #)) -> State# RealWorld -> (# State# RealWorld, a_levpoly #) #

catchSTM# :: (State# RealWorld -> (# State# RealWorld, a_levpoly #)) -> (b -> State# RealWorld -> (# State# RealWorld, a_levpoly #)) -> State# RealWorld -> (# State# RealWorld, a_levpoly #) #

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

fork# :: (State# RealWorld -> (# State# RealWorld, a_reppoly #)) -> State# RealWorld -> (# State# RealWorld, ThreadId# #) #

forkOn# :: Int# -> (State# RealWorld -> (# State# RealWorld, a_reppoly #)) -> 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# -> ByteArray# -> State# RealWorld -> State# RealWorld #

isCurrentThreadBound# :: State# RealWorld -> (# State# RealWorld, Int# #) #

noDuplicate# :: State# s -> State# s #

threadLabel# :: ThreadId# -> State# RealWorld -> (# State# RealWorld, Int#, ByteArray# #) #

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

listThreads# :: State# RealWorld -> (# State# RealWorld, Array# ThreadId# #) #

mkWeak# :: a_levpoly -> b_levpoly -> (State# RealWorld -> (# State# RealWorld, c #)) -> State# RealWorld -> (# State# RealWorld, Weak# b_levpoly #) #

mkWeakNoFinalizer# :: a_levpoly -> b_levpoly -> State# RealWorld -> (# State# RealWorld, Weak# b_levpoly #) #

addCFinalizerToWeak# :: Addr# -> Addr# -> Int# -> Addr# -> Weak# b_levpoly -> State# RealWorld -> (# State# RealWorld, Int# #) #

deRefWeak# :: Weak# a_levpoly -> State# RealWorld -> (# State# RealWorld, Int#, a_levpoly #) #

finalizeWeak# :: Weak# a_levpoly -> State# RealWorld -> (# State# RealWorld, Int#, State# RealWorld -> (# State# RealWorld, b #) #) #

touch# :: a_levpoly -> State# s -> State# s #

makeStablePtr# :: a_levpoly -> State# RealWorld -> (# State# RealWorld, StablePtr# a_levpoly #) #

deRefStablePtr# :: StablePtr# a_levpoly -> State# RealWorld -> (# State# RealWorld, a_levpoly #) #

eqStablePtr# :: StablePtr# a_levpoly -> StablePtr# a_levpoly -> Int# #

makeStableName# :: a_levpoly -> State# RealWorld -> (# State# RealWorld, StableName# a_levpoly #) #

stableNameToInt# :: StableName# a_levpoly -> 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_levpoly -> b_levpoly -> Int# #

par# :: a -> Int# #

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

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

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

keepAlive# :: a_levpoly -> State# s -> (State# s -> b_reppoly) -> b_reppoly #

dataToTagSmall# :: a_levpoly -> Int# #

dataToTagLarge# :: a_levpoly -> Int# #

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

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#, ByteArray#, Array# b #) #

closureSize# :: a -> Int# #

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

annotateStack# :: b -> (State# s -> (# State# s, a_reppoly #)) -> State# s -> (# State# s, a_reppoly #) #

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

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

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

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

setThreadAllocationCounter# :: Int64# -> State# RealWorld -> State# RealWorld #

setOtherThreadAllocationCounter# :: Int64# -> ThreadId# -> State# RealWorld -> State# RealWorld #

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 #