module GHC.PrimopWrappers where
import qualified GHC.Prim
import GHC.Tuple ()
import GHC.Prim (Char#, Int#, Word#, Float#, Double#, State#, MutableArray#, Array#, MutableByteArray#, ByteArray#, Addr#, StablePtr#, MutableArrayArray#, ArrayArray#, MutVar#, RealWorld, TVar#, MVar#, ThreadId#, Weak#, StableName#, BCO#)
#if defined (__GLASGOW_HASKELL_LLVM__)
import GHC.Prim (FloatX4#, DoubleX2#, Int32X4#, Int64X2#)
#endif /* defined (__GLASGOW_HASKELL_LLVM__) */
gtCharI# :: Char# -> Char# -> Int#
gtCharI# a1 a2 = (GHC.Prim.gtCharI#) a1 a2
geCharI# :: Char# -> Char# -> Int#
geCharI# a1 a2 = (GHC.Prim.geCharI#) a1 a2
eqCharI# :: Char# -> Char# -> Int#
eqCharI# a1 a2 = (GHC.Prim.eqCharI#) a1 a2
neCharI# :: Char# -> Char# -> Int#
neCharI# a1 a2 = (GHC.Prim.neCharI#) a1 a2
ltCharI# :: Char# -> Char# -> Int#
ltCharI# a1 a2 = (GHC.Prim.ltCharI#) a1 a2
leCharI# :: Char# -> Char# -> Int#
leCharI# a1 a2 = (GHC.Prim.leCharI#) a1 a2
ord# :: Char# -> Int#
ord# a1 = (GHC.Prim.ord#) a1
(+#) :: Int# -> Int# -> Int#
(+#) a1 a2 = (GHC.Prim.+#) a1 a2
(-#) :: Int# -> Int# -> Int#
(-#) a1 a2 = (GHC.Prim.-#) a1 a2
(*#) :: Int# -> Int# -> Int#
(*#) a1 a2 = (GHC.Prim.*#) a1 a2
mulIntMayOflo# :: Int# -> Int# -> Int#
mulIntMayOflo# a1 a2 = (GHC.Prim.mulIntMayOflo#) a1 a2
quotInt# :: Int# -> Int# -> Int#
quotInt# a1 a2 = (GHC.Prim.quotInt#) a1 a2
remInt# :: Int# -> Int# -> Int#
remInt# a1 a2 = (GHC.Prim.remInt#) a1 a2
quotRemInt# :: Int# -> Int# -> (# Int#,Int# #)
quotRemInt# a1 a2 = (GHC.Prim.quotRemInt#) a1 a2
andI# :: Int# -> Int# -> Int#
andI# a1 a2 = (GHC.Prim.andI#) a1 a2
orI# :: Int# -> Int# -> Int#
orI# a1 a2 = (GHC.Prim.orI#) a1 a2
xorI# :: Int# -> Int# -> Int#
xorI# a1 a2 = (GHC.Prim.xorI#) a1 a2
notI# :: Int# -> Int#
notI# a1 = (GHC.Prim.notI#) a1
negateInt# :: Int# -> Int#
negateInt# a1 = (GHC.Prim.negateInt#) a1
addIntC# :: Int# -> Int# -> (# Int#,Int# #)
addIntC# a1 a2 = (GHC.Prim.addIntC#) a1 a2
subIntC# :: Int# -> Int# -> (# Int#,Int# #)
subIntC# a1 a2 = (GHC.Prim.subIntC#) a1 a2
(>$#) :: Int# -> Int# -> Int#
(>$#) a1 a2 = (GHC.Prim.>$#) a1 a2
(>=$#) :: Int# -> Int# -> Int#
(>=$#) a1 a2 = (GHC.Prim.>=$#) a1 a2
(==$#) :: Int# -> Int# -> Int#
(==$#) a1 a2 = (GHC.Prim.==$#) a1 a2
(/=$#) :: Int# -> Int# -> Int#
(/=$#) a1 a2 = (GHC.Prim./=$#) a1 a2
(<$#) :: Int# -> Int# -> Int#
(<$#) a1 a2 = (GHC.Prim.<$#) a1 a2
(<=$#) :: Int# -> Int# -> Int#
(<=$#) a1 a2 = (GHC.Prim.<=$#) a1 a2
chr# :: Int# -> Char#
chr# a1 = (GHC.Prim.chr#) a1
int2Word# :: Int# -> Word#
int2Word# a1 = (GHC.Prim.int2Word#) a1
int2Float# :: Int# -> Float#
int2Float# a1 = (GHC.Prim.int2Float#) a1
int2Double# :: Int# -> Double#
int2Double# a1 = (GHC.Prim.int2Double#) a1
word2Float# :: Word# -> Float#
word2Float# a1 = (GHC.Prim.word2Float#) a1
word2Double# :: Word# -> Double#
word2Double# a1 = (GHC.Prim.word2Double#) a1
uncheckedIShiftL# :: Int# -> Int# -> Int#
uncheckedIShiftL# a1 a2 = (GHC.Prim.uncheckedIShiftL#) a1 a2
uncheckedIShiftRA# :: Int# -> Int# -> Int#
uncheckedIShiftRA# a1 a2 = (GHC.Prim.uncheckedIShiftRA#) a1 a2
uncheckedIShiftRL# :: Int# -> Int# -> Int#
uncheckedIShiftRL# a1 a2 = (GHC.Prim.uncheckedIShiftRL#) a1 a2
plusWord# :: Word# -> Word# -> Word#
plusWord# a1 a2 = (GHC.Prim.plusWord#) a1 a2
plusWord2# :: Word# -> Word# -> (# Word#,Word# #)
plusWord2# a1 a2 = (GHC.Prim.plusWord2#) a1 a2
minusWord# :: Word# -> Word# -> Word#
minusWord# a1 a2 = (GHC.Prim.minusWord#) a1 a2
timesWord# :: Word# -> Word# -> Word#
timesWord# a1 a2 = (GHC.Prim.timesWord#) a1 a2
timesWord2# :: Word# -> Word# -> (# Word#,Word# #)
timesWord2# a1 a2 = (GHC.Prim.timesWord2#) a1 a2
quotWord# :: Word# -> Word# -> Word#
quotWord# a1 a2 = (GHC.Prim.quotWord#) a1 a2
remWord# :: Word# -> Word# -> Word#
remWord# a1 a2 = (GHC.Prim.remWord#) a1 a2
quotRemWord# :: Word# -> Word# -> (# Word#,Word# #)
quotRemWord# a1 a2 = (GHC.Prim.quotRemWord#) a1 a2
quotRemWord2# :: Word# -> Word# -> Word# -> (# Word#,Word# #)
quotRemWord2# a1 a2 a3 = (GHC.Prim.quotRemWord2#) a1 a2 a3
and# :: Word# -> Word# -> Word#
and# a1 a2 = (GHC.Prim.and#) a1 a2
or# :: Word# -> Word# -> Word#
or# a1 a2 = (GHC.Prim.or#) a1 a2
xor# :: Word# -> Word# -> Word#
xor# a1 a2 = (GHC.Prim.xor#) a1 a2
not# :: Word# -> Word#
not# a1 = (GHC.Prim.not#) a1
uncheckedShiftL# :: Word# -> Int# -> Word#
uncheckedShiftL# a1 a2 = (GHC.Prim.uncheckedShiftL#) a1 a2
uncheckedShiftRL# :: Word# -> Int# -> Word#
uncheckedShiftRL# a1 a2 = (GHC.Prim.uncheckedShiftRL#) a1 a2
word2Int# :: Word# -> Int#
word2Int# a1 = (GHC.Prim.word2Int#) a1
gtWordI# :: Word# -> Word# -> Int#
gtWordI# a1 a2 = (GHC.Prim.gtWordI#) a1 a2
geWordI# :: Word# -> Word# -> Int#
geWordI# a1 a2 = (GHC.Prim.geWordI#) a1 a2
eqWordI# :: Word# -> Word# -> Int#
eqWordI# a1 a2 = (GHC.Prim.eqWordI#) a1 a2
neWordI# :: Word# -> Word# -> Int#
neWordI# a1 a2 = (GHC.Prim.neWordI#) a1 a2
ltWordI# :: Word# -> Word# -> Int#
ltWordI# a1 a2 = (GHC.Prim.ltWordI#) a1 a2
leWordI# :: Word# -> Word# -> Int#
leWordI# a1 a2 = (GHC.Prim.leWordI#) a1 a2
popCnt8# :: Word# -> Word#
popCnt8# a1 = (GHC.Prim.popCnt8#) a1
popCnt16# :: Word# -> Word#
popCnt16# a1 = (GHC.Prim.popCnt16#) a1
popCnt32# :: Word# -> Word#
popCnt32# a1 = (GHC.Prim.popCnt32#) a1
popCnt64# :: Word# -> Word#
popCnt64# a1 = (GHC.Prim.popCnt64#) a1
popCnt# :: Word# -> Word#
popCnt# a1 = (GHC.Prim.popCnt#) a1
byteSwap16# :: Word# -> Word#
byteSwap16# a1 = (GHC.Prim.byteSwap16#) a1
byteSwap32# :: Word# -> Word#
byteSwap32# a1 = (GHC.Prim.byteSwap32#) a1
byteSwap64# :: Word# -> Word#
byteSwap64# a1 = (GHC.Prim.byteSwap64#) a1
byteSwap# :: Word# -> Word#
byteSwap# a1 = (GHC.Prim.byteSwap#) a1
narrow8Int# :: Int# -> Int#
narrow8Int# a1 = (GHC.Prim.narrow8Int#) a1
narrow16Int# :: Int# -> Int#
narrow16Int# a1 = (GHC.Prim.narrow16Int#) a1
narrow32Int# :: Int# -> Int#
narrow32Int# a1 = (GHC.Prim.narrow32Int#) a1
narrow8Word# :: Word# -> Word#
narrow8Word# a1 = (GHC.Prim.narrow8Word#) a1
narrow16Word# :: Word# -> Word#
narrow16Word# a1 = (GHC.Prim.narrow16Word#) a1
narrow32Word# :: Word# -> Word#
narrow32Word# a1 = (GHC.Prim.narrow32Word#) a1
(>$##) :: Double# -> Double# -> Int#
(>$##) a1 a2 = (GHC.Prim.>$##) a1 a2
(>=$##) :: Double# -> Double# -> Int#
(>=$##) a1 a2 = (GHC.Prim.>=$##) a1 a2
(==$##) :: Double# -> Double# -> Int#
(==$##) a1 a2 = (GHC.Prim.==$##) a1 a2
(/=$##) :: Double# -> Double# -> Int#
(/=$##) a1 a2 = (GHC.Prim./=$##) a1 a2
(<$##) :: Double# -> Double# -> Int#
(<$##) a1 a2 = (GHC.Prim.<$##) a1 a2
(<=$##) :: Double# -> Double# -> Int#
(<=$##) a1 a2 = (GHC.Prim.<=$##) a1 a2
(+##) :: Double# -> Double# -> Double#
(+##) a1 a2 = (GHC.Prim.+##) a1 a2
(-##) :: Double# -> Double# -> Double#
(-##) a1 a2 = (GHC.Prim.-##) a1 a2
(*##) :: Double# -> Double# -> Double#
(*##) a1 a2 = (GHC.Prim.*##) a1 a2
(/##) :: Double# -> Double# -> Double#
(/##) a1 a2 = (GHC.Prim./##) a1 a2
negateDouble# :: Double# -> Double#
negateDouble# a1 = (GHC.Prim.negateDouble#) a1
double2Int# :: Double# -> Int#
double2Int# a1 = (GHC.Prim.double2Int#) a1
double2Float# :: Double# -> Float#
double2Float# a1 = (GHC.Prim.double2Float#) a1
expDouble# :: Double# -> Double#
expDouble# a1 = (GHC.Prim.expDouble#) a1
logDouble# :: Double# -> Double#
logDouble# a1 = (GHC.Prim.logDouble#) a1
sqrtDouble# :: Double# -> Double#
sqrtDouble# a1 = (GHC.Prim.sqrtDouble#) a1
sinDouble# :: Double# -> Double#
sinDouble# a1 = (GHC.Prim.sinDouble#) a1
cosDouble# :: Double# -> Double#
cosDouble# a1 = (GHC.Prim.cosDouble#) a1
tanDouble# :: Double# -> Double#
tanDouble# a1 = (GHC.Prim.tanDouble#) a1
asinDouble# :: Double# -> Double#
asinDouble# a1 = (GHC.Prim.asinDouble#) a1
acosDouble# :: Double# -> Double#
acosDouble# a1 = (GHC.Prim.acosDouble#) a1
atanDouble# :: Double# -> Double#
atanDouble# a1 = (GHC.Prim.atanDouble#) a1
sinhDouble# :: Double# -> Double#
sinhDouble# a1 = (GHC.Prim.sinhDouble#) a1
coshDouble# :: Double# -> Double#
coshDouble# a1 = (GHC.Prim.coshDouble#) a1
tanhDouble# :: Double# -> Double#
tanhDouble# a1 = (GHC.Prim.tanhDouble#) a1
(**##) :: Double# -> Double# -> Double#
(**##) a1 a2 = (GHC.Prim.**##) a1 a2
decodeDouble_2Int# :: Double# -> (# Int#,Word#,Word#,Int# #)
decodeDouble_2Int# a1 = (GHC.Prim.decodeDouble_2Int#) a1
gtFloatI# :: Float# -> Float# -> Int#
gtFloatI# a1 a2 = (GHC.Prim.gtFloatI#) a1 a2
geFloatI# :: Float# -> Float# -> Int#
geFloatI# a1 a2 = (GHC.Prim.geFloatI#) a1 a2
eqFloatI# :: Float# -> Float# -> Int#
eqFloatI# a1 a2 = (GHC.Prim.eqFloatI#) a1 a2
neFloatI# :: Float# -> Float# -> Int#
neFloatI# a1 a2 = (GHC.Prim.neFloatI#) a1 a2
ltFloatI# :: Float# -> Float# -> Int#
ltFloatI# a1 a2 = (GHC.Prim.ltFloatI#) a1 a2
leFloatI# :: Float# -> Float# -> Int#
leFloatI# a1 a2 = (GHC.Prim.leFloatI#) a1 a2
plusFloat# :: Float# -> Float# -> Float#
plusFloat# a1 a2 = (GHC.Prim.plusFloat#) a1 a2
minusFloat# :: Float# -> Float# -> Float#
minusFloat# a1 a2 = (GHC.Prim.minusFloat#) a1 a2
timesFloat# :: Float# -> Float# -> Float#
timesFloat# a1 a2 = (GHC.Prim.timesFloat#) a1 a2
divideFloat# :: Float# -> Float# -> Float#
divideFloat# a1 a2 = (GHC.Prim.divideFloat#) a1 a2
negateFloat# :: Float# -> Float#
negateFloat# a1 = (GHC.Prim.negateFloat#) a1
float2Int# :: Float# -> Int#
float2Int# a1 = (GHC.Prim.float2Int#) a1
expFloat# :: Float# -> Float#
expFloat# a1 = (GHC.Prim.expFloat#) a1
logFloat# :: Float# -> Float#
logFloat# a1 = (GHC.Prim.logFloat#) a1
sqrtFloat# :: Float# -> Float#
sqrtFloat# a1 = (GHC.Prim.sqrtFloat#) a1
sinFloat# :: Float# -> Float#
sinFloat# a1 = (GHC.Prim.sinFloat#) a1
cosFloat# :: Float# -> Float#
cosFloat# a1 = (GHC.Prim.cosFloat#) a1
tanFloat# :: Float# -> Float#
tanFloat# a1 = (GHC.Prim.tanFloat#) a1
asinFloat# :: Float# -> Float#
asinFloat# a1 = (GHC.Prim.asinFloat#) a1
acosFloat# :: Float# -> Float#
acosFloat# a1 = (GHC.Prim.acosFloat#) a1
atanFloat# :: Float# -> Float#
atanFloat# a1 = (GHC.Prim.atanFloat#) a1
sinhFloat# :: Float# -> Float#
sinhFloat# a1 = (GHC.Prim.sinhFloat#) a1
coshFloat# :: Float# -> Float#
coshFloat# a1 = (GHC.Prim.coshFloat#) a1
tanhFloat# :: Float# -> Float#
tanhFloat# a1 = (GHC.Prim.tanhFloat#) a1
powerFloat# :: Float# -> Float# -> Float#
powerFloat# a1 a2 = (GHC.Prim.powerFloat#) a1 a2
float2Double# :: Float# -> Double#
float2Double# a1 = (GHC.Prim.float2Double#) a1
decodeFloat_Int# :: Float# -> (# Int#,Int# #)
decodeFloat_Int# a1 = (GHC.Prim.decodeFloat_Int#) a1
newArray# :: Int# -> a -> State# s -> (# State# s,MutableArray# s a #)
newArray# a1 a2 a3 = (GHC.Prim.newArray#) a1 a2 a3
sameMutableArray# :: MutableArray# s a -> MutableArray# s a -> Int#
sameMutableArray# a1 a2 = (GHC.Prim.sameMutableArray#) a1 a2
readArray# :: MutableArray# s a -> Int# -> State# s -> (# State# s,a #)
readArray# a1 a2 a3 = (GHC.Prim.readArray#) a1 a2 a3
writeArray# :: MutableArray# s a -> Int# -> a -> State# s -> State# s
writeArray# a1 a2 a3 a4 = (GHC.Prim.writeArray#) a1 a2 a3 a4
sizeofArray# :: Array# a -> Int#
sizeofArray# a1 = (GHC.Prim.sizeofArray#) a1
sizeofMutableArray# :: MutableArray# s a -> Int#
sizeofMutableArray# a1 = (GHC.Prim.sizeofMutableArray#) a1
indexArray# :: Array# a -> Int# -> (# a #)
indexArray# a1 a2 = (GHC.Prim.indexArray#) a1 a2
unsafeFreezeArray# :: MutableArray# s a -> State# s -> (# State# s,Array# a #)
unsafeFreezeArray# a1 a2 = (GHC.Prim.unsafeFreezeArray#) a1 a2
unsafeThawArray# :: Array# a -> State# s -> (# State# s,MutableArray# s a #)
unsafeThawArray# a1 a2 = (GHC.Prim.unsafeThawArray#) a1 a2
copyArray# :: Array# a -> Int# -> MutableArray# s a -> Int# -> Int# -> State# s -> State# s
copyArray# a1 a2 a3 a4 a5 a6 = (GHC.Prim.copyArray#) a1 a2 a3 a4 a5 a6
copyMutableArray# :: MutableArray# s a -> Int# -> MutableArray# s a -> Int# -> Int# -> State# s -> State# s
copyMutableArray# a1 a2 a3 a4 a5 a6 = (GHC.Prim.copyMutableArray#) a1 a2 a3 a4 a5 a6
cloneArray# :: Array# a -> Int# -> Int# -> Array# a
cloneArray# a1 a2 a3 = (GHC.Prim.cloneArray#) a1 a2 a3
cloneMutableArray# :: MutableArray# s a -> Int# -> Int# -> State# s -> (# State# s,MutableArray# s a #)
cloneMutableArray# a1 a2 a3 a4 = (GHC.Prim.cloneMutableArray#) a1 a2 a3 a4
freezeArray# :: MutableArray# s a -> Int# -> Int# -> State# s -> (# State# s,Array# a #)
freezeArray# a1 a2 a3 a4 = (GHC.Prim.freezeArray#) a1 a2 a3 a4
thawArray# :: Array# a -> Int# -> Int# -> State# s -> (# State# s,MutableArray# s a #)
thawArray# a1 a2 a3 a4 = (GHC.Prim.thawArray#) a1 a2 a3 a4
newByteArray# :: Int# -> State# s -> (# State# s,MutableByteArray# s #)
newByteArray# a1 a2 = (GHC.Prim.newByteArray#) a1 a2
newPinnedByteArray# :: Int# -> State# s -> (# State# s,MutableByteArray# s #)
newPinnedByteArray# a1 a2 = (GHC.Prim.newPinnedByteArray#) a1 a2
newAlignedPinnedByteArray# :: Int# -> Int# -> State# s -> (# State# s,MutableByteArray# s #)
newAlignedPinnedByteArray# a1 a2 a3 = (GHC.Prim.newAlignedPinnedByteArray#) a1 a2 a3
byteArrayContents# :: ByteArray# -> Addr#
byteArrayContents# a1 = (GHC.Prim.byteArrayContents#) a1
sameMutableByteArray# :: MutableByteArray# s -> MutableByteArray# s -> Int#
sameMutableByteArray# a1 a2 = (GHC.Prim.sameMutableByteArray#) a1 a2
unsafeFreezeByteArray# :: MutableByteArray# s -> State# s -> (# State# s,ByteArray# #)
unsafeFreezeByteArray# a1 a2 = (GHC.Prim.unsafeFreezeByteArray#) a1 a2
sizeofByteArray# :: ByteArray# -> Int#
sizeofByteArray# a1 = (GHC.Prim.sizeofByteArray#) a1
sizeofMutableByteArray# :: MutableByteArray# s -> Int#
sizeofMutableByteArray# a1 = (GHC.Prim.sizeofMutableByteArray#) a1
indexCharArray# :: ByteArray# -> Int# -> Char#
indexCharArray# a1 a2 = (GHC.Prim.indexCharArray#) a1 a2
indexWideCharArray# :: ByteArray# -> Int# -> Char#
indexWideCharArray# a1 a2 = (GHC.Prim.indexWideCharArray#) a1 a2
indexIntArray# :: ByteArray# -> Int# -> Int#
indexIntArray# a1 a2 = (GHC.Prim.indexIntArray#) a1 a2
indexWordArray# :: ByteArray# -> Int# -> Word#
indexWordArray# a1 a2 = (GHC.Prim.indexWordArray#) a1 a2
indexAddrArray# :: ByteArray# -> Int# -> Addr#
indexAddrArray# a1 a2 = (GHC.Prim.indexAddrArray#) a1 a2
indexFloatArray# :: ByteArray# -> Int# -> Float#
indexFloatArray# a1 a2 = (GHC.Prim.indexFloatArray#) a1 a2
indexDoubleArray# :: ByteArray# -> Int# -> Double#
indexDoubleArray# a1 a2 = (GHC.Prim.indexDoubleArray#) a1 a2
indexStablePtrArray# :: ByteArray# -> Int# -> StablePtr# a
indexStablePtrArray# a1 a2 = (GHC.Prim.indexStablePtrArray#) a1 a2
indexInt8Array# :: ByteArray# -> Int# -> Int#
indexInt8Array# a1 a2 = (GHC.Prim.indexInt8Array#) a1 a2
indexInt16Array# :: ByteArray# -> Int# -> Int#
indexInt16Array# a1 a2 = (GHC.Prim.indexInt16Array#) a1 a2
indexInt32Array# :: ByteArray# -> Int# -> Int#
indexInt32Array# a1 a2 = (GHC.Prim.indexInt32Array#) a1 a2
indexInt64Array# :: ByteArray# -> Int# -> Int#
indexInt64Array# a1 a2 = (GHC.Prim.indexInt64Array#) a1 a2
indexWord8Array# :: ByteArray# -> Int# -> Word#
indexWord8Array# a1 a2 = (GHC.Prim.indexWord8Array#) a1 a2
indexWord16Array# :: ByteArray# -> Int# -> Word#
indexWord16Array# a1 a2 = (GHC.Prim.indexWord16Array#) a1 a2
indexWord32Array# :: ByteArray# -> Int# -> Word#
indexWord32Array# a1 a2 = (GHC.Prim.indexWord32Array#) a1 a2
indexWord64Array# :: ByteArray# -> Int# -> Word#
indexWord64Array# a1 a2 = (GHC.Prim.indexWord64Array#) a1 a2
readCharArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Char# #)
readCharArray# a1 a2 a3 = (GHC.Prim.readCharArray#) a1 a2 a3
readWideCharArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Char# #)
readWideCharArray# a1 a2 a3 = (GHC.Prim.readWideCharArray#) a1 a2 a3
readIntArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int# #)
readIntArray# a1 a2 a3 = (GHC.Prim.readIntArray#) a1 a2 a3
readWordArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word# #)
readWordArray# a1 a2 a3 = (GHC.Prim.readWordArray#) a1 a2 a3
readAddrArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Addr# #)
readAddrArray# a1 a2 a3 = (GHC.Prim.readAddrArray#) a1 a2 a3
readFloatArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Float# #)
readFloatArray# a1 a2 a3 = (GHC.Prim.readFloatArray#) a1 a2 a3
readDoubleArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Double# #)
readDoubleArray# a1 a2 a3 = (GHC.Prim.readDoubleArray#) a1 a2 a3
readStablePtrArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,StablePtr# a #)
readStablePtrArray# a1 a2 a3 = (GHC.Prim.readStablePtrArray#) a1 a2 a3
readInt8Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int# #)
readInt8Array# a1 a2 a3 = (GHC.Prim.readInt8Array#) a1 a2 a3
readInt16Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int# #)
readInt16Array# a1 a2 a3 = (GHC.Prim.readInt16Array#) a1 a2 a3
readInt32Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int# #)
readInt32Array# a1 a2 a3 = (GHC.Prim.readInt32Array#) a1 a2 a3
readInt64Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int# #)
readInt64Array# a1 a2 a3 = (GHC.Prim.readInt64Array#) a1 a2 a3
readWord8Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word# #)
readWord8Array# a1 a2 a3 = (GHC.Prim.readWord8Array#) a1 a2 a3
readWord16Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word# #)
readWord16Array# a1 a2 a3 = (GHC.Prim.readWord16Array#) a1 a2 a3
readWord32Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word# #)
readWord32Array# a1 a2 a3 = (GHC.Prim.readWord32Array#) a1 a2 a3
readWord64Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word# #)
readWord64Array# a1 a2 a3 = (GHC.Prim.readWord64Array#) a1 a2 a3
writeCharArray# :: MutableByteArray# s -> Int# -> Char# -> State# s -> State# s
writeCharArray# a1 a2 a3 a4 = (GHC.Prim.writeCharArray#) a1 a2 a3 a4
writeWideCharArray# :: MutableByteArray# s -> Int# -> Char# -> State# s -> State# s
writeWideCharArray# a1 a2 a3 a4 = (GHC.Prim.writeWideCharArray#) a1 a2 a3 a4
writeIntArray# :: MutableByteArray# s -> Int# -> Int# -> State# s -> State# s
writeIntArray# a1 a2 a3 a4 = (GHC.Prim.writeIntArray#) a1 a2 a3 a4
writeWordArray# :: MutableByteArray# s -> Int# -> Word# -> State# s -> State# s
writeWordArray# a1 a2 a3 a4 = (GHC.Prim.writeWordArray#) a1 a2 a3 a4
writeAddrArray# :: MutableByteArray# s -> Int# -> Addr# -> State# s -> State# s
writeAddrArray# a1 a2 a3 a4 = (GHC.Prim.writeAddrArray#) a1 a2 a3 a4
writeFloatArray# :: MutableByteArray# s -> Int# -> Float# -> State# s -> State# s
writeFloatArray# a1 a2 a3 a4 = (GHC.Prim.writeFloatArray#) a1 a2 a3 a4
writeDoubleArray# :: MutableByteArray# s -> Int# -> Double# -> State# s -> State# s
writeDoubleArray# a1 a2 a3 a4 = (GHC.Prim.writeDoubleArray#) a1 a2 a3 a4
writeStablePtrArray# :: MutableByteArray# s -> Int# -> StablePtr# a -> State# s -> State# s
writeStablePtrArray# a1 a2 a3 a4 = (GHC.Prim.writeStablePtrArray#) a1 a2 a3 a4
writeInt8Array# :: MutableByteArray# s -> Int# -> Int# -> State# s -> State# s
writeInt8Array# a1 a2 a3 a4 = (GHC.Prim.writeInt8Array#) a1 a2 a3 a4
writeInt16Array# :: MutableByteArray# s -> Int# -> Int# -> State# s -> State# s
writeInt16Array# a1 a2 a3 a4 = (GHC.Prim.writeInt16Array#) a1 a2 a3 a4
writeInt32Array# :: MutableByteArray# s -> Int# -> Int# -> State# s -> State# s
writeInt32Array# a1 a2 a3 a4 = (GHC.Prim.writeInt32Array#) a1 a2 a3 a4
writeInt64Array# :: MutableByteArray# s -> Int# -> Int# -> State# s -> State# s
writeInt64Array# a1 a2 a3 a4 = (GHC.Prim.writeInt64Array#) a1 a2 a3 a4
writeWord8Array# :: MutableByteArray# s -> Int# -> Word# -> State# s -> State# s
writeWord8Array# a1 a2 a3 a4 = (GHC.Prim.writeWord8Array#) a1 a2 a3 a4
writeWord16Array# :: MutableByteArray# s -> Int# -> Word# -> State# s -> State# s
writeWord16Array# a1 a2 a3 a4 = (GHC.Prim.writeWord16Array#) a1 a2 a3 a4
writeWord32Array# :: MutableByteArray# s -> Int# -> Word# -> State# s -> State# s
writeWord32Array# a1 a2 a3 a4 = (GHC.Prim.writeWord32Array#) a1 a2 a3 a4
writeWord64Array# :: MutableByteArray# s -> Int# -> Word# -> State# s -> State# s
writeWord64Array# a1 a2 a3 a4 = (GHC.Prim.writeWord64Array#) a1 a2 a3 a4
copyByteArray# :: ByteArray# -> Int# -> MutableByteArray# s -> Int# -> Int# -> State# s -> State# s
copyByteArray# a1 a2 a3 a4 a5 a6 = (GHC.Prim.copyByteArray#) a1 a2 a3 a4 a5 a6
copyMutableByteArray# :: MutableByteArray# s -> Int# -> MutableByteArray# s -> Int# -> Int# -> State# s -> State# s
copyMutableByteArray# a1 a2 a3 a4 a5 a6 = (GHC.Prim.copyMutableByteArray#) a1 a2 a3 a4 a5 a6
setByteArray# :: MutableByteArray# s -> Int# -> Int# -> Int# -> State# s -> State# s
setByteArray# a1 a2 a3 a4 a5 = (GHC.Prim.setByteArray#) a1 a2 a3 a4 a5
newArrayArray# :: Int# -> State# s -> (# State# s,MutableArrayArray# s #)
newArrayArray# a1 a2 = (GHC.Prim.newArrayArray#) a1 a2
sameMutableArrayArray# :: MutableArrayArray# s -> MutableArrayArray# s -> Int#
sameMutableArrayArray# a1 a2 = (GHC.Prim.sameMutableArrayArray#) a1 a2
unsafeFreezeArrayArray# :: MutableArrayArray# s -> State# s -> (# State# s,ArrayArray# #)
unsafeFreezeArrayArray# a1 a2 = (GHC.Prim.unsafeFreezeArrayArray#) a1 a2
sizeofArrayArray# :: ArrayArray# -> Int#
sizeofArrayArray# a1 = (GHC.Prim.sizeofArrayArray#) a1
sizeofMutableArrayArray# :: MutableArrayArray# s -> Int#
sizeofMutableArrayArray# a1 = (GHC.Prim.sizeofMutableArrayArray#) a1
indexByteArrayArray# :: ArrayArray# -> Int# -> ByteArray#
indexByteArrayArray# a1 a2 = (GHC.Prim.indexByteArrayArray#) a1 a2
indexArrayArrayArray# :: ArrayArray# -> Int# -> ArrayArray#
indexArrayArrayArray# a1 a2 = (GHC.Prim.indexArrayArrayArray#) a1 a2
readByteArrayArray# :: MutableArrayArray# s -> Int# -> State# s -> (# State# s,ByteArray# #)
readByteArrayArray# a1 a2 a3 = (GHC.Prim.readByteArrayArray#) a1 a2 a3
readMutableByteArrayArray# :: MutableArrayArray# s -> Int# -> State# s -> (# State# s,MutableByteArray# s #)
readMutableByteArrayArray# a1 a2 a3 = (GHC.Prim.readMutableByteArrayArray#) a1 a2 a3
readArrayArrayArray# :: MutableArrayArray# s -> Int# -> State# s -> (# State# s,ArrayArray# #)
readArrayArrayArray# a1 a2 a3 = (GHC.Prim.readArrayArrayArray#) a1 a2 a3
readMutableArrayArrayArray# :: MutableArrayArray# s -> Int# -> State# s -> (# State# s,MutableArrayArray# s #)
readMutableArrayArrayArray# a1 a2 a3 = (GHC.Prim.readMutableArrayArrayArray#) a1 a2 a3
writeByteArrayArray# :: MutableArrayArray# s -> Int# -> ByteArray# -> State# s -> State# s
writeByteArrayArray# a1 a2 a3 a4 = (GHC.Prim.writeByteArrayArray#) a1 a2 a3 a4
writeMutableByteArrayArray# :: MutableArrayArray# s -> Int# -> MutableByteArray# s -> State# s -> State# s
writeMutableByteArrayArray# a1 a2 a3 a4 = (GHC.Prim.writeMutableByteArrayArray#) a1 a2 a3 a4
writeArrayArrayArray# :: MutableArrayArray# s -> Int# -> ArrayArray# -> State# s -> State# s
writeArrayArrayArray# a1 a2 a3 a4 = (GHC.Prim.writeArrayArrayArray#) a1 a2 a3 a4
writeMutableArrayArrayArray# :: MutableArrayArray# s -> Int# -> MutableArrayArray# s -> State# s -> State# s
writeMutableArrayArrayArray# a1 a2 a3 a4 = (GHC.Prim.writeMutableArrayArrayArray#) a1 a2 a3 a4
copyArrayArray# :: ArrayArray# -> Int# -> MutableArrayArray# s -> Int# -> Int# -> State# s -> State# s
copyArrayArray# a1 a2 a3 a4 a5 a6 = (GHC.Prim.copyArrayArray#) a1 a2 a3 a4 a5 a6
copyMutableArrayArray# :: MutableArrayArray# s -> Int# -> MutableArrayArray# s -> Int# -> Int# -> State# s -> State# s
copyMutableArrayArray# a1 a2 a3 a4 a5 a6 = (GHC.Prim.copyMutableArrayArray#) a1 a2 a3 a4 a5 a6
plusAddr# :: Addr# -> Int# -> Addr#
plusAddr# a1 a2 = (GHC.Prim.plusAddr#) a1 a2
minusAddr# :: Addr# -> Addr# -> Int#
minusAddr# a1 a2 = (GHC.Prim.minusAddr#) a1 a2
remAddr# :: Addr# -> Int# -> Int#
remAddr# a1 a2 = (GHC.Prim.remAddr#) a1 a2
addr2Int# :: Addr# -> Int#
addr2Int# a1 = (GHC.Prim.addr2Int#) a1
int2Addr# :: Int# -> Addr#
int2Addr# a1 = (GHC.Prim.int2Addr#) a1
gtAddrI# :: Addr# -> Addr# -> Int#
gtAddrI# a1 a2 = (GHC.Prim.gtAddrI#) a1 a2
geAddrI# :: Addr# -> Addr# -> Int#
geAddrI# a1 a2 = (GHC.Prim.geAddrI#) a1 a2
eqAddrI# :: Addr# -> Addr# -> Int#
eqAddrI# a1 a2 = (GHC.Prim.eqAddrI#) a1 a2
neAddrI# :: Addr# -> Addr# -> Int#
neAddrI# a1 a2 = (GHC.Prim.neAddrI#) a1 a2
ltAddrI# :: Addr# -> Addr# -> Int#
ltAddrI# a1 a2 = (GHC.Prim.ltAddrI#) a1 a2
leAddrI# :: Addr# -> Addr# -> Int#
leAddrI# a1 a2 = (GHC.Prim.leAddrI#) a1 a2
indexCharOffAddr# :: Addr# -> Int# -> Char#
indexCharOffAddr# a1 a2 = (GHC.Prim.indexCharOffAddr#) a1 a2
indexWideCharOffAddr# :: Addr# -> Int# -> Char#
indexWideCharOffAddr# a1 a2 = (GHC.Prim.indexWideCharOffAddr#) a1 a2
indexIntOffAddr# :: Addr# -> Int# -> Int#
indexIntOffAddr# a1 a2 = (GHC.Prim.indexIntOffAddr#) a1 a2
indexWordOffAddr# :: Addr# -> Int# -> Word#
indexWordOffAddr# a1 a2 = (GHC.Prim.indexWordOffAddr#) a1 a2
indexAddrOffAddr# :: Addr# -> Int# -> Addr#
indexAddrOffAddr# a1 a2 = (GHC.Prim.indexAddrOffAddr#) a1 a2
indexFloatOffAddr# :: Addr# -> Int# -> Float#
indexFloatOffAddr# a1 a2 = (GHC.Prim.indexFloatOffAddr#) a1 a2
indexDoubleOffAddr# :: Addr# -> Int# -> Double#
indexDoubleOffAddr# a1 a2 = (GHC.Prim.indexDoubleOffAddr#) a1 a2
indexStablePtrOffAddr# :: Addr# -> Int# -> StablePtr# a
indexStablePtrOffAddr# a1 a2 = (GHC.Prim.indexStablePtrOffAddr#) a1 a2
indexInt8OffAddr# :: Addr# -> Int# -> Int#
indexInt8OffAddr# a1 a2 = (GHC.Prim.indexInt8OffAddr#) a1 a2
indexInt16OffAddr# :: Addr# -> Int# -> Int#
indexInt16OffAddr# a1 a2 = (GHC.Prim.indexInt16OffAddr#) a1 a2
indexInt32OffAddr# :: Addr# -> Int# -> Int#
indexInt32OffAddr# a1 a2 = (GHC.Prim.indexInt32OffAddr#) a1 a2
indexInt64OffAddr# :: Addr# -> Int# -> Int#
indexInt64OffAddr# a1 a2 = (GHC.Prim.indexInt64OffAddr#) a1 a2
indexWord8OffAddr# :: Addr# -> Int# -> Word#
indexWord8OffAddr# a1 a2 = (GHC.Prim.indexWord8OffAddr#) a1 a2
indexWord16OffAddr# :: Addr# -> Int# -> Word#
indexWord16OffAddr# a1 a2 = (GHC.Prim.indexWord16OffAddr#) a1 a2
indexWord32OffAddr# :: Addr# -> Int# -> Word#
indexWord32OffAddr# a1 a2 = (GHC.Prim.indexWord32OffAddr#) a1 a2
indexWord64OffAddr# :: Addr# -> Int# -> Word#
indexWord64OffAddr# a1 a2 = (GHC.Prim.indexWord64OffAddr#) a1 a2
readCharOffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Char# #)
readCharOffAddr# a1 a2 a3 = (GHC.Prim.readCharOffAddr#) a1 a2 a3
readWideCharOffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Char# #)
readWideCharOffAddr# a1 a2 a3 = (GHC.Prim.readWideCharOffAddr#) a1 a2 a3
readIntOffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int# #)
readIntOffAddr# a1 a2 a3 = (GHC.Prim.readIntOffAddr#) a1 a2 a3
readWordOffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word# #)
readWordOffAddr# a1 a2 a3 = (GHC.Prim.readWordOffAddr#) a1 a2 a3
readAddrOffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Addr# #)
readAddrOffAddr# a1 a2 a3 = (GHC.Prim.readAddrOffAddr#) a1 a2 a3
readFloatOffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Float# #)
readFloatOffAddr# a1 a2 a3 = (GHC.Prim.readFloatOffAddr#) a1 a2 a3
readDoubleOffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Double# #)
readDoubleOffAddr# a1 a2 a3 = (GHC.Prim.readDoubleOffAddr#) a1 a2 a3
readStablePtrOffAddr# :: Addr# -> Int# -> State# s -> (# State# s,StablePtr# a #)
readStablePtrOffAddr# a1 a2 a3 = (GHC.Prim.readStablePtrOffAddr#) a1 a2 a3
readInt8OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int# #)
readInt8OffAddr# a1 a2 a3 = (GHC.Prim.readInt8OffAddr#) a1 a2 a3
readInt16OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int# #)
readInt16OffAddr# a1 a2 a3 = (GHC.Prim.readInt16OffAddr#) a1 a2 a3
readInt32OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int# #)
readInt32OffAddr# a1 a2 a3 = (GHC.Prim.readInt32OffAddr#) a1 a2 a3
readInt64OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int# #)
readInt64OffAddr# a1 a2 a3 = (GHC.Prim.readInt64OffAddr#) a1 a2 a3
readWord8OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word# #)
readWord8OffAddr# a1 a2 a3 = (GHC.Prim.readWord8OffAddr#) a1 a2 a3
readWord16OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word# #)
readWord16OffAddr# a1 a2 a3 = (GHC.Prim.readWord16OffAddr#) a1 a2 a3
readWord32OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word# #)
readWord32OffAddr# a1 a2 a3 = (GHC.Prim.readWord32OffAddr#) a1 a2 a3
readWord64OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word# #)
readWord64OffAddr# a1 a2 a3 = (GHC.Prim.readWord64OffAddr#) a1 a2 a3
writeCharOffAddr# :: Addr# -> Int# -> Char# -> State# s -> State# s
writeCharOffAddr# a1 a2 a3 a4 = (GHC.Prim.writeCharOffAddr#) a1 a2 a3 a4
writeWideCharOffAddr# :: Addr# -> Int# -> Char# -> State# s -> State# s
writeWideCharOffAddr# a1 a2 a3 a4 = (GHC.Prim.writeWideCharOffAddr#) a1 a2 a3 a4
writeIntOffAddr# :: Addr# -> Int# -> Int# -> State# s -> State# s
writeIntOffAddr# a1 a2 a3 a4 = (GHC.Prim.writeIntOffAddr#) a1 a2 a3 a4
writeWordOffAddr# :: Addr# -> Int# -> Word# -> State# s -> State# s
writeWordOffAddr# a1 a2 a3 a4 = (GHC.Prim.writeWordOffAddr#) a1 a2 a3 a4
writeAddrOffAddr# :: Addr# -> Int# -> Addr# -> State# s -> State# s
writeAddrOffAddr# a1 a2 a3 a4 = (GHC.Prim.writeAddrOffAddr#) a1 a2 a3 a4
writeFloatOffAddr# :: Addr# -> Int# -> Float# -> State# s -> State# s
writeFloatOffAddr# a1 a2 a3 a4 = (GHC.Prim.writeFloatOffAddr#) a1 a2 a3 a4
writeDoubleOffAddr# :: Addr# -> Int# -> Double# -> State# s -> State# s
writeDoubleOffAddr# a1 a2 a3 a4 = (GHC.Prim.writeDoubleOffAddr#) a1 a2 a3 a4
writeStablePtrOffAddr# :: Addr# -> Int# -> StablePtr# a -> State# s -> State# s
writeStablePtrOffAddr# a1 a2 a3 a4 = (GHC.Prim.writeStablePtrOffAddr#) a1 a2 a3 a4
writeInt8OffAddr# :: Addr# -> Int# -> Int# -> State# s -> State# s
writeInt8OffAddr# a1 a2 a3 a4 = (GHC.Prim.writeInt8OffAddr#) a1 a2 a3 a4
writeInt16OffAddr# :: Addr# -> Int# -> Int# -> State# s -> State# s
writeInt16OffAddr# a1 a2 a3 a4 = (GHC.Prim.writeInt16OffAddr#) a1 a2 a3 a4
writeInt32OffAddr# :: Addr# -> Int# -> Int# -> State# s -> State# s
writeInt32OffAddr# a1 a2 a3 a4 = (GHC.Prim.writeInt32OffAddr#) a1 a2 a3 a4
writeInt64OffAddr# :: Addr# -> Int# -> Int# -> State# s -> State# s
writeInt64OffAddr# a1 a2 a3 a4 = (GHC.Prim.writeInt64OffAddr#) a1 a2 a3 a4
writeWord8OffAddr# :: Addr# -> Int# -> Word# -> State# s -> State# s
writeWord8OffAddr# a1 a2 a3 a4 = (GHC.Prim.writeWord8OffAddr#) a1 a2 a3 a4
writeWord16OffAddr# :: Addr# -> Int# -> Word# -> State# s -> State# s
writeWord16OffAddr# a1 a2 a3 a4 = (GHC.Prim.writeWord16OffAddr#) a1 a2 a3 a4
writeWord32OffAddr# :: Addr# -> Int# -> Word# -> State# s -> State# s
writeWord32OffAddr# a1 a2 a3 a4 = (GHC.Prim.writeWord32OffAddr#) a1 a2 a3 a4
writeWord64OffAddr# :: Addr# -> Int# -> Word# -> State# s -> State# s
writeWord64OffAddr# a1 a2 a3 a4 = (GHC.Prim.writeWord64OffAddr#) a1 a2 a3 a4
newMutVar# :: a -> State# s -> (# State# s,MutVar# s a #)
newMutVar# a1 a2 = (GHC.Prim.newMutVar#) a1 a2
readMutVar# :: MutVar# s a -> State# s -> (# State# s,a #)
readMutVar# a1 a2 = (GHC.Prim.readMutVar#) a1 a2
writeMutVar# :: MutVar# s a -> a -> State# s -> State# s
writeMutVar# a1 a2 a3 = (GHC.Prim.writeMutVar#) a1 a2 a3
sameMutVar# :: MutVar# s a -> MutVar# s a -> Int#
sameMutVar# a1 a2 = (GHC.Prim.sameMutVar#) a1 a2
atomicModifyMutVar# :: MutVar# s a -> (a -> b) -> State# s -> (# State# s,c #)
atomicModifyMutVar# a1 a2 a3 = (GHC.Prim.atomicModifyMutVar#) a1 a2 a3
casMutVar# :: MutVar# s a -> a -> a -> State# s -> (# State# s,Int#,a #)
casMutVar# a1 a2 a3 a4 = (GHC.Prim.casMutVar#) a1 a2 a3 a4
catch# :: (State# (RealWorld) -> (# State# (RealWorld),a #)) -> (b -> State# (RealWorld) -> (# State# (RealWorld),a #)) -> State# (RealWorld) -> (# State# (RealWorld),a #)
catch# a1 a2 a3 = (GHC.Prim.catch#) a1 a2 a3
raise# :: a -> b
raise# a1 = (GHC.Prim.raise#) a1
raiseIO# :: a -> State# (RealWorld) -> (# State# (RealWorld),b #)
raiseIO# a1 a2 = (GHC.Prim.raiseIO#) a1 a2
maskAsyncExceptions# :: (State# (RealWorld) -> (# State# (RealWorld),a #)) -> State# (RealWorld) -> (# State# (RealWorld),a #)
maskAsyncExceptions# a1 a2 = (GHC.Prim.maskAsyncExceptions#) a1 a2
maskUninterruptible# :: (State# (RealWorld) -> (# State# (RealWorld),a #)) -> State# (RealWorld) -> (# State# (RealWorld),a #)
maskUninterruptible# a1 a2 = (GHC.Prim.maskUninterruptible#) a1 a2
unmaskAsyncExceptions# :: (State# (RealWorld) -> (# State# (RealWorld),a #)) -> State# (RealWorld) -> (# State# (RealWorld),a #)
unmaskAsyncExceptions# a1 a2 = (GHC.Prim.unmaskAsyncExceptions#) a1 a2
getMaskingState# :: State# (RealWorld) -> (# State# (RealWorld),Int# #)
getMaskingState# a1 = (GHC.Prim.getMaskingState#) a1
atomically# :: (State# (RealWorld) -> (# State# (RealWorld),a #)) -> State# (RealWorld) -> (# State# (RealWorld),a #)
atomically# a1 a2 = (GHC.Prim.atomically#) a1 a2
retry# :: State# (RealWorld) -> (# State# (RealWorld),a #)
retry# a1 = (GHC.Prim.retry#) a1
catchRetry# :: (State# (RealWorld) -> (# State# (RealWorld),a #)) -> (State# (RealWorld) -> (# State# (RealWorld),a #)) -> State# (RealWorld) -> (# State# (RealWorld),a #)
catchRetry# a1 a2 a3 = (GHC.Prim.catchRetry#) a1 a2 a3
catchSTM# :: (State# (RealWorld) -> (# State# (RealWorld),a #)) -> (b -> State# (RealWorld) -> (# State# (RealWorld),a #)) -> State# (RealWorld) -> (# State# (RealWorld),a #)
catchSTM# a1 a2 a3 = (GHC.Prim.catchSTM#) a1 a2 a3
check# :: (State# (RealWorld) -> (# State# (RealWorld),a #)) -> State# (RealWorld) -> (# State# (RealWorld),() #)
check# a1 a2 = (GHC.Prim.check#) a1 a2
newTVar# :: a -> State# s -> (# State# s,TVar# s a #)
newTVar# a1 a2 = (GHC.Prim.newTVar#) a1 a2
readTVar# :: TVar# s a -> State# s -> (# State# s,a #)
readTVar# a1 a2 = (GHC.Prim.readTVar#) a1 a2
readTVarIO# :: TVar# s a -> State# s -> (# State# s,a #)
readTVarIO# a1 a2 = (GHC.Prim.readTVarIO#) a1 a2
writeTVar# :: TVar# s a -> a -> State# s -> State# s
writeTVar# a1 a2 a3 = (GHC.Prim.writeTVar#) a1 a2 a3
sameTVar# :: TVar# s a -> TVar# s a -> Int#
sameTVar# a1 a2 = (GHC.Prim.sameTVar#) a1 a2
newMVar# :: State# s -> (# State# s,MVar# s a #)
newMVar# a1 = (GHC.Prim.newMVar#) a1
takeMVar# :: MVar# s a -> State# s -> (# State# s,a #)
takeMVar# a1 a2 = (GHC.Prim.takeMVar#) a1 a2
tryTakeMVar# :: MVar# s a -> State# s -> (# State# s,Int#,a #)
tryTakeMVar# a1 a2 = (GHC.Prim.tryTakeMVar#) a1 a2
putMVar# :: MVar# s a -> a -> State# s -> State# s
putMVar# a1 a2 a3 = (GHC.Prim.putMVar#) a1 a2 a3
tryPutMVar# :: MVar# s a -> a -> State# s -> (# State# s,Int# #)
tryPutMVar# a1 a2 a3 = (GHC.Prim.tryPutMVar#) a1 a2 a3
readMVar# :: MVar# s a -> State# s -> (# State# s,a #)
readMVar# a1 a2 = (GHC.Prim.readMVar#) a1 a2
tryReadMVar# :: MVar# s a -> State# s -> (# State# s,Int#,a #)
tryReadMVar# a1 a2 = (GHC.Prim.tryReadMVar#) a1 a2
sameMVar# :: MVar# s a -> MVar# s a -> Int#
sameMVar# a1 a2 = (GHC.Prim.sameMVar#) a1 a2
isEmptyMVar# :: MVar# s a -> State# s -> (# State# s,Int# #)
isEmptyMVar# a1 a2 = (GHC.Prim.isEmptyMVar#) a1 a2
delay# :: Int# -> State# s -> State# s
delay# a1 a2 = (GHC.Prim.delay#) a1 a2
waitRead# :: Int# -> State# s -> State# s
waitRead# a1 a2 = (GHC.Prim.waitRead#) a1 a2
waitWrite# :: Int# -> State# s -> State# s
waitWrite# a1 a2 = (GHC.Prim.waitWrite#) a1 a2
fork# :: a -> State# (RealWorld) -> (# State# (RealWorld),ThreadId# #)
fork# a1 a2 = (GHC.Prim.fork#) a1 a2
forkOn# :: Int# -> a -> State# (RealWorld) -> (# State# (RealWorld),ThreadId# #)
forkOn# a1 a2 a3 = (GHC.Prim.forkOn#) a1 a2 a3
killThread# :: ThreadId# -> a -> State# (RealWorld) -> State# (RealWorld)
killThread# a1 a2 a3 = (GHC.Prim.killThread#) a1 a2 a3
yield# :: State# (RealWorld) -> State# (RealWorld)
yield# a1 = (GHC.Prim.yield#) a1
myThreadId# :: State# (RealWorld) -> (# State# (RealWorld),ThreadId# #)
myThreadId# a1 = (GHC.Prim.myThreadId#) a1
labelThread# :: ThreadId# -> Addr# -> State# (RealWorld) -> State# (RealWorld)
labelThread# a1 a2 a3 = (GHC.Prim.labelThread#) a1 a2 a3
isCurrentThreadBound# :: State# (RealWorld) -> (# State# (RealWorld),Int# #)
isCurrentThreadBound# a1 = (GHC.Prim.isCurrentThreadBound#) a1
noDuplicate# :: State# (RealWorld) -> State# (RealWorld)
noDuplicate# a1 = (GHC.Prim.noDuplicate#) a1
threadStatus# :: ThreadId# -> State# (RealWorld) -> (# State# (RealWorld),Int#,Int#,Int# #)
threadStatus# a1 a2 = (GHC.Prim.threadStatus#) a1 a2
mkWeak# :: o -> b -> c -> State# (RealWorld) -> (# State# (RealWorld),Weak# b #)
mkWeak# a1 a2 a3 a4 = (GHC.Prim.mkWeak#) a1 a2 a3 a4
mkWeakNoFinalizer# :: o -> b -> State# (RealWorld) -> (# State# (RealWorld),Weak# b #)
mkWeakNoFinalizer# a1 a2 a3 = (GHC.Prim.mkWeakNoFinalizer#) a1 a2 a3
addCFinalizerToWeak# :: Addr# -> Addr# -> Int# -> Addr# -> Weak# b -> State# (RealWorld) -> (# State# (RealWorld),Int# #)
addCFinalizerToWeak# a1 a2 a3 a4 a5 a6 = (GHC.Prim.addCFinalizerToWeak#) a1 a2 a3 a4 a5 a6
deRefWeak# :: Weak# a -> State# (RealWorld) -> (# State# (RealWorld),Int#,a #)
deRefWeak# a1 a2 = (GHC.Prim.deRefWeak#) a1 a2
finalizeWeak# :: Weak# a -> State# (RealWorld) -> (# State# (RealWorld),Int#,State# (RealWorld) -> (# State# (RealWorld),() #) #)
finalizeWeak# a1 a2 = (GHC.Prim.finalizeWeak#) a1 a2
touch# :: o -> State# (RealWorld) -> State# (RealWorld)
touch# a1 a2 = (GHC.Prim.touch#) a1 a2
makeStablePtr# :: a -> State# (RealWorld) -> (# State# (RealWorld),StablePtr# a #)
makeStablePtr# a1 a2 = (GHC.Prim.makeStablePtr#) a1 a2
deRefStablePtr# :: StablePtr# a -> State# (RealWorld) -> (# State# (RealWorld),a #)
deRefStablePtr# a1 a2 = (GHC.Prim.deRefStablePtr#) a1 a2
eqStablePtr# :: StablePtr# a -> StablePtr# a -> Int#
eqStablePtr# a1 a2 = (GHC.Prim.eqStablePtr#) a1 a2
makeStableName# :: a -> State# (RealWorld) -> (# State# (RealWorld),StableName# a #)
makeStableName# a1 a2 = (GHC.Prim.makeStableName#) a1 a2
eqStableName# :: StableName# a -> StableName# b -> Int#
eqStableName# a1 a2 = (GHC.Prim.eqStableName#) a1 a2
stableNameToInt# :: StableName# a -> Int#
stableNameToInt# a1 = (GHC.Prim.stableNameToInt#) a1
reallyUnsafePtrEquality# :: a -> a -> Int#
reallyUnsafePtrEquality# a1 a2 = (GHC.Prim.reallyUnsafePtrEquality#) a1 a2
spark# :: a -> State# s -> (# State# s,a #)
spark# a1 a2 = (GHC.Prim.spark#) a1 a2
getSpark# :: State# s -> (# State# s,Int#,a #)
getSpark# a1 = (GHC.Prim.getSpark#) a1
numSparks# :: State# s -> (# State# s,Int# #)
numSparks# a1 = (GHC.Prim.numSparks#) a1
dataToTag# :: a -> Int#
dataToTag# a1 = (GHC.Prim.dataToTag#) a1
addrToAny# :: Addr# -> (# a #)
addrToAny# a1 = (GHC.Prim.addrToAny#) a1
mkApUpd0# :: BCO# -> (# a #)
mkApUpd0# a1 = (GHC.Prim.mkApUpd0#) a1
newBCO# :: ByteArray# -> ByteArray# -> Array# a -> Int# -> ByteArray# -> State# s -> (# State# s,BCO# #)
newBCO# a1 a2 a3 a4 a5 a6 = (GHC.Prim.newBCO#) a1 a2 a3 a4 a5 a6
unpackClosure# :: a -> (# Addr#,Array# b,ByteArray# #)
unpackClosure# a1 = (GHC.Prim.unpackClosure#) a1
getApStackVal# :: a -> Int# -> (# Int#,b #)
getApStackVal# a1 a2 = (GHC.Prim.getApStackVal#) a1 a2
getCCSOf# :: a -> State# s -> (# State# s,Addr# #)
getCCSOf# a1 a2 = (GHC.Prim.getCCSOf#) a1 a2
getCurrentCCS# :: a -> State# s -> (# State# s,Addr# #)
getCurrentCCS# a1 a2 = (GHC.Prim.getCurrentCCS#) a1 a2
traceEvent# :: Addr# -> State# s -> State# s
traceEvent# a1 a2 = (GHC.Prim.traceEvent#) a1 a2
traceMarker# :: Addr# -> State# s -> State# s
traceMarker# a1 a2 = (GHC.Prim.traceMarker#) a1 a2
#if defined (__GLASGOW_HASKELL_LLVM__)
floatToFloatX4# :: Float# -> FloatX4#
floatToFloatX4# a1 = (GHC.Prim.floatToFloatX4#) a1
packFloatX4# :: Float# -> Float# -> Float# -> Float# -> FloatX4#
packFloatX4# a1 a2 a3 a4 = (GHC.Prim.packFloatX4#) a1 a2 a3 a4
unpackFloatX4# :: FloatX4# -> (# Float#,Float#,Float#,Float# #)
unpackFloatX4# a1 = (GHC.Prim.unpackFloatX4#) a1
insertFloatX4# :: FloatX4# -> Float# -> Int# -> FloatX4#
insertFloatX4# a1 a2 a3 = (GHC.Prim.insertFloatX4#) a1 a2 a3
plusFloatX4# :: FloatX4# -> FloatX4# -> FloatX4#
plusFloatX4# a1 a2 = (GHC.Prim.plusFloatX4#) a1 a2
minusFloatX4# :: FloatX4# -> FloatX4# -> FloatX4#
minusFloatX4# a1 a2 = (GHC.Prim.minusFloatX4#) a1 a2
timesFloatX4# :: FloatX4# -> FloatX4# -> FloatX4#
timesFloatX4# a1 a2 = (GHC.Prim.timesFloatX4#) a1 a2
divideFloatX4# :: FloatX4# -> FloatX4# -> FloatX4#
divideFloatX4# a1 a2 = (GHC.Prim.divideFloatX4#) a1 a2
negateFloatX4# :: FloatX4# -> FloatX4#
negateFloatX4# a1 = (GHC.Prim.negateFloatX4#) a1
indexFloatX4Array# :: ByteArray# -> Int# -> FloatX4#
indexFloatX4Array# a1 a2 = (GHC.Prim.indexFloatX4Array#) a1 a2
readFloatX4Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,FloatX4# #)
readFloatX4Array# a1 a2 a3 = (GHC.Prim.readFloatX4Array#) a1 a2 a3
writeFloatX4Array# :: MutableByteArray# s -> Int# -> FloatX4# -> State# s -> State# s
writeFloatX4Array# a1 a2 a3 a4 = (GHC.Prim.writeFloatX4Array#) a1 a2 a3 a4
indexFloatX4OffAddr# :: Addr# -> Int# -> FloatX4#
indexFloatX4OffAddr# a1 a2 = (GHC.Prim.indexFloatX4OffAddr#) a1 a2
readFloatX4OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,FloatX4# #)
readFloatX4OffAddr# a1 a2 a3 = (GHC.Prim.readFloatX4OffAddr#) a1 a2 a3
writeFloatX4OffAddr# :: Addr# -> Int# -> FloatX4# -> State# s -> State# s
writeFloatX4OffAddr# a1 a2 a3 a4 = (GHC.Prim.writeFloatX4OffAddr#) a1 a2 a3 a4
indexFloatArrayAsFloatX4# :: ByteArray# -> Int# -> FloatX4#
indexFloatArrayAsFloatX4# a1 a2 = (GHC.Prim.indexFloatArrayAsFloatX4#) a1 a2
readFloatArrayAsFloatX4# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,FloatX4# #)
readFloatArrayAsFloatX4# a1 a2 a3 = (GHC.Prim.readFloatArrayAsFloatX4#) a1 a2 a3
writeFloatArrayAsFloatX4# :: MutableByteArray# s -> Int# -> FloatX4# -> State# s -> State# s
writeFloatArrayAsFloatX4# a1 a2 a3 a4 = (GHC.Prim.writeFloatArrayAsFloatX4#) a1 a2 a3 a4
indexFloatOffAddrAsFloatX4# :: Addr# -> Int# -> FloatX4#
indexFloatOffAddrAsFloatX4# a1 a2 = (GHC.Prim.indexFloatOffAddrAsFloatX4#) a1 a2
readFloatOffAddrAsFloatX4# :: Addr# -> Int# -> State# s -> (# State# s,FloatX4# #)
readFloatOffAddrAsFloatX4# a1 a2 a3 = (GHC.Prim.readFloatOffAddrAsFloatX4#) a1 a2 a3
writeFloatOffAddrAsFloatX4# :: Addr# -> Int# -> FloatX4# -> State# s -> State# s
writeFloatOffAddrAsFloatX4# a1 a2 a3 a4 = (GHC.Prim.writeFloatOffAddrAsFloatX4#) a1 a2 a3 a4
doubleToDoubleX2# :: Double# -> DoubleX2#
doubleToDoubleX2# a1 = (GHC.Prim.doubleToDoubleX2#) a1
insertDoubleX2# :: DoubleX2# -> Double# -> Int# -> DoubleX2#
insertDoubleX2# a1 a2 a3 = (GHC.Prim.insertDoubleX2#) a1 a2 a3
packDoubleX2# :: Double# -> Double# -> DoubleX2#
packDoubleX2# a1 a2 = (GHC.Prim.packDoubleX2#) a1 a2
unpackDoubleX2# :: DoubleX2# -> (# Double#,Double# #)
unpackDoubleX2# a1 = (GHC.Prim.unpackDoubleX2#) a1
plusDoubleX2# :: DoubleX2# -> DoubleX2# -> DoubleX2#
plusDoubleX2# a1 a2 = (GHC.Prim.plusDoubleX2#) a1 a2
minusDoubleX2# :: DoubleX2# -> DoubleX2# -> DoubleX2#
minusDoubleX2# a1 a2 = (GHC.Prim.minusDoubleX2#) a1 a2
timesDoubleX2# :: DoubleX2# -> DoubleX2# -> DoubleX2#
timesDoubleX2# a1 a2 = (GHC.Prim.timesDoubleX2#) a1 a2
divideDoubleX2# :: DoubleX2# -> DoubleX2# -> DoubleX2#
divideDoubleX2# a1 a2 = (GHC.Prim.divideDoubleX2#) a1 a2
negateDoubleX2# :: DoubleX2# -> DoubleX2#
negateDoubleX2# a1 = (GHC.Prim.negateDoubleX2#) a1
indexDoubleX2Array# :: ByteArray# -> Int# -> DoubleX2#
indexDoubleX2Array# a1 a2 = (GHC.Prim.indexDoubleX2Array#) a1 a2
readDoubleX2Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,DoubleX2# #)
readDoubleX2Array# a1 a2 a3 = (GHC.Prim.readDoubleX2Array#) a1 a2 a3
writeDoubleX2Array# :: MutableByteArray# s -> Int# -> DoubleX2# -> State# s -> State# s
writeDoubleX2Array# a1 a2 a3 a4 = (GHC.Prim.writeDoubleX2Array#) a1 a2 a3 a4
indexDoubleX2OffAddr# :: Addr# -> Int# -> DoubleX2#
indexDoubleX2OffAddr# a1 a2 = (GHC.Prim.indexDoubleX2OffAddr#) a1 a2
readDoubleX2OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,DoubleX2# #)
readDoubleX2OffAddr# a1 a2 a3 = (GHC.Prim.readDoubleX2OffAddr#) a1 a2 a3
writeDoubleX2OffAddr# :: Addr# -> Int# -> DoubleX2# -> State# s -> State# s
writeDoubleX2OffAddr# a1 a2 a3 a4 = (GHC.Prim.writeDoubleX2OffAddr#) a1 a2 a3 a4
indexDoubleArrayAsDoubleX2# :: ByteArray# -> Int# -> DoubleX2#
indexDoubleArrayAsDoubleX2# a1 a2 = (GHC.Prim.indexDoubleArrayAsDoubleX2#) a1 a2
readDoubleArrayAsDoubleX2# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,DoubleX2# #)
readDoubleArrayAsDoubleX2# a1 a2 a3 = (GHC.Prim.readDoubleArrayAsDoubleX2#) a1 a2 a3
writeDoubleArrayAsDoubleX2# :: MutableByteArray# s -> Int# -> DoubleX2# -> State# s -> State# s
writeDoubleArrayAsDoubleX2# a1 a2 a3 a4 = (GHC.Prim.writeDoubleArrayAsDoubleX2#) a1 a2 a3 a4
indexDoubleOffAddrAsDoubleX2# :: Addr# -> Int# -> DoubleX2#
indexDoubleOffAddrAsDoubleX2# a1 a2 = (GHC.Prim.indexDoubleOffAddrAsDoubleX2#) a1 a2
readDoubleOffAddrAsDoubleX2# :: Addr# -> Int# -> State# s -> (# State# s,DoubleX2# #)
readDoubleOffAddrAsDoubleX2# a1 a2 a3 = (GHC.Prim.readDoubleOffAddrAsDoubleX2#) a1 a2 a3
writeDoubleOffAddrAsDoubleX2# :: Addr# -> Int# -> DoubleX2# -> State# s -> State# s
writeDoubleOffAddrAsDoubleX2# a1 a2 a3 a4 = (GHC.Prim.writeDoubleOffAddrAsDoubleX2#) a1 a2 a3 a4
int32ToInt32X4# :: Int# -> Int32X4#
int32ToInt32X4# a1 = (GHC.Prim.int32ToInt32X4#) a1
insertInt32X4# :: Int32X4# -> Int# -> Int# -> Int32X4#
insertInt32X4# a1 a2 a3 = (GHC.Prim.insertInt32X4#) a1 a2 a3
packInt32X4# :: Int# -> Int# -> Int# -> Int# -> Int32X4#
packInt32X4# a1 a2 a3 a4 = (GHC.Prim.packInt32X4#) a1 a2 a3 a4
unpackInt32X4# :: Int32X4# -> (# Int#,Int#,Int#,Int# #)
unpackInt32X4# a1 = (GHC.Prim.unpackInt32X4#) a1
plusInt32X4# :: Int32X4# -> Int32X4# -> Int32X4#
plusInt32X4# a1 a2 = (GHC.Prim.plusInt32X4#) a1 a2
minusInt32X4# :: Int32X4# -> Int32X4# -> Int32X4#
minusInt32X4# a1 a2 = (GHC.Prim.minusInt32X4#) a1 a2
timesInt32X4# :: Int32X4# -> Int32X4# -> Int32X4#
timesInt32X4# a1 a2 = (GHC.Prim.timesInt32X4#) a1 a2
quotInt32X4# :: Int32X4# -> Int32X4# -> Int32X4#
quotInt32X4# a1 a2 = (GHC.Prim.quotInt32X4#) a1 a2
remInt32X4# :: Int32X4# -> Int32X4# -> Int32X4#
remInt32X4# a1 a2 = (GHC.Prim.remInt32X4#) a1 a2
negateInt32X4# :: Int32X4# -> Int32X4#
negateInt32X4# a1 = (GHC.Prim.negateInt32X4#) a1
indexInt32X4Array# :: ByteArray# -> Int# -> Int32X4#
indexInt32X4Array# a1 a2 = (GHC.Prim.indexInt32X4Array#) a1 a2
readInt32X4Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int32X4# #)
readInt32X4Array# a1 a2 a3 = (GHC.Prim.readInt32X4Array#) a1 a2 a3
writeInt32X4Array# :: MutableByteArray# s -> Int# -> Int32X4# -> State# s -> State# s
writeInt32X4Array# a1 a2 a3 a4 = (GHC.Prim.writeInt32X4Array#) a1 a2 a3 a4
indexInt32X4OffAddr# :: Addr# -> Int# -> Int32X4#
indexInt32X4OffAddr# a1 a2 = (GHC.Prim.indexInt32X4OffAddr#) a1 a2
readInt32X4OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int32X4# #)
readInt32X4OffAddr# a1 a2 a3 = (GHC.Prim.readInt32X4OffAddr#) a1 a2 a3
writeInt32X4OffAddr# :: Addr# -> Int# -> Int32X4# -> State# s -> State# s
writeInt32X4OffAddr# a1 a2 a3 a4 = (GHC.Prim.writeInt32X4OffAddr#) a1 a2 a3 a4
indexInt32ArrayAsInt32X4# :: ByteArray# -> Int# -> Int32X4#
indexInt32ArrayAsInt32X4# a1 a2 = (GHC.Prim.indexInt32ArrayAsInt32X4#) a1 a2
readInt32ArrayAsInt32X4# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int32X4# #)
readInt32ArrayAsInt32X4# a1 a2 a3 = (GHC.Prim.readInt32ArrayAsInt32X4#) a1 a2 a3
writeInt32ArrayAsInt32X4# :: MutableByteArray# s -> Int# -> Int32X4# -> State# s -> State# s
writeInt32ArrayAsInt32X4# a1 a2 a3 a4 = (GHC.Prim.writeInt32ArrayAsInt32X4#) a1 a2 a3 a4
indexInt32OffAddrAsInt32X4# :: Addr# -> Int# -> Int32X4#
indexInt32OffAddrAsInt32X4# a1 a2 = (GHC.Prim.indexInt32OffAddrAsInt32X4#) a1 a2
readInt32OffAddrAsInt32X4# :: Addr# -> Int# -> State# s -> (# State# s,Int32X4# #)
readInt32OffAddrAsInt32X4# a1 a2 a3 = (GHC.Prim.readInt32OffAddrAsInt32X4#) a1 a2 a3
writeInt32OffAddrAsInt32X4# :: Addr# -> Int# -> Int32X4# -> State# s -> State# s
writeInt32OffAddrAsInt32X4# a1 a2 a3 a4 = (GHC.Prim.writeInt32OffAddrAsInt32X4#) a1 a2 a3 a4
int64ToInt64X2# :: Int# -> Int64X2#
int64ToInt64X2# a1 = (GHC.Prim.int64ToInt64X2#) a1
insertInt64X2# :: Int64X2# -> Int# -> Int# -> Int64X2#
insertInt64X2# a1 a2 a3 = (GHC.Prim.insertInt64X2#) a1 a2 a3
packInt64X2# :: Int# -> Int# -> Int64X2#
packInt64X2# a1 a2 = (GHC.Prim.packInt64X2#) a1 a2
unpackInt64X2# :: Int64X2# -> (# Int#,Int# #)
unpackInt64X2# a1 = (GHC.Prim.unpackInt64X2#) a1
plusInt64X2# :: Int64X2# -> Int64X2# -> Int64X2#
plusInt64X2# a1 a2 = (GHC.Prim.plusInt64X2#) a1 a2
minusInt64X2# :: Int64X2# -> Int64X2# -> Int64X2#
minusInt64X2# a1 a2 = (GHC.Prim.minusInt64X2#) a1 a2
timesInt64X2# :: Int64X2# -> Int64X2# -> Int64X2#
timesInt64X2# a1 a2 = (GHC.Prim.timesInt64X2#) a1 a2
quotInt64X2# :: Int64X2# -> Int64X2# -> Int64X2#
quotInt64X2# a1 a2 = (GHC.Prim.quotInt64X2#) a1 a2
remInt64X2# :: Int64X2# -> Int64X2# -> Int64X2#
remInt64X2# a1 a2 = (GHC.Prim.remInt64X2#) a1 a2
negateInt64X2# :: Int64X2# -> Int64X2#
negateInt64X2# a1 = (GHC.Prim.negateInt64X2#) a1
indexInt64X2Array# :: ByteArray# -> Int# -> Int64X2#
indexInt64X2Array# a1 a2 = (GHC.Prim.indexInt64X2Array#) a1 a2
readInt64X2Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int64X2# #)
readInt64X2Array# a1 a2 a3 = (GHC.Prim.readInt64X2Array#) a1 a2 a3
writeInt64X2Array# :: MutableByteArray# s -> Int# -> Int64X2# -> State# s -> State# s
writeInt64X2Array# a1 a2 a3 a4 = (GHC.Prim.writeInt64X2Array#) a1 a2 a3 a4
indexInt64X2OffAddr# :: Addr# -> Int# -> Int64X2#
indexInt64X2OffAddr# a1 a2 = (GHC.Prim.indexInt64X2OffAddr#) a1 a2
readInt64X2OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int64X2# #)
readInt64X2OffAddr# a1 a2 a3 = (GHC.Prim.readInt64X2OffAddr#) a1 a2 a3
writeInt64X2OffAddr# :: Addr# -> Int# -> Int64X2# -> State# s -> State# s
writeInt64X2OffAddr# a1 a2 a3 a4 = (GHC.Prim.writeInt64X2OffAddr#) a1 a2 a3 a4
indexInt64ArrayAsInt64X2# :: ByteArray# -> Int# -> Int64X2#
indexInt64ArrayAsInt64X2# a1 a2 = (GHC.Prim.indexInt64ArrayAsInt64X2#) a1 a2
readInt64ArrayAsInt64X2# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int64X2# #)
readInt64ArrayAsInt64X2# a1 a2 a3 = (GHC.Prim.readInt64ArrayAsInt64X2#) a1 a2 a3
writeInt64ArrayAsInt64X2# :: MutableByteArray# s -> Int# -> Int64X2# -> State# s -> State# s
writeInt64ArrayAsInt64X2# a1 a2 a3 a4 = (GHC.Prim.writeInt64ArrayAsInt64X2#) a1 a2 a3 a4
indexInt64OffAddrAsInt64X2# :: Addr# -> Int# -> Int64X2#
indexInt64OffAddrAsInt64X2# a1 a2 = (GHC.Prim.indexInt64OffAddrAsInt64X2#) a1 a2
readInt64OffAddrAsInt64X2# :: Addr# -> Int# -> State# s -> (# State# s,Int64X2# #)
readInt64OffAddrAsInt64X2# a1 a2 a3 = (GHC.Prim.readInt64OffAddrAsInt64X2#) a1 a2 a3
writeInt64OffAddrAsInt64X2# :: Addr# -> Int# -> Int64X2# -> State# s -> State# s
writeInt64OffAddrAsInt64X2# a1 a2 a3 a4 = (GHC.Prim.writeInt64OffAddrAsInt64X2#) a1 a2 a3 a4
prefetchByteArray# :: ByteArray# -> Int# -> ByteArray#
prefetchByteArray# a1 a2 = (GHC.Prim.prefetchByteArray#) a1 a2
prefetchMutableByteArray# :: MutableByteArray# s -> Int# -> State# s -> State# s
prefetchMutableByteArray# a1 a2 a3 = (GHC.Prim.prefetchMutableByteArray#) a1 a2 a3
prefetchAddr# :: Addr# -> Int# -> Addr#
prefetchAddr# a1 a2 = (GHC.Prim.prefetchAddr#) a1 a2
#endif /* defined (__GLASGOW_HASKELL_LLVM__) */