module GHC.PrimopWrappers where
import qualified GHC.Prim
import GHC.Tuple ()
import GHC.Prim (Char#, Int#, Int8#, Word8#, Word#, Int16#, Word16#, Int32#, Word32#, Int64#, Word64#, Float#, Double#, State#, MutableArray#, Array#, SmallMutableArray#, SmallArray#, MutableByteArray#, ByteArray#, Addr#, StablePtr#, MutVar#, RealWorld, TVar#, MVar#, IOPort#, ThreadId#, Weak#, StableName#, Compact#, BCO)
gtChar# :: Char# -> Char# -> Int#
gtChar# a1 a2 = GHC.Prim.gtChar# a1 a2
geChar# :: Char# -> Char# -> Int#
geChar# a1 a2 = GHC.Prim.geChar# a1 a2
eqChar# :: Char# -> Char# -> Int#
eqChar# a1 a2 = GHC.Prim.eqChar# a1 a2
neChar# :: Char# -> Char# -> Int#
neChar# a1 a2 = GHC.Prim.neChar# a1 a2
ltChar# :: Char# -> Char# -> Int#
ltChar# a1 a2 = GHC.Prim.ltChar# a1 a2
leChar# :: Char# -> Char# -> Int#
leChar# a1 a2 = GHC.Prim.leChar# a1 a2
ord# :: Char# -> Int#
ord# a1 = GHC.Prim.ord# a1
int8ToInt# :: Int8# -> Int#
int8ToInt# a1 = GHC.Prim.int8ToInt# a1
intToInt8# :: Int# -> Int8#
intToInt8# a1 = GHC.Prim.intToInt8# a1
negateInt8# :: Int8# -> Int8#
negateInt8# a1 = GHC.Prim.negateInt8# a1
plusInt8# :: Int8# -> Int8# -> Int8#
plusInt8# a1 a2 = GHC.Prim.plusInt8# a1 a2
subInt8# :: Int8# -> Int8# -> Int8#
subInt8# a1 a2 = GHC.Prim.subInt8# a1 a2
timesInt8# :: Int8# -> Int8# -> Int8#
timesInt8# a1 a2 = GHC.Prim.timesInt8# a1 a2
quotInt8# :: Int8# -> Int8# -> Int8#
quotInt8# a1 a2 = GHC.Prim.quotInt8# a1 a2
remInt8# :: Int8# -> Int8# -> Int8#
remInt8# a1 a2 = GHC.Prim.remInt8# a1 a2
quotRemInt8# :: Int8# -> Int8# -> (# Int8#,Int8# #)
quotRemInt8# a1 a2 = GHC.Prim.quotRemInt8# a1 a2
uncheckedShiftLInt8# :: Int8# -> Int# -> Int8#
uncheckedShiftLInt8# a1 a2 = GHC.Prim.uncheckedShiftLInt8# a1 a2
uncheckedShiftRAInt8# :: Int8# -> Int# -> Int8#
uncheckedShiftRAInt8# a1 a2 = GHC.Prim.uncheckedShiftRAInt8# a1 a2
uncheckedShiftRLInt8# :: Int8# -> Int# -> Int8#
uncheckedShiftRLInt8# a1 a2 = GHC.Prim.uncheckedShiftRLInt8# a1 a2
int8ToWord8# :: Int8# -> Word8#
int8ToWord8# a1 = GHC.Prim.int8ToWord8# a1
eqInt8# :: Int8# -> Int8# -> Int#
eqInt8# a1 a2 = GHC.Prim.eqInt8# a1 a2
geInt8# :: Int8# -> Int8# -> Int#
geInt8# a1 a2 = GHC.Prim.geInt8# a1 a2
gtInt8# :: Int8# -> Int8# -> Int#
gtInt8# a1 a2 = GHC.Prim.gtInt8# a1 a2
leInt8# :: Int8# -> Int8# -> Int#
leInt8# a1 a2 = GHC.Prim.leInt8# a1 a2
ltInt8# :: Int8# -> Int8# -> Int#
ltInt8# a1 a2 = GHC.Prim.ltInt8# a1 a2
neInt8# :: Int8# -> Int8# -> Int#
neInt8# a1 a2 = GHC.Prim.neInt8# a1 a2
word8ToWord# :: Word8# -> Word#
word8ToWord# a1 = GHC.Prim.word8ToWord# a1
wordToWord8# :: Word# -> Word8#
wordToWord8# a1 = GHC.Prim.wordToWord8# a1
plusWord8# :: Word8# -> Word8# -> Word8#
plusWord8# a1 a2 = GHC.Prim.plusWord8# a1 a2
subWord8# :: Word8# -> Word8# -> Word8#
subWord8# a1 a2 = GHC.Prim.subWord8# a1 a2
timesWord8# :: Word8# -> Word8# -> Word8#
timesWord8# a1 a2 = GHC.Prim.timesWord8# a1 a2
quotWord8# :: Word8# -> Word8# -> Word8#
quotWord8# a1 a2 = GHC.Prim.quotWord8# a1 a2
remWord8# :: Word8# -> Word8# -> Word8#
remWord8# a1 a2 = GHC.Prim.remWord8# a1 a2
quotRemWord8# :: Word8# -> Word8# -> (# Word8#,Word8# #)
quotRemWord8# a1 a2 = GHC.Prim.quotRemWord8# a1 a2
andWord8# :: Word8# -> Word8# -> Word8#
andWord8# a1 a2 = GHC.Prim.andWord8# a1 a2
orWord8# :: Word8# -> Word8# -> Word8#
orWord8# a1 a2 = GHC.Prim.orWord8# a1 a2
xorWord8# :: Word8# -> Word8# -> Word8#
xorWord8# a1 a2 = GHC.Prim.xorWord8# a1 a2
notWord8# :: Word8# -> Word8#
notWord8# a1 = GHC.Prim.notWord8# a1
uncheckedShiftLWord8# :: Word8# -> Int# -> Word8#
uncheckedShiftLWord8# a1 a2 = GHC.Prim.uncheckedShiftLWord8# a1 a2
uncheckedShiftRLWord8# :: Word8# -> Int# -> Word8#
uncheckedShiftRLWord8# a1 a2 = GHC.Prim.uncheckedShiftRLWord8# a1 a2
word8ToInt8# :: Word8# -> Int8#
word8ToInt8# a1 = GHC.Prim.word8ToInt8# a1
eqWord8# :: Word8# -> Word8# -> Int#
eqWord8# a1 a2 = GHC.Prim.eqWord8# a1 a2
geWord8# :: Word8# -> Word8# -> Int#
geWord8# a1 a2 = GHC.Prim.geWord8# a1 a2
gtWord8# :: Word8# -> Word8# -> Int#
gtWord8# a1 a2 = GHC.Prim.gtWord8# a1 a2
leWord8# :: Word8# -> Word8# -> Int#
leWord8# a1 a2 = GHC.Prim.leWord8# a1 a2
ltWord8# :: Word8# -> Word8# -> Int#
ltWord8# a1 a2 = GHC.Prim.ltWord8# a1 a2
neWord8# :: Word8# -> Word8# -> Int#
neWord8# a1 a2 = GHC.Prim.neWord8# a1 a2
int16ToInt# :: Int16# -> Int#
int16ToInt# a1 = GHC.Prim.int16ToInt# a1
intToInt16# :: Int# -> Int16#
intToInt16# a1 = GHC.Prim.intToInt16# a1
negateInt16# :: Int16# -> Int16#
negateInt16# a1 = GHC.Prim.negateInt16# a1
plusInt16# :: Int16# -> Int16# -> Int16#
plusInt16# a1 a2 = GHC.Prim.plusInt16# a1 a2
subInt16# :: Int16# -> Int16# -> Int16#
subInt16# a1 a2 = GHC.Prim.subInt16# a1 a2
timesInt16# :: Int16# -> Int16# -> Int16#
timesInt16# a1 a2 = GHC.Prim.timesInt16# a1 a2
quotInt16# :: Int16# -> Int16# -> Int16#
quotInt16# a1 a2 = GHC.Prim.quotInt16# a1 a2
remInt16# :: Int16# -> Int16# -> Int16#
remInt16# a1 a2 = GHC.Prim.remInt16# a1 a2
quotRemInt16# :: Int16# -> Int16# -> (# Int16#,Int16# #)
quotRemInt16# a1 a2 = GHC.Prim.quotRemInt16# a1 a2
uncheckedShiftLInt16# :: Int16# -> Int# -> Int16#
uncheckedShiftLInt16# a1 a2 = GHC.Prim.uncheckedShiftLInt16# a1 a2
uncheckedShiftRAInt16# :: Int16# -> Int# -> Int16#
uncheckedShiftRAInt16# a1 a2 = GHC.Prim.uncheckedShiftRAInt16# a1 a2
uncheckedShiftRLInt16# :: Int16# -> Int# -> Int16#
uncheckedShiftRLInt16# a1 a2 = GHC.Prim.uncheckedShiftRLInt16# a1 a2
int16ToWord16# :: Int16# -> Word16#
int16ToWord16# a1 = GHC.Prim.int16ToWord16# a1
eqInt16# :: Int16# -> Int16# -> Int#
eqInt16# a1 a2 = GHC.Prim.eqInt16# a1 a2
geInt16# :: Int16# -> Int16# -> Int#
geInt16# a1 a2 = GHC.Prim.geInt16# a1 a2
gtInt16# :: Int16# -> Int16# -> Int#
gtInt16# a1 a2 = GHC.Prim.gtInt16# a1 a2
leInt16# :: Int16# -> Int16# -> Int#
leInt16# a1 a2 = GHC.Prim.leInt16# a1 a2
ltInt16# :: Int16# -> Int16# -> Int#
ltInt16# a1 a2 = GHC.Prim.ltInt16# a1 a2
neInt16# :: Int16# -> Int16# -> Int#
neInt16# a1 a2 = GHC.Prim.neInt16# a1 a2
word16ToWord# :: Word16# -> Word#
word16ToWord# a1 = GHC.Prim.word16ToWord# a1
wordToWord16# :: Word# -> Word16#
wordToWord16# a1 = GHC.Prim.wordToWord16# a1
plusWord16# :: Word16# -> Word16# -> Word16#
plusWord16# a1 a2 = GHC.Prim.plusWord16# a1 a2
subWord16# :: Word16# -> Word16# -> Word16#
subWord16# a1 a2 = GHC.Prim.subWord16# a1 a2
timesWord16# :: Word16# -> Word16# -> Word16#
timesWord16# a1 a2 = GHC.Prim.timesWord16# a1 a2
quotWord16# :: Word16# -> Word16# -> Word16#
quotWord16# a1 a2 = GHC.Prim.quotWord16# a1 a2
remWord16# :: Word16# -> Word16# -> Word16#
remWord16# a1 a2 = GHC.Prim.remWord16# a1 a2
quotRemWord16# :: Word16# -> Word16# -> (# Word16#,Word16# #)
quotRemWord16# a1 a2 = GHC.Prim.quotRemWord16# a1 a2
andWord16# :: Word16# -> Word16# -> Word16#
andWord16# a1 a2 = GHC.Prim.andWord16# a1 a2
orWord16# :: Word16# -> Word16# -> Word16#
orWord16# a1 a2 = GHC.Prim.orWord16# a1 a2
xorWord16# :: Word16# -> Word16# -> Word16#
xorWord16# a1 a2 = GHC.Prim.xorWord16# a1 a2
notWord16# :: Word16# -> Word16#
notWord16# a1 = GHC.Prim.notWord16# a1
uncheckedShiftLWord16# :: Word16# -> Int# -> Word16#
uncheckedShiftLWord16# a1 a2 = GHC.Prim.uncheckedShiftLWord16# a1 a2
uncheckedShiftRLWord16# :: Word16# -> Int# -> Word16#
uncheckedShiftRLWord16# a1 a2 = GHC.Prim.uncheckedShiftRLWord16# a1 a2
word16ToInt16# :: Word16# -> Int16#
word16ToInt16# a1 = GHC.Prim.word16ToInt16# a1
eqWord16# :: Word16# -> Word16# -> Int#
eqWord16# a1 a2 = GHC.Prim.eqWord16# a1 a2
geWord16# :: Word16# -> Word16# -> Int#
geWord16# a1 a2 = GHC.Prim.geWord16# a1 a2
gtWord16# :: Word16# -> Word16# -> Int#
gtWord16# a1 a2 = GHC.Prim.gtWord16# a1 a2
leWord16# :: Word16# -> Word16# -> Int#
leWord16# a1 a2 = GHC.Prim.leWord16# a1 a2
ltWord16# :: Word16# -> Word16# -> Int#
ltWord16# a1 a2 = GHC.Prim.ltWord16# a1 a2
neWord16# :: Word16# -> Word16# -> Int#
neWord16# a1 a2 = GHC.Prim.neWord16# a1 a2
int32ToInt# :: Int32# -> Int#
int32ToInt# a1 = GHC.Prim.int32ToInt# a1
intToInt32# :: Int# -> Int32#
intToInt32# a1 = GHC.Prim.intToInt32# a1
negateInt32# :: Int32# -> Int32#
negateInt32# a1 = GHC.Prim.negateInt32# a1
plusInt32# :: Int32# -> Int32# -> Int32#
plusInt32# a1 a2 = GHC.Prim.plusInt32# a1 a2
subInt32# :: Int32# -> Int32# -> Int32#
subInt32# a1 a2 = GHC.Prim.subInt32# a1 a2
timesInt32# :: Int32# -> Int32# -> Int32#
timesInt32# a1 a2 = GHC.Prim.timesInt32# a1 a2
quotInt32# :: Int32# -> Int32# -> Int32#
quotInt32# a1 a2 = GHC.Prim.quotInt32# a1 a2
remInt32# :: Int32# -> Int32# -> Int32#
remInt32# a1 a2 = GHC.Prim.remInt32# a1 a2
quotRemInt32# :: Int32# -> Int32# -> (# Int32#,Int32# #)
quotRemInt32# a1 a2 = GHC.Prim.quotRemInt32# a1 a2
uncheckedShiftLInt32# :: Int32# -> Int# -> Int32#
uncheckedShiftLInt32# a1 a2 = GHC.Prim.uncheckedShiftLInt32# a1 a2
uncheckedShiftRAInt32# :: Int32# -> Int# -> Int32#
uncheckedShiftRAInt32# a1 a2 = GHC.Prim.uncheckedShiftRAInt32# a1 a2
uncheckedShiftRLInt32# :: Int32# -> Int# -> Int32#
uncheckedShiftRLInt32# a1 a2 = GHC.Prim.uncheckedShiftRLInt32# a1 a2
int32ToWord32# :: Int32# -> Word32#
int32ToWord32# a1 = GHC.Prim.int32ToWord32# a1
eqInt32# :: Int32# -> Int32# -> Int#
eqInt32# a1 a2 = GHC.Prim.eqInt32# a1 a2
geInt32# :: Int32# -> Int32# -> Int#
geInt32# a1 a2 = GHC.Prim.geInt32# a1 a2
gtInt32# :: Int32# -> Int32# -> Int#
gtInt32# a1 a2 = GHC.Prim.gtInt32# a1 a2
leInt32# :: Int32# -> Int32# -> Int#
leInt32# a1 a2 = GHC.Prim.leInt32# a1 a2
ltInt32# :: Int32# -> Int32# -> Int#
ltInt32# a1 a2 = GHC.Prim.ltInt32# a1 a2
neInt32# :: Int32# -> Int32# -> Int#
neInt32# a1 a2 = GHC.Prim.neInt32# a1 a2
word32ToWord# :: Word32# -> Word#
word32ToWord# a1 = GHC.Prim.word32ToWord# a1
wordToWord32# :: Word# -> Word32#
wordToWord32# a1 = GHC.Prim.wordToWord32# a1
plusWord32# :: Word32# -> Word32# -> Word32#
plusWord32# a1 a2 = GHC.Prim.plusWord32# a1 a2
subWord32# :: Word32# -> Word32# -> Word32#
subWord32# a1 a2 = GHC.Prim.subWord32# a1 a2
timesWord32# :: Word32# -> Word32# -> Word32#
timesWord32# a1 a2 = GHC.Prim.timesWord32# a1 a2
quotWord32# :: Word32# -> Word32# -> Word32#
quotWord32# a1 a2 = GHC.Prim.quotWord32# a1 a2
remWord32# :: Word32# -> Word32# -> Word32#
remWord32# a1 a2 = GHC.Prim.remWord32# a1 a2
quotRemWord32# :: Word32# -> Word32# -> (# Word32#,Word32# #)
quotRemWord32# a1 a2 = GHC.Prim.quotRemWord32# a1 a2
andWord32# :: Word32# -> Word32# -> Word32#
andWord32# a1 a2 = GHC.Prim.andWord32# a1 a2
orWord32# :: Word32# -> Word32# -> Word32#
orWord32# a1 a2 = GHC.Prim.orWord32# a1 a2
xorWord32# :: Word32# -> Word32# -> Word32#
xorWord32# a1 a2 = GHC.Prim.xorWord32# a1 a2
notWord32# :: Word32# -> Word32#
notWord32# a1 = GHC.Prim.notWord32# a1
uncheckedShiftLWord32# :: Word32# -> Int# -> Word32#
uncheckedShiftLWord32# a1 a2 = GHC.Prim.uncheckedShiftLWord32# a1 a2
uncheckedShiftRLWord32# :: Word32# -> Int# -> Word32#
uncheckedShiftRLWord32# a1 a2 = GHC.Prim.uncheckedShiftRLWord32# a1 a2
word32ToInt32# :: Word32# -> Int32#
word32ToInt32# a1 = GHC.Prim.word32ToInt32# a1
eqWord32# :: Word32# -> Word32# -> Int#
eqWord32# a1 a2 = GHC.Prim.eqWord32# a1 a2
geWord32# :: Word32# -> Word32# -> Int#
geWord32# a1 a2 = GHC.Prim.geWord32# a1 a2
gtWord32# :: Word32# -> Word32# -> Int#
gtWord32# a1 a2 = GHC.Prim.gtWord32# a1 a2
leWord32# :: Word32# -> Word32# -> Int#
leWord32# a1 a2 = GHC.Prim.leWord32# a1 a2
ltWord32# :: Word32# -> Word32# -> Int#
ltWord32# a1 a2 = GHC.Prim.ltWord32# a1 a2
neWord32# :: Word32# -> Word32# -> Int#
neWord32# a1 a2 = GHC.Prim.neWord32# a1 a2
int64ToInt# :: Int64# -> Int#
int64ToInt# a1 = GHC.Prim.int64ToInt# a1
intToInt64# :: Int# -> Int64#
intToInt64# a1 = GHC.Prim.intToInt64# a1
negateInt64# :: Int64# -> Int64#
negateInt64# a1 = GHC.Prim.negateInt64# a1
plusInt64# :: Int64# -> Int64# -> Int64#
plusInt64# a1 a2 = GHC.Prim.plusInt64# a1 a2
subInt64# :: Int64# -> Int64# -> Int64#
subInt64# a1 a2 = GHC.Prim.subInt64# a1 a2
timesInt64# :: Int64# -> Int64# -> Int64#
timesInt64# a1 a2 = GHC.Prim.timesInt64# a1 a2
quotInt64# :: Int64# -> Int64# -> Int64#
quotInt64# a1 a2 = GHC.Prim.quotInt64# a1 a2
remInt64# :: Int64# -> Int64# -> Int64#
remInt64# a1 a2 = GHC.Prim.remInt64# a1 a2
uncheckedIShiftL64# :: Int64# -> Int# -> Int64#
uncheckedIShiftL64# a1 a2 = GHC.Prim.uncheckedIShiftL64# a1 a2
uncheckedIShiftRA64# :: Int64# -> Int# -> Int64#
uncheckedIShiftRA64# a1 a2 = GHC.Prim.uncheckedIShiftRA64# a1 a2
uncheckedIShiftRL64# :: Int64# -> Int# -> Int64#
uncheckedIShiftRL64# a1 a2 = GHC.Prim.uncheckedIShiftRL64# a1 a2
int64ToWord64# :: Int64# -> Word64#
int64ToWord64# a1 = GHC.Prim.int64ToWord64# a1
eqInt64# :: Int64# -> Int64# -> Int#
eqInt64# a1 a2 = GHC.Prim.eqInt64# a1 a2
geInt64# :: Int64# -> Int64# -> Int#
geInt64# a1 a2 = GHC.Prim.geInt64# a1 a2
gtInt64# :: Int64# -> Int64# -> Int#
gtInt64# a1 a2 = GHC.Prim.gtInt64# a1 a2
leInt64# :: Int64# -> Int64# -> Int#
leInt64# a1 a2 = GHC.Prim.leInt64# a1 a2
ltInt64# :: Int64# -> Int64# -> Int#
ltInt64# a1 a2 = GHC.Prim.ltInt64# a1 a2
neInt64# :: Int64# -> Int64# -> Int#
neInt64# a1 a2 = GHC.Prim.neInt64# a1 a2
word64ToWord# :: Word64# -> Word#
word64ToWord# a1 = GHC.Prim.word64ToWord# a1
wordToWord64# :: Word# -> Word64#
wordToWord64# a1 = GHC.Prim.wordToWord64# a1
plusWord64# :: Word64# -> Word64# -> Word64#
plusWord64# a1 a2 = GHC.Prim.plusWord64# a1 a2
subWord64# :: Word64# -> Word64# -> Word64#
subWord64# a1 a2 = GHC.Prim.subWord64# a1 a2
timesWord64# :: Word64# -> Word64# -> Word64#
timesWord64# a1 a2 = GHC.Prim.timesWord64# a1 a2
quotWord64# :: Word64# -> Word64# -> Word64#
quotWord64# a1 a2 = GHC.Prim.quotWord64# a1 a2
remWord64# :: Word64# -> Word64# -> Word64#
remWord64# a1 a2 = GHC.Prim.remWord64# a1 a2
and64# :: Word64# -> Word64# -> Word64#
and64# a1 a2 = GHC.Prim.and64# a1 a2
or64# :: Word64# -> Word64# -> Word64#
or64# a1 a2 = GHC.Prim.or64# a1 a2
xor64# :: Word64# -> Word64# -> Word64#
xor64# a1 a2 = GHC.Prim.xor64# a1 a2
not64# :: Word64# -> Word64#
not64# a1 = GHC.Prim.not64# a1
uncheckedShiftL64# :: Word64# -> Int# -> Word64#
uncheckedShiftL64# a1 a2 = GHC.Prim.uncheckedShiftL64# a1 a2
uncheckedShiftRL64# :: Word64# -> Int# -> Word64#
uncheckedShiftRL64# a1 a2 = GHC.Prim.uncheckedShiftRL64# a1 a2
word64ToInt64# :: Word64# -> Int64#
word64ToInt64# a1 = GHC.Prim.word64ToInt64# a1
eqWord64# :: Word64# -> Word64# -> Int#
eqWord64# a1 a2 = GHC.Prim.eqWord64# a1 a2
geWord64# :: Word64# -> Word64# -> Int#
geWord64# a1 a2 = GHC.Prim.geWord64# a1 a2
gtWord64# :: Word64# -> Word64# -> Int#
gtWord64# a1 a2 = GHC.Prim.gtWord64# a1 a2
leWord64# :: Word64# -> Word64# -> Int#
leWord64# a1 a2 = GHC.Prim.leWord64# a1 a2
ltWord64# :: Word64# -> Word64# -> Int#
ltWord64# a1 a2 = GHC.Prim.ltWord64# a1 a2
neWord64# :: Word64# -> Word64# -> Int#
neWord64# a1 a2 = GHC.Prim.neWord64# 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
timesInt2# :: Int# -> Int# -> (# Int#,Int#,Int# #)
timesInt2# a1 a2 = GHC.Prim.timesInt2# 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
addWordC# :: Word# -> Word# -> (# Word#,Int# #)
addWordC# a1 a2 = GHC.Prim.addWordC# a1 a2
subWordC# :: Word# -> Word# -> (# Word#,Int# #)
subWordC# a1 a2 = GHC.Prim.subWordC# 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
gtWord# :: Word# -> Word# -> Int#
gtWord# a1 a2 = GHC.Prim.gtWord# a1 a2
geWord# :: Word# -> Word# -> Int#
geWord# a1 a2 = GHC.Prim.geWord# a1 a2
eqWord# :: Word# -> Word# -> Int#
eqWord# a1 a2 = GHC.Prim.eqWord# a1 a2
neWord# :: Word# -> Word# -> Int#
neWord# a1 a2 = GHC.Prim.neWord# a1 a2
ltWord# :: Word# -> Word# -> Int#
ltWord# a1 a2 = GHC.Prim.ltWord# a1 a2
leWord# :: Word# -> Word# -> Int#
leWord# a1 a2 = GHC.Prim.leWord# 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# :: Word64# -> Word#
popCnt64# a1 = GHC.Prim.popCnt64# a1
popCnt# :: Word# -> Word#
popCnt# a1 = GHC.Prim.popCnt# a1
pdep8# :: Word# -> Word# -> Word#
pdep8# a1 a2 = GHC.Prim.pdep8# a1 a2
pdep16# :: Word# -> Word# -> Word#
pdep16# a1 a2 = GHC.Prim.pdep16# a1 a2
pdep32# :: Word# -> Word# -> Word#
pdep32# a1 a2 = GHC.Prim.pdep32# a1 a2
pdep64# :: Word64# -> Word64# -> Word64#
pdep64# a1 a2 = GHC.Prim.pdep64# a1 a2
pdep# :: Word# -> Word# -> Word#
pdep# a1 a2 = GHC.Prim.pdep# a1 a2
pext8# :: Word# -> Word# -> Word#
pext8# a1 a2 = GHC.Prim.pext8# a1 a2
pext16# :: Word# -> Word# -> Word#
pext16# a1 a2 = GHC.Prim.pext16# a1 a2
pext32# :: Word# -> Word# -> Word#
pext32# a1 a2 = GHC.Prim.pext32# a1 a2
pext64# :: Word64# -> Word64# -> Word64#
pext64# a1 a2 = GHC.Prim.pext64# a1 a2
pext# :: Word# -> Word# -> Word#
pext# a1 a2 = GHC.Prim.pext# a1 a2
clz8# :: Word# -> Word#
clz8# a1 = GHC.Prim.clz8# a1
clz16# :: Word# -> Word#
clz16# a1 = GHC.Prim.clz16# a1
clz32# :: Word# -> Word#
clz32# a1 = GHC.Prim.clz32# a1
clz64# :: Word64# -> Word#
clz64# a1 = GHC.Prim.clz64# a1
clz# :: Word# -> Word#
clz# a1 = GHC.Prim.clz# a1
ctz8# :: Word# -> Word#
ctz8# a1 = GHC.Prim.ctz8# a1
ctz16# :: Word# -> Word#
ctz16# a1 = GHC.Prim.ctz16# a1
ctz32# :: Word# -> Word#
ctz32# a1 = GHC.Prim.ctz32# a1
ctz64# :: Word64# -> Word#
ctz64# a1 = GHC.Prim.ctz64# a1
ctz# :: Word# -> Word#
ctz# a1 = GHC.Prim.ctz# a1
byteSwap16# :: Word# -> Word#
byteSwap16# a1 = GHC.Prim.byteSwap16# a1
byteSwap32# :: Word# -> Word#
byteSwap32# a1 = GHC.Prim.byteSwap32# a1
byteSwap64# :: Word64# -> Word64#
byteSwap64# a1 = GHC.Prim.byteSwap64# a1
byteSwap# :: Word# -> Word#
byteSwap# a1 = GHC.Prim.byteSwap# a1
bitReverse8# :: Word# -> Word#
bitReverse8# a1 = GHC.Prim.bitReverse8# a1
bitReverse16# :: Word# -> Word#
bitReverse16# a1 = GHC.Prim.bitReverse16# a1
bitReverse32# :: Word# -> Word#
bitReverse32# a1 = GHC.Prim.bitReverse32# a1
bitReverse64# :: Word64# -> Word64#
bitReverse64# a1 = GHC.Prim.bitReverse64# a1
bitReverse# :: Word# -> Word#
bitReverse# a1 = GHC.Prim.bitReverse# 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
fabsDouble# :: Double# -> Double#
fabsDouble# a1 = GHC.Prim.fabsDouble# 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
expm1Double# :: Double# -> Double#
expm1Double# a1 = GHC.Prim.expm1Double# a1
logDouble# :: Double# -> Double#
logDouble# a1 = GHC.Prim.logDouble# a1
log1pDouble# :: Double# -> Double#
log1pDouble# a1 = GHC.Prim.log1pDouble# 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
asinhDouble# :: Double# -> Double#
asinhDouble# a1 = GHC.Prim.asinhDouble# a1
acoshDouble# :: Double# -> Double#
acoshDouble# a1 = GHC.Prim.acoshDouble# a1
atanhDouble# :: Double# -> Double#
atanhDouble# a1 = GHC.Prim.atanhDouble# 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
decodeDouble_Int64# :: Double# -> (# Int64#,Int# #)
decodeDouble_Int64# a1 = GHC.Prim.decodeDouble_Int64# a1
gtFloat# :: Float# -> Float# -> Int#
gtFloat# a1 a2 = GHC.Prim.gtFloat# a1 a2
geFloat# :: Float# -> Float# -> Int#
geFloat# a1 a2 = GHC.Prim.geFloat# a1 a2
eqFloat# :: Float# -> Float# -> Int#
eqFloat# a1 a2 = GHC.Prim.eqFloat# a1 a2
neFloat# :: Float# -> Float# -> Int#
neFloat# a1 a2 = GHC.Prim.neFloat# a1 a2
ltFloat# :: Float# -> Float# -> Int#
ltFloat# a1 a2 = GHC.Prim.ltFloat# a1 a2
leFloat# :: Float# -> Float# -> Int#
leFloat# a1 a2 = GHC.Prim.leFloat# 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
fabsFloat# :: Float# -> Float#
fabsFloat# a1 = GHC.Prim.fabsFloat# a1
float2Int# :: Float# -> Int#
float2Int# a1 = GHC.Prim.float2Int# a1
expFloat# :: Float# -> Float#
expFloat# a1 = GHC.Prim.expFloat# a1
expm1Float# :: Float# -> Float#
expm1Float# a1 = GHC.Prim.expm1Float# a1
logFloat# :: Float# -> Float#
logFloat# a1 = GHC.Prim.logFloat# a1
log1pFloat# :: Float# -> Float#
log1pFloat# a1 = GHC.Prim.log1pFloat# 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
asinhFloat# :: Float# -> Float#
asinhFloat# a1 = GHC.Prim.asinhFloat# a1
acoshFloat# :: Float# -> Float#
acoshFloat# a1 = GHC.Prim.acoshFloat# a1
atanhFloat# :: Float# -> Float#
atanhFloat# a1 = GHC.Prim.atanhFloat# 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# -> v -> State# s -> (# State# s,MutableArray# s v #)
newArray# a1 a2 a3 = GHC.Prim.newArray# a1 a2 a3
readArray# :: MutableArray# s v -> Int# -> State# s -> (# State# s,v #)
readArray# a1 a2 a3 = GHC.Prim.readArray# a1 a2 a3
writeArray# :: MutableArray# s v -> Int# -> v -> State# s -> State# s
writeArray# a1 a2 a3 a4 = GHC.Prim.writeArray# a1 a2 a3 a4
sizeofArray# :: Array# v -> Int#
sizeofArray# a1 = GHC.Prim.sizeofArray# a1
sizeofMutableArray# :: MutableArray# s v -> Int#
sizeofMutableArray# a1 = GHC.Prim.sizeofMutableArray# a1
indexArray# :: Array# v -> Int# -> (# v #)
indexArray# a1 a2 = GHC.Prim.indexArray# a1 a2
unsafeFreezeArray# :: MutableArray# s v -> State# s -> (# State# s,Array# v #)
unsafeFreezeArray# a1 a2 = GHC.Prim.unsafeFreezeArray# a1 a2
unsafeThawArray# :: Array# v -> State# s -> (# State# s,MutableArray# s v #)
unsafeThawArray# a1 a2 = GHC.Prim.unsafeThawArray# a1 a2
copyArray# :: Array# v -> Int# -> MutableArray# s v -> 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 v -> Int# -> MutableArray# s v -> Int# -> Int# -> State# s -> State# s
copyMutableArray# a1 a2 a3 a4 a5 a6 = GHC.Prim.copyMutableArray# a1 a2 a3 a4 a5 a6
cloneArray# :: Array# v -> Int# -> Int# -> Array# v
cloneArray# a1 a2 a3 = GHC.Prim.cloneArray# a1 a2 a3
cloneMutableArray# :: MutableArray# s v -> Int# -> Int# -> State# s -> (# State# s,MutableArray# s v #)
cloneMutableArray# a1 a2 a3 a4 = GHC.Prim.cloneMutableArray# a1 a2 a3 a4
freezeArray# :: MutableArray# s v -> Int# -> Int# -> State# s -> (# State# s,Array# v #)
freezeArray# a1 a2 a3 a4 = GHC.Prim.freezeArray# a1 a2 a3 a4
thawArray# :: Array# v -> Int# -> Int# -> State# s -> (# State# s,MutableArray# s v #)
thawArray# a1 a2 a3 a4 = GHC.Prim.thawArray# a1 a2 a3 a4
casArray# :: MutableArray# s v -> Int# -> v -> v -> State# s -> (# State# s,Int#,v #)
casArray# a1 a2 a3 a4 a5 = GHC.Prim.casArray# a1 a2 a3 a4 a5
newSmallArray# :: Int# -> v -> State# s -> (# State# s,SmallMutableArray# s v #)
newSmallArray# a1 a2 a3 = GHC.Prim.newSmallArray# a1 a2 a3
shrinkSmallMutableArray# :: SmallMutableArray# s v -> Int# -> State# s -> State# s
shrinkSmallMutableArray# a1 a2 a3 = GHC.Prim.shrinkSmallMutableArray# a1 a2 a3
readSmallArray# :: SmallMutableArray# s v -> Int# -> State# s -> (# State# s,v #)
readSmallArray# a1 a2 a3 = GHC.Prim.readSmallArray# a1 a2 a3
writeSmallArray# :: SmallMutableArray# s v -> Int# -> v -> State# s -> State# s
writeSmallArray# a1 a2 a3 a4 = GHC.Prim.writeSmallArray# a1 a2 a3 a4
sizeofSmallArray# :: SmallArray# v -> Int#
sizeofSmallArray# a1 = GHC.Prim.sizeofSmallArray# a1
sizeofSmallMutableArray# :: SmallMutableArray# s v -> Int#
sizeofSmallMutableArray# a1 = GHC.Prim.sizeofSmallMutableArray# a1
getSizeofSmallMutableArray# :: SmallMutableArray# s v -> State# s -> (# State# s,Int# #)
getSizeofSmallMutableArray# a1 a2 = GHC.Prim.getSizeofSmallMutableArray# a1 a2
indexSmallArray# :: SmallArray# v -> Int# -> (# v #)
indexSmallArray# a1 a2 = GHC.Prim.indexSmallArray# a1 a2
unsafeFreezeSmallArray# :: SmallMutableArray# s v -> State# s -> (# State# s,SmallArray# v #)
unsafeFreezeSmallArray# a1 a2 = GHC.Prim.unsafeFreezeSmallArray# a1 a2
unsafeThawSmallArray# :: SmallArray# v -> State# s -> (# State# s,SmallMutableArray# s v #)
unsafeThawSmallArray# a1 a2 = GHC.Prim.unsafeThawSmallArray# a1 a2
copySmallArray# :: SmallArray# v -> Int# -> SmallMutableArray# s v -> Int# -> Int# -> State# s -> State# s
copySmallArray# a1 a2 a3 a4 a5 a6 = GHC.Prim.copySmallArray# a1 a2 a3 a4 a5 a6
copySmallMutableArray# :: SmallMutableArray# s v -> Int# -> SmallMutableArray# s v -> Int# -> Int# -> State# s -> State# s
copySmallMutableArray# a1 a2 a3 a4 a5 a6 = GHC.Prim.copySmallMutableArray# a1 a2 a3 a4 a5 a6
cloneSmallArray# :: SmallArray# v -> Int# -> Int# -> SmallArray# v
cloneSmallArray# a1 a2 a3 = GHC.Prim.cloneSmallArray# a1 a2 a3
cloneSmallMutableArray# :: SmallMutableArray# s v -> Int# -> Int# -> State# s -> (# State# s,SmallMutableArray# s v #)
cloneSmallMutableArray# a1 a2 a3 a4 = GHC.Prim.cloneSmallMutableArray# a1 a2 a3 a4
freezeSmallArray# :: SmallMutableArray# s v -> Int# -> Int# -> State# s -> (# State# s,SmallArray# v #)
freezeSmallArray# a1 a2 a3 a4 = GHC.Prim.freezeSmallArray# a1 a2 a3 a4
thawSmallArray# :: SmallArray# v -> Int# -> Int# -> State# s -> (# State# s,SmallMutableArray# s v #)
thawSmallArray# a1 a2 a3 a4 = GHC.Prim.thawSmallArray# a1 a2 a3 a4
casSmallArray# :: SmallMutableArray# s v -> Int# -> v -> v -> State# s -> (# State# s,Int#,v #)
casSmallArray# a1 a2 a3 a4 a5 = GHC.Prim.casSmallArray# a1 a2 a3 a4 a5
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
isMutableByteArrayPinned# :: MutableByteArray# s -> Int#
isMutableByteArrayPinned# a1 = GHC.Prim.isMutableByteArrayPinned# a1
isByteArrayPinned# :: ByteArray# -> Int#
isByteArrayPinned# a1 = GHC.Prim.isByteArrayPinned# a1
byteArrayContents# :: ByteArray# -> Addr#
byteArrayContents# a1 = GHC.Prim.byteArrayContents# a1
mutableByteArrayContents# :: MutableByteArray# s -> Addr#
mutableByteArrayContents# a1 = GHC.Prim.mutableByteArrayContents# a1
shrinkMutableByteArray# :: MutableByteArray# s -> Int# -> State# s -> State# s
shrinkMutableByteArray# a1 a2 a3 = GHC.Prim.shrinkMutableByteArray# a1 a2 a3
resizeMutableByteArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,MutableByteArray# s #)
resizeMutableByteArray# a1 a2 a3 = GHC.Prim.resizeMutableByteArray# a1 a2 a3
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
getSizeofMutableByteArray# :: MutableByteArray# s -> State# s -> (# State# s,Int# #)
getSizeofMutableByteArray# a1 a2 = GHC.Prim.getSizeofMutableByteArray# a1 a2
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# -> Int8#
indexInt8Array# a1 a2 = GHC.Prim.indexInt8Array# a1 a2
indexInt16Array# :: ByteArray# -> Int# -> Int16#
indexInt16Array# a1 a2 = GHC.Prim.indexInt16Array# a1 a2
indexInt32Array# :: ByteArray# -> Int# -> Int32#
indexInt32Array# a1 a2 = GHC.Prim.indexInt32Array# a1 a2
indexInt64Array# :: ByteArray# -> Int# -> Int64#
indexInt64Array# a1 a2 = GHC.Prim.indexInt64Array# a1 a2
indexWord8Array# :: ByteArray# -> Int# -> Word8#
indexWord8Array# a1 a2 = GHC.Prim.indexWord8Array# a1 a2
indexWord16Array# :: ByteArray# -> Int# -> Word16#
indexWord16Array# a1 a2 = GHC.Prim.indexWord16Array# a1 a2
indexWord32Array# :: ByteArray# -> Int# -> Word32#
indexWord32Array# a1 a2 = GHC.Prim.indexWord32Array# a1 a2
indexWord64Array# :: ByteArray# -> Int# -> Word64#
indexWord64Array# a1 a2 = GHC.Prim.indexWord64Array# a1 a2
indexWord8ArrayAsChar# :: ByteArray# -> Int# -> Char#
indexWord8ArrayAsChar# a1 a2 = GHC.Prim.indexWord8ArrayAsChar# a1 a2
indexWord8ArrayAsWideChar# :: ByteArray# -> Int# -> Char#
indexWord8ArrayAsWideChar# a1 a2 = GHC.Prim.indexWord8ArrayAsWideChar# a1 a2
indexWord8ArrayAsInt# :: ByteArray# -> Int# -> Int#
indexWord8ArrayAsInt# a1 a2 = GHC.Prim.indexWord8ArrayAsInt# a1 a2
indexWord8ArrayAsWord# :: ByteArray# -> Int# -> Word#
indexWord8ArrayAsWord# a1 a2 = GHC.Prim.indexWord8ArrayAsWord# a1 a2
indexWord8ArrayAsAddr# :: ByteArray# -> Int# -> Addr#
indexWord8ArrayAsAddr# a1 a2 = GHC.Prim.indexWord8ArrayAsAddr# a1 a2
indexWord8ArrayAsFloat# :: ByteArray# -> Int# -> Float#
indexWord8ArrayAsFloat# a1 a2 = GHC.Prim.indexWord8ArrayAsFloat# a1 a2
indexWord8ArrayAsDouble# :: ByteArray# -> Int# -> Double#
indexWord8ArrayAsDouble# a1 a2 = GHC.Prim.indexWord8ArrayAsDouble# a1 a2
indexWord8ArrayAsStablePtr# :: ByteArray# -> Int# -> StablePtr# a
indexWord8ArrayAsStablePtr# a1 a2 = GHC.Prim.indexWord8ArrayAsStablePtr# a1 a2
indexWord8ArrayAsInt16# :: ByteArray# -> Int# -> Int16#
indexWord8ArrayAsInt16# a1 a2 = GHC.Prim.indexWord8ArrayAsInt16# a1 a2
indexWord8ArrayAsInt32# :: ByteArray# -> Int# -> Int32#
indexWord8ArrayAsInt32# a1 a2 = GHC.Prim.indexWord8ArrayAsInt32# a1 a2
indexWord8ArrayAsInt64# :: ByteArray# -> Int# -> Int64#
indexWord8ArrayAsInt64# a1 a2 = GHC.Prim.indexWord8ArrayAsInt64# a1 a2
indexWord8ArrayAsWord16# :: ByteArray# -> Int# -> Word16#
indexWord8ArrayAsWord16# a1 a2 = GHC.Prim.indexWord8ArrayAsWord16# a1 a2
indexWord8ArrayAsWord32# :: ByteArray# -> Int# -> Word32#
indexWord8ArrayAsWord32# a1 a2 = GHC.Prim.indexWord8ArrayAsWord32# a1 a2
indexWord8ArrayAsWord64# :: ByteArray# -> Int# -> Word64#
indexWord8ArrayAsWord64# a1 a2 = GHC.Prim.indexWord8ArrayAsWord64# 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,Int8# #)
readInt8Array# a1 a2 a3 = GHC.Prim.readInt8Array# a1 a2 a3
readInt16Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int16# #)
readInt16Array# a1 a2 a3 = GHC.Prim.readInt16Array# a1 a2 a3
readInt32Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int32# #)
readInt32Array# a1 a2 a3 = GHC.Prim.readInt32Array# a1 a2 a3
readInt64Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int64# #)
readInt64Array# a1 a2 a3 = GHC.Prim.readInt64Array# a1 a2 a3
readWord8Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word8# #)
readWord8Array# a1 a2 a3 = GHC.Prim.readWord8Array# a1 a2 a3
readWord16Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word16# #)
readWord16Array# a1 a2 a3 = GHC.Prim.readWord16Array# a1 a2 a3
readWord32Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word32# #)
readWord32Array# a1 a2 a3 = GHC.Prim.readWord32Array# a1 a2 a3
readWord64Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word64# #)
readWord64Array# a1 a2 a3 = GHC.Prim.readWord64Array# a1 a2 a3
readWord8ArrayAsChar# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Char# #)
readWord8ArrayAsChar# a1 a2 a3 = GHC.Prim.readWord8ArrayAsChar# a1 a2 a3
readWord8ArrayAsWideChar# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Char# #)
readWord8ArrayAsWideChar# a1 a2 a3 = GHC.Prim.readWord8ArrayAsWideChar# a1 a2 a3
readWord8ArrayAsInt# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int# #)
readWord8ArrayAsInt# a1 a2 a3 = GHC.Prim.readWord8ArrayAsInt# a1 a2 a3
readWord8ArrayAsWord# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word# #)
readWord8ArrayAsWord# a1 a2 a3 = GHC.Prim.readWord8ArrayAsWord# a1 a2 a3
readWord8ArrayAsAddr# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Addr# #)
readWord8ArrayAsAddr# a1 a2 a3 = GHC.Prim.readWord8ArrayAsAddr# a1 a2 a3
readWord8ArrayAsFloat# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Float# #)
readWord8ArrayAsFloat# a1 a2 a3 = GHC.Prim.readWord8ArrayAsFloat# a1 a2 a3
readWord8ArrayAsDouble# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Double# #)
readWord8ArrayAsDouble# a1 a2 a3 = GHC.Prim.readWord8ArrayAsDouble# a1 a2 a3
readWord8ArrayAsStablePtr# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,StablePtr# a #)
readWord8ArrayAsStablePtr# a1 a2 a3 = GHC.Prim.readWord8ArrayAsStablePtr# a1 a2 a3
readWord8ArrayAsInt16# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int16# #)
readWord8ArrayAsInt16# a1 a2 a3 = GHC.Prim.readWord8ArrayAsInt16# a1 a2 a3
readWord8ArrayAsInt32# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int32# #)
readWord8ArrayAsInt32# a1 a2 a3 = GHC.Prim.readWord8ArrayAsInt32# a1 a2 a3
readWord8ArrayAsInt64# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int64# #)
readWord8ArrayAsInt64# a1 a2 a3 = GHC.Prim.readWord8ArrayAsInt64# a1 a2 a3
readWord8ArrayAsWord16# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word16# #)
readWord8ArrayAsWord16# a1 a2 a3 = GHC.Prim.readWord8ArrayAsWord16# a1 a2 a3
readWord8ArrayAsWord32# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word32# #)
readWord8ArrayAsWord32# a1 a2 a3 = GHC.Prim.readWord8ArrayAsWord32# a1 a2 a3
readWord8ArrayAsWord64# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word64# #)
readWord8ArrayAsWord64# a1 a2 a3 = GHC.Prim.readWord8ArrayAsWord64# 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# -> Int8# -> State# s -> State# s
writeInt8Array# a1 a2 a3 a4 = GHC.Prim.writeInt8Array# a1 a2 a3 a4
writeInt16Array# :: MutableByteArray# s -> Int# -> Int16# -> State# s -> State# s
writeInt16Array# a1 a2 a3 a4 = GHC.Prim.writeInt16Array# a1 a2 a3 a4
writeInt32Array# :: MutableByteArray# s -> Int# -> Int32# -> State# s -> State# s
writeInt32Array# a1 a2 a3 a4 = GHC.Prim.writeInt32Array# a1 a2 a3 a4
writeInt64Array# :: MutableByteArray# s -> Int# -> Int64# -> State# s -> State# s
writeInt64Array# a1 a2 a3 a4 = GHC.Prim.writeInt64Array# a1 a2 a3 a4
writeWord8Array# :: MutableByteArray# s -> Int# -> Word8# -> State# s -> State# s
writeWord8Array# a1 a2 a3 a4 = GHC.Prim.writeWord8Array# a1 a2 a3 a4
writeWord16Array# :: MutableByteArray# s -> Int# -> Word16# -> State# s -> State# s
writeWord16Array# a1 a2 a3 a4 = GHC.Prim.writeWord16Array# a1 a2 a3 a4
writeWord32Array# :: MutableByteArray# s -> Int# -> Word32# -> State# s -> State# s
writeWord32Array# a1 a2 a3 a4 = GHC.Prim.writeWord32Array# a1 a2 a3 a4
writeWord64Array# :: MutableByteArray# s -> Int# -> Word64# -> State# s -> State# s
writeWord64Array# a1 a2 a3 a4 = GHC.Prim.writeWord64Array# a1 a2 a3 a4
writeWord8ArrayAsChar# :: MutableByteArray# s -> Int# -> Char# -> State# s -> State# s
writeWord8ArrayAsChar# a1 a2 a3 a4 = GHC.Prim.writeWord8ArrayAsChar# a1 a2 a3 a4
writeWord8ArrayAsWideChar# :: MutableByteArray# s -> Int# -> Char# -> State# s -> State# s
writeWord8ArrayAsWideChar# a1 a2 a3 a4 = GHC.Prim.writeWord8ArrayAsWideChar# a1 a2 a3 a4
writeWord8ArrayAsInt# :: MutableByteArray# s -> Int# -> Int# -> State# s -> State# s
writeWord8ArrayAsInt# a1 a2 a3 a4 = GHC.Prim.writeWord8ArrayAsInt# a1 a2 a3 a4
writeWord8ArrayAsWord# :: MutableByteArray# s -> Int# -> Word# -> State# s -> State# s
writeWord8ArrayAsWord# a1 a2 a3 a4 = GHC.Prim.writeWord8ArrayAsWord# a1 a2 a3 a4
writeWord8ArrayAsAddr# :: MutableByteArray# s -> Int# -> Addr# -> State# s -> State# s
writeWord8ArrayAsAddr# a1 a2 a3 a4 = GHC.Prim.writeWord8ArrayAsAddr# a1 a2 a3 a4
writeWord8ArrayAsFloat# :: MutableByteArray# s -> Int# -> Float# -> State# s -> State# s
writeWord8ArrayAsFloat# a1 a2 a3 a4 = GHC.Prim.writeWord8ArrayAsFloat# a1 a2 a3 a4
writeWord8ArrayAsDouble# :: MutableByteArray# s -> Int# -> Double# -> State# s -> State# s
writeWord8ArrayAsDouble# a1 a2 a3 a4 = GHC.Prim.writeWord8ArrayAsDouble# a1 a2 a3 a4
writeWord8ArrayAsStablePtr# :: MutableByteArray# s -> Int# -> StablePtr# a -> State# s -> State# s
writeWord8ArrayAsStablePtr# a1 a2 a3 a4 = GHC.Prim.writeWord8ArrayAsStablePtr# a1 a2 a3 a4
writeWord8ArrayAsInt16# :: MutableByteArray# s -> Int# -> Int16# -> State# s -> State# s
writeWord8ArrayAsInt16# a1 a2 a3 a4 = GHC.Prim.writeWord8ArrayAsInt16# a1 a2 a3 a4
writeWord8ArrayAsInt32# :: MutableByteArray# s -> Int# -> Int32# -> State# s -> State# s
writeWord8ArrayAsInt32# a1 a2 a3 a4 = GHC.Prim.writeWord8ArrayAsInt32# a1 a2 a3 a4
writeWord8ArrayAsInt64# :: MutableByteArray# s -> Int# -> Int64# -> State# s -> State# s
writeWord8ArrayAsInt64# a1 a2 a3 a4 = GHC.Prim.writeWord8ArrayAsInt64# a1 a2 a3 a4
writeWord8ArrayAsWord16# :: MutableByteArray# s -> Int# -> Word16# -> State# s -> State# s
writeWord8ArrayAsWord16# a1 a2 a3 a4 = GHC.Prim.writeWord8ArrayAsWord16# a1 a2 a3 a4
writeWord8ArrayAsWord32# :: MutableByteArray# s -> Int# -> Word32# -> State# s -> State# s
writeWord8ArrayAsWord32# a1 a2 a3 a4 = GHC.Prim.writeWord8ArrayAsWord32# a1 a2 a3 a4
writeWord8ArrayAsWord64# :: MutableByteArray# s -> Int# -> Word64# -> State# s -> State# s
writeWord8ArrayAsWord64# a1 a2 a3 a4 = GHC.Prim.writeWord8ArrayAsWord64# a1 a2 a3 a4
compareByteArrays# :: ByteArray# -> Int# -> ByteArray# -> Int# -> Int# -> Int#
compareByteArrays# a1 a2 a3 a4 a5 = GHC.Prim.compareByteArrays# a1 a2 a3 a4 a5
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
copyByteArrayToAddr# :: ByteArray# -> Int# -> Addr# -> Int# -> State# s -> State# s
copyByteArrayToAddr# a1 a2 a3 a4 a5 = GHC.Prim.copyByteArrayToAddr# a1 a2 a3 a4 a5
copyMutableByteArrayToAddr# :: MutableByteArray# s -> Int# -> Addr# -> Int# -> State# s -> State# s
copyMutableByteArrayToAddr# a1 a2 a3 a4 a5 = GHC.Prim.copyMutableByteArrayToAddr# a1 a2 a3 a4 a5
copyAddrToByteArray# :: Addr# -> MutableByteArray# s -> Int# -> Int# -> State# s -> State# s
copyAddrToByteArray# a1 a2 a3 a4 a5 = GHC.Prim.copyAddrToByteArray# a1 a2 a3 a4 a5
setByteArray# :: MutableByteArray# s -> Int# -> Int# -> Int# -> State# s -> State# s
setByteArray# a1 a2 a3 a4 a5 = GHC.Prim.setByteArray# a1 a2 a3 a4 a5
atomicReadIntArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int# #)
atomicReadIntArray# a1 a2 a3 = GHC.Prim.atomicReadIntArray# a1 a2 a3
atomicWriteIntArray# :: MutableByteArray# s -> Int# -> Int# -> State# s -> State# s
atomicWriteIntArray# a1 a2 a3 a4 = GHC.Prim.atomicWriteIntArray# a1 a2 a3 a4
casIntArray# :: MutableByteArray# s -> Int# -> Int# -> Int# -> State# s -> (# State# s,Int# #)
casIntArray# a1 a2 a3 a4 a5 = GHC.Prim.casIntArray# a1 a2 a3 a4 a5
casInt8Array# :: MutableByteArray# s -> Int# -> Int8# -> Int8# -> State# s -> (# State# s,Int8# #)
casInt8Array# a1 a2 a3 a4 a5 = GHC.Prim.casInt8Array# a1 a2 a3 a4 a5
casInt16Array# :: MutableByteArray# s -> Int# -> Int16# -> Int16# -> State# s -> (# State# s,Int16# #)
casInt16Array# a1 a2 a3 a4 a5 = GHC.Prim.casInt16Array# a1 a2 a3 a4 a5
casInt32Array# :: MutableByteArray# s -> Int# -> Int32# -> Int32# -> State# s -> (# State# s,Int32# #)
casInt32Array# a1 a2 a3 a4 a5 = GHC.Prim.casInt32Array# a1 a2 a3 a4 a5
casInt64Array# :: MutableByteArray# s -> Int# -> Int64# -> Int64# -> State# s -> (# State# s,Int64# #)
casInt64Array# a1 a2 a3 a4 a5 = GHC.Prim.casInt64Array# a1 a2 a3 a4 a5
fetchAddIntArray# :: MutableByteArray# s -> Int# -> Int# -> State# s -> (# State# s,Int# #)
fetchAddIntArray# a1 a2 a3 a4 = GHC.Prim.fetchAddIntArray# a1 a2 a3 a4
fetchSubIntArray# :: MutableByteArray# s -> Int# -> Int# -> State# s -> (# State# s,Int# #)
fetchSubIntArray# a1 a2 a3 a4 = GHC.Prim.fetchSubIntArray# a1 a2 a3 a4
fetchAndIntArray# :: MutableByteArray# s -> Int# -> Int# -> State# s -> (# State# s,Int# #)
fetchAndIntArray# a1 a2 a3 a4 = GHC.Prim.fetchAndIntArray# a1 a2 a3 a4
fetchNandIntArray# :: MutableByteArray# s -> Int# -> Int# -> State# s -> (# State# s,Int# #)
fetchNandIntArray# a1 a2 a3 a4 = GHC.Prim.fetchNandIntArray# a1 a2 a3 a4
fetchOrIntArray# :: MutableByteArray# s -> Int# -> Int# -> State# s -> (# State# s,Int# #)
fetchOrIntArray# a1 a2 a3 a4 = GHC.Prim.fetchOrIntArray# a1 a2 a3 a4
fetchXorIntArray# :: MutableByteArray# s -> Int# -> Int# -> State# s -> (# State# s,Int# #)
fetchXorIntArray# a1 a2 a3 a4 = GHC.Prim.fetchXorIntArray# a1 a2 a3 a4
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
gtAddr# :: Addr# -> Addr# -> Int#
gtAddr# a1 a2 = GHC.Prim.gtAddr# a1 a2
geAddr# :: Addr# -> Addr# -> Int#
geAddr# a1 a2 = GHC.Prim.geAddr# a1 a2
eqAddr# :: Addr# -> Addr# -> Int#
eqAddr# a1 a2 = GHC.Prim.eqAddr# a1 a2
neAddr# :: Addr# -> Addr# -> Int#
neAddr# a1 a2 = GHC.Prim.neAddr# a1 a2
ltAddr# :: Addr# -> Addr# -> Int#
ltAddr# a1 a2 = GHC.Prim.ltAddr# a1 a2
leAddr# :: Addr# -> Addr# -> Int#
leAddr# a1 a2 = GHC.Prim.leAddr# 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# -> Int8#
indexInt8OffAddr# a1 a2 = GHC.Prim.indexInt8OffAddr# a1 a2
indexInt16OffAddr# :: Addr# -> Int# -> Int16#
indexInt16OffAddr# a1 a2 = GHC.Prim.indexInt16OffAddr# a1 a2
indexInt32OffAddr# :: Addr# -> Int# -> Int32#
indexInt32OffAddr# a1 a2 = GHC.Prim.indexInt32OffAddr# a1 a2
indexInt64OffAddr# :: Addr# -> Int# -> Int64#
indexInt64OffAddr# a1 a2 = GHC.Prim.indexInt64OffAddr# a1 a2
indexWord8OffAddr# :: Addr# -> Int# -> Word8#
indexWord8OffAddr# a1 a2 = GHC.Prim.indexWord8OffAddr# a1 a2
indexWord16OffAddr# :: Addr# -> Int# -> Word16#
indexWord16OffAddr# a1 a2 = GHC.Prim.indexWord16OffAddr# a1 a2
indexWord32OffAddr# :: Addr# -> Int# -> Word32#
indexWord32OffAddr# a1 a2 = GHC.Prim.indexWord32OffAddr# a1 a2
indexWord64OffAddr# :: Addr# -> Int# -> Word64#
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,Int8# #)
readInt8OffAddr# a1 a2 a3 = GHC.Prim.readInt8OffAddr# a1 a2 a3
readInt16OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int16# #)
readInt16OffAddr# a1 a2 a3 = GHC.Prim.readInt16OffAddr# a1 a2 a3
readInt32OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int32# #)
readInt32OffAddr# a1 a2 a3 = GHC.Prim.readInt32OffAddr# a1 a2 a3
readInt64OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int64# #)
readInt64OffAddr# a1 a2 a3 = GHC.Prim.readInt64OffAddr# a1 a2 a3
readWord8OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word8# #)
readWord8OffAddr# a1 a2 a3 = GHC.Prim.readWord8OffAddr# a1 a2 a3
readWord16OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word16# #)
readWord16OffAddr# a1 a2 a3 = GHC.Prim.readWord16OffAddr# a1 a2 a3
readWord32OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word32# #)
readWord32OffAddr# a1 a2 a3 = GHC.Prim.readWord32OffAddr# a1 a2 a3
readWord64OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word64# #)
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# -> Int8# -> State# s -> State# s
writeInt8OffAddr# a1 a2 a3 a4 = GHC.Prim.writeInt8OffAddr# a1 a2 a3 a4
writeInt16OffAddr# :: Addr# -> Int# -> Int16# -> State# s -> State# s
writeInt16OffAddr# a1 a2 a3 a4 = GHC.Prim.writeInt16OffAddr# a1 a2 a3 a4
writeInt32OffAddr# :: Addr# -> Int# -> Int32# -> State# s -> State# s
writeInt32OffAddr# a1 a2 a3 a4 = GHC.Prim.writeInt32OffAddr# a1 a2 a3 a4
writeInt64OffAddr# :: Addr# -> Int# -> Int64# -> State# s -> State# s
writeInt64OffAddr# a1 a2 a3 a4 = GHC.Prim.writeInt64OffAddr# a1 a2 a3 a4
writeWord8OffAddr# :: Addr# -> Int# -> Word8# -> State# s -> State# s
writeWord8OffAddr# a1 a2 a3 a4 = GHC.Prim.writeWord8OffAddr# a1 a2 a3 a4
writeWord16OffAddr# :: Addr# -> Int# -> Word16# -> State# s -> State# s
writeWord16OffAddr# a1 a2 a3 a4 = GHC.Prim.writeWord16OffAddr# a1 a2 a3 a4
writeWord32OffAddr# :: Addr# -> Int# -> Word32# -> State# s -> State# s
writeWord32OffAddr# a1 a2 a3 a4 = GHC.Prim.writeWord32OffAddr# a1 a2 a3 a4
writeWord64OffAddr# :: Addr# -> Int# -> Word64# -> State# s -> State# s
writeWord64OffAddr# a1 a2 a3 a4 = GHC.Prim.writeWord64OffAddr# a1 a2 a3 a4
atomicExchangeAddrAddr# :: Addr# -> Addr# -> State# s -> (# State# s,Addr# #)
atomicExchangeAddrAddr# a1 a2 a3 = GHC.Prim.atomicExchangeAddrAddr# a1 a2 a3
atomicExchangeWordAddr# :: Addr# -> Word# -> State# s -> (# State# s,Word# #)
atomicExchangeWordAddr# a1 a2 a3 = GHC.Prim.atomicExchangeWordAddr# a1 a2 a3
atomicCasAddrAddr# :: Addr# -> Addr# -> Addr# -> State# s -> (# State# s,Addr# #)
atomicCasAddrAddr# a1 a2 a3 a4 = GHC.Prim.atomicCasAddrAddr# a1 a2 a3 a4
atomicCasWordAddr# :: Addr# -> Word# -> Word# -> State# s -> (# State# s,Word# #)
atomicCasWordAddr# a1 a2 a3 a4 = GHC.Prim.atomicCasWordAddr# a1 a2 a3 a4
atomicCasWord8Addr# :: Addr# -> Word8# -> Word8# -> State# s -> (# State# s,Word8# #)
atomicCasWord8Addr# a1 a2 a3 a4 = GHC.Prim.atomicCasWord8Addr# a1 a2 a3 a4
atomicCasWord16Addr# :: Addr# -> Word16# -> Word16# -> State# s -> (# State# s,Word16# #)
atomicCasWord16Addr# a1 a2 a3 a4 = GHC.Prim.atomicCasWord16Addr# a1 a2 a3 a4
atomicCasWord32Addr# :: Addr# -> Word32# -> Word32# -> State# s -> (# State# s,Word32# #)
atomicCasWord32Addr# a1 a2 a3 a4 = GHC.Prim.atomicCasWord32Addr# a1 a2 a3 a4
atomicCasWord64Addr# :: Addr# -> Word64# -> Word64# -> State# s -> (# State# s,Word64# #)
atomicCasWord64Addr# a1 a2 a3 a4 = GHC.Prim.atomicCasWord64Addr# a1 a2 a3 a4
fetchAddWordAddr# :: Addr# -> Word# -> State# s -> (# State# s,Word# #)
fetchAddWordAddr# a1 a2 a3 = GHC.Prim.fetchAddWordAddr# a1 a2 a3
fetchSubWordAddr# :: Addr# -> Word# -> State# s -> (# State# s,Word# #)
fetchSubWordAddr# a1 a2 a3 = GHC.Prim.fetchSubWordAddr# a1 a2 a3
fetchAndWordAddr# :: Addr# -> Word# -> State# s -> (# State# s,Word# #)
fetchAndWordAddr# a1 a2 a3 = GHC.Prim.fetchAndWordAddr# a1 a2 a3
fetchNandWordAddr# :: Addr# -> Word# -> State# s -> (# State# s,Word# #)
fetchNandWordAddr# a1 a2 a3 = GHC.Prim.fetchNandWordAddr# a1 a2 a3
fetchOrWordAddr# :: Addr# -> Word# -> State# s -> (# State# s,Word# #)
fetchOrWordAddr# a1 a2 a3 = GHC.Prim.fetchOrWordAddr# a1 a2 a3
fetchXorWordAddr# :: Addr# -> Word# -> State# s -> (# State# s,Word# #)
fetchXorWordAddr# a1 a2 a3 = GHC.Prim.fetchXorWordAddr# a1 a2 a3
atomicReadWordAddr# :: Addr# -> State# s -> (# State# s,Word# #)
atomicReadWordAddr# a1 a2 = GHC.Prim.atomicReadWordAddr# a1 a2
atomicWriteWordAddr# :: Addr# -> Word# -> State# s -> State# s
atomicWriteWordAddr# a1 a2 a3 = GHC.Prim.atomicWriteWordAddr# a1 a2 a3
newMutVar# :: v -> State# s -> (# State# s,MutVar# s v #)
newMutVar# a1 a2 = GHC.Prim.newMutVar# a1 a2
readMutVar# :: MutVar# s v -> State# s -> (# State# s,v #)
readMutVar# a1 a2 = GHC.Prim.readMutVar# a1 a2
writeMutVar# :: MutVar# s v -> v -> State# s -> State# s
writeMutVar# a1 a2 a3 = GHC.Prim.writeMutVar# a1 a2 a3
atomicModifyMutVar2# :: MutVar# s a -> (a -> c) -> State# s -> (# State# s,a,c #)
atomicModifyMutVar2# a1 a2 a3 = GHC.Prim.atomicModifyMutVar2# a1 a2 a3
atomicModifyMutVar_# :: MutVar# s a -> (a -> a) -> State# s -> (# State# s,a,a #)
atomicModifyMutVar_# a1 a2 a3 = GHC.Prim.atomicModifyMutVar_# a1 a2 a3
casMutVar# :: MutVar# s v -> v -> v -> State# s -> (# State# s,Int#,v #)
casMutVar# a1 a2 a3 a4 = GHC.Prim.casMutVar# a1 a2 a3 a4
catch# :: (State# (RealWorld) -> (# State# (RealWorld),o #)) -> (w -> State# (RealWorld) -> (# State# (RealWorld),o #)) -> State# (RealWorld) -> (# State# (RealWorld),o #)
catch# a1 a2 a3 = GHC.Prim.catch# a1 a2 a3
raise# :: v -> p
raise# a1 = GHC.Prim.raise# a1
raiseIO# :: v -> State# (RealWorld) -> (# State# (RealWorld),p #)
raiseIO# a1 a2 = GHC.Prim.raiseIO# a1 a2
maskAsyncExceptions# :: (State# (RealWorld) -> (# State# (RealWorld),o #)) -> State# (RealWorld) -> (# State# (RealWorld),o #)
maskAsyncExceptions# a1 a2 = GHC.Prim.maskAsyncExceptions# a1 a2
maskUninterruptible# :: (State# (RealWorld) -> (# State# (RealWorld),o #)) -> State# (RealWorld) -> (# State# (RealWorld),o #)
maskUninterruptible# a1 a2 = GHC.Prim.maskUninterruptible# a1 a2
unmaskAsyncExceptions# :: (State# (RealWorld) -> (# State# (RealWorld),o #)) -> State# (RealWorld) -> (# State# (RealWorld),o #)
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),v #)) -> State# (RealWorld) -> (# State# (RealWorld),v #)
atomically# a1 a2 = GHC.Prim.atomically# a1 a2
retry# :: State# (RealWorld) -> (# State# (RealWorld),v #)
retry# a1 = GHC.Prim.retry# a1
catchRetry# :: (State# (RealWorld) -> (# State# (RealWorld),v #)) -> (State# (RealWorld) -> (# State# (RealWorld),v #)) -> State# (RealWorld) -> (# State# (RealWorld),v #)
catchRetry# a1 a2 a3 = GHC.Prim.catchRetry# a1 a2 a3
catchSTM# :: (State# (RealWorld) -> (# State# (RealWorld),v #)) -> (b -> State# (RealWorld) -> (# State# (RealWorld),v #)) -> State# (RealWorld) -> (# State# (RealWorld),v #)
catchSTM# a1 a2 a3 = GHC.Prim.catchSTM# a1 a2 a3
newTVar# :: v -> State# s -> (# State# s,TVar# s v #)
newTVar# a1 a2 = GHC.Prim.newTVar# a1 a2
readTVar# :: TVar# s v -> State# s -> (# State# s,v #)
readTVar# a1 a2 = GHC.Prim.readTVar# a1 a2
readTVarIO# :: TVar# s v -> State# s -> (# State# s,v #)
readTVarIO# a1 a2 = GHC.Prim.readTVarIO# a1 a2
writeTVar# :: TVar# s v -> v -> State# s -> State# s
writeTVar# a1 a2 a3 = GHC.Prim.writeTVar# a1 a2 a3
newMVar# :: State# s -> (# State# s,MVar# s v #)
newMVar# a1 = GHC.Prim.newMVar# a1
takeMVar# :: MVar# s v -> State# s -> (# State# s,v #)
takeMVar# a1 a2 = GHC.Prim.takeMVar# a1 a2
tryTakeMVar# :: MVar# s v -> State# s -> (# State# s,Int#,v #)
tryTakeMVar# a1 a2 = GHC.Prim.tryTakeMVar# a1 a2
putMVar# :: MVar# s v -> v -> State# s -> State# s
putMVar# a1 a2 a3 = GHC.Prim.putMVar# a1 a2 a3
tryPutMVar# :: MVar# s v -> v -> State# s -> (# State# s,Int# #)
tryPutMVar# a1 a2 a3 = GHC.Prim.tryPutMVar# a1 a2 a3
readMVar# :: MVar# s v -> State# s -> (# State# s,v #)
readMVar# a1 a2 = GHC.Prim.readMVar# a1 a2
tryReadMVar# :: MVar# s v -> State# s -> (# State# s,Int#,v #)
tryReadMVar# a1 a2 = GHC.Prim.tryReadMVar# a1 a2
isEmptyMVar# :: MVar# s v -> State# s -> (# State# s,Int# #)
isEmptyMVar# a1 a2 = GHC.Prim.isEmptyMVar# a1 a2
newIOPort# :: State# s -> (# State# s,IOPort# s v #)
newIOPort# a1 = GHC.Prim.newIOPort# a1
readIOPort# :: IOPort# s v -> State# s -> (# State# s,v #)
readIOPort# a1 a2 = GHC.Prim.readIOPort# a1 a2
writeIOPort# :: IOPort# s v -> v -> State# s -> (# State# s,Int# #)
writeIOPort# a1 a2 a3 = GHC.Prim.writeIOPort# a1 a2 a3
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# :: (State# (RealWorld) -> (# State# (RealWorld),o #)) -> State# (RealWorld) -> (# State# (RealWorld),ThreadId# #)
fork# a1 a2 = GHC.Prim.fork# a1 a2
forkOn# :: Int# -> (State# (RealWorld) -> (# State# (RealWorld),o #)) -> 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# s -> State# s
noDuplicate# a1 = GHC.Prim.noDuplicate# a1
threadStatus# :: ThreadId# -> State# (RealWorld) -> (# State# (RealWorld),Int#,Int#,Int# #)
threadStatus# a1 a2 = GHC.Prim.threadStatus# a1 a2
mkWeak# :: v -> w -> (State# (RealWorld) -> (# State# (RealWorld),c #)) -> State# (RealWorld) -> (# State# (RealWorld),Weak# w #)
mkWeak# a1 a2 a3 a4 = GHC.Prim.mkWeak# a1 a2 a3 a4
mkWeakNoFinalizer# :: v -> w -> State# (RealWorld) -> (# State# (RealWorld),Weak# w #)
mkWeakNoFinalizer# a1 a2 a3 = GHC.Prim.mkWeakNoFinalizer# a1 a2 a3
addCFinalizerToWeak# :: Addr# -> Addr# -> Int# -> Addr# -> Weak# w -> State# (RealWorld) -> (# State# (RealWorld),Int# #)
addCFinalizerToWeak# a1 a2 a3 a4 a5 a6 = GHC.Prim.addCFinalizerToWeak# a1 a2 a3 a4 a5 a6
deRefWeak# :: Weak# v -> State# (RealWorld) -> (# State# (RealWorld),Int#,v #)
deRefWeak# a1 a2 = GHC.Prim.deRefWeak# a1 a2
finalizeWeak# :: Weak# v -> State# (RealWorld) -> (# State# (RealWorld),Int#,State# (RealWorld) -> (# State# (RealWorld),b #) #)
finalizeWeak# a1 a2 = GHC.Prim.finalizeWeak# a1 a2
touch# :: v -> State# (RealWorld) -> State# (RealWorld)
touch# a1 a2 = GHC.Prim.touch# a1 a2
makeStablePtr# :: v -> State# (RealWorld) -> (# State# (RealWorld),StablePtr# v #)
makeStablePtr# a1 a2 = GHC.Prim.makeStablePtr# a1 a2
deRefStablePtr# :: StablePtr# v -> State# (RealWorld) -> (# State# (RealWorld),v #)
deRefStablePtr# a1 a2 = GHC.Prim.deRefStablePtr# a1 a2
eqStablePtr# :: StablePtr# v -> StablePtr# v -> Int#
eqStablePtr# a1 a2 = GHC.Prim.eqStablePtr# a1 a2
makeStableName# :: v -> State# (RealWorld) -> (# State# (RealWorld),StableName# v #)
makeStableName# a1 a2 = GHC.Prim.makeStableName# a1 a2
stableNameToInt# :: StableName# v -> Int#
stableNameToInt# a1 = GHC.Prim.stableNameToInt# a1
compactNew# :: Word# -> State# (RealWorld) -> (# State# (RealWorld),Compact# #)
compactNew# a1 a2 = GHC.Prim.compactNew# a1 a2
compactResize# :: Compact# -> Word# -> State# (RealWorld) -> State# (RealWorld)
compactResize# a1 a2 a3 = GHC.Prim.compactResize# a1 a2 a3
compactContains# :: Compact# -> a -> State# (RealWorld) -> (# State# (RealWorld),Int# #)
compactContains# a1 a2 a3 = GHC.Prim.compactContains# a1 a2 a3
compactContainsAny# :: a -> State# (RealWorld) -> (# State# (RealWorld),Int# #)
compactContainsAny# a1 a2 = GHC.Prim.compactContainsAny# a1 a2
compactGetFirstBlock# :: Compact# -> State# (RealWorld) -> (# State# (RealWorld),Addr#,Word# #)
compactGetFirstBlock# a1 a2 = GHC.Prim.compactGetFirstBlock# a1 a2
compactGetNextBlock# :: Compact# -> Addr# -> State# (RealWorld) -> (# State# (RealWorld),Addr#,Word# #)
compactGetNextBlock# a1 a2 a3 = GHC.Prim.compactGetNextBlock# a1 a2 a3
compactAllocateBlock# :: Word# -> Addr# -> State# (RealWorld) -> (# State# (RealWorld),Addr# #)
compactAllocateBlock# a1 a2 a3 = GHC.Prim.compactAllocateBlock# a1 a2 a3
compactFixupPointers# :: Addr# -> Addr# -> State# (RealWorld) -> (# State# (RealWorld),Compact#,Addr# #)
compactFixupPointers# a1 a2 a3 = GHC.Prim.compactFixupPointers# a1 a2 a3
compactAdd# :: Compact# -> a -> State# (RealWorld) -> (# State# (RealWorld),a #)
compactAdd# a1 a2 a3 = GHC.Prim.compactAdd# a1 a2 a3
compactAddWithSharing# :: Compact# -> a -> State# (RealWorld) -> (# State# (RealWorld),a #)
compactAddWithSharing# a1 a2 a3 = GHC.Prim.compactAddWithSharing# a1 a2 a3
compactSize# :: Compact# -> State# (RealWorld) -> (# State# (RealWorld),Word# #)
compactSize# a1 a2 = GHC.Prim.compactSize# a1 a2
reallyUnsafePtrEquality# :: v -> w -> Int#
reallyUnsafePtrEquality# a1 a2 = GHC.Prim.reallyUnsafePtrEquality# a1 a2
par# :: a -> Int#
par# a1 = GHC.Prim.par# a1
spark# :: a -> State# s -> (# State# s,a #)
spark# a1 a2 = GHC.Prim.spark# a1 a2
seq# :: a -> State# s -> (# State# s,a #)
seq# a1 a2 = GHC.Prim.seq# 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
keepAlive# :: v -> State# (RealWorld) -> (State# (RealWorld) -> p) -> p
keepAlive# a1 a2 a3 = GHC.Prim.keepAlive# a1 a2 a3
dataToTag# :: a -> Int#
dataToTag# a1 = GHC.Prim.dataToTag# a1
addrToAny# :: Addr# -> (# a #)
addrToAny# a1 = GHC.Prim.addrToAny# a1
anyToAddr# :: a -> State# (RealWorld) -> (# State# (RealWorld),Addr# #)
anyToAddr# a1 a2 = GHC.Prim.anyToAddr# a1 a2
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#,ByteArray#,Array# b #)
unpackClosure# a1 = GHC.Prim.unpackClosure# a1
closureSize# :: a -> Int#
closureSize# a1 = GHC.Prim.closureSize# 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
clearCCS# :: (State# s -> (# State# s,a #)) -> State# s -> (# State# s,a #)
clearCCS# a1 a2 = GHC.Prim.clearCCS# a1 a2
whereFrom# :: a -> State# s -> (# State# s,Addr# #)
whereFrom# a1 a2 = GHC.Prim.whereFrom# a1 a2
traceEvent# :: Addr# -> State# s -> State# s
traceEvent# a1 a2 = GHC.Prim.traceEvent# a1 a2
traceBinaryEvent# :: Addr# -> Int# -> State# s -> State# s
traceBinaryEvent# a1 a2 a3 = GHC.Prim.traceBinaryEvent# a1 a2 a3
traceMarker# :: Addr# -> State# s -> State# s
traceMarker# a1 a2 = GHC.Prim.traceMarker# a1 a2
setThreadAllocationCounter# :: Int64# -> State# (RealWorld) -> State# (RealWorld)
setThreadAllocationCounter# a1 a2 = GHC.Prim.setThreadAllocationCounter# a1 a2
prefetchByteArray3# :: ByteArray# -> Int# -> State# s -> State# s
prefetchByteArray3# a1 a2 a3 = GHC.Prim.prefetchByteArray3# a1 a2 a3
prefetchMutableByteArray3# :: MutableByteArray# s -> Int# -> State# s -> State# s
prefetchMutableByteArray3# a1 a2 a3 = GHC.Prim.prefetchMutableByteArray3# a1 a2 a3
prefetchAddr3# :: Addr# -> Int# -> State# s -> State# s
prefetchAddr3# a1 a2 a3 = GHC.Prim.prefetchAddr3# a1 a2 a3
prefetchValue3# :: a -> State# s -> State# s
prefetchValue3# a1 a2 = GHC.Prim.prefetchValue3# a1 a2
prefetchByteArray2# :: ByteArray# -> Int# -> State# s -> State# s
prefetchByteArray2# a1 a2 a3 = GHC.Prim.prefetchByteArray2# a1 a2 a3
prefetchMutableByteArray2# :: MutableByteArray# s -> Int# -> State# s -> State# s
prefetchMutableByteArray2# a1 a2 a3 = GHC.Prim.prefetchMutableByteArray2# a1 a2 a3
prefetchAddr2# :: Addr# -> Int# -> State# s -> State# s
prefetchAddr2# a1 a2 a3 = GHC.Prim.prefetchAddr2# a1 a2 a3
prefetchValue2# :: a -> State# s -> State# s
prefetchValue2# a1 a2 = GHC.Prim.prefetchValue2# a1 a2
prefetchByteArray1# :: ByteArray# -> Int# -> State# s -> State# s
prefetchByteArray1# a1 a2 a3 = GHC.Prim.prefetchByteArray1# a1 a2 a3
prefetchMutableByteArray1# :: MutableByteArray# s -> Int# -> State# s -> State# s
prefetchMutableByteArray1# a1 a2 a3 = GHC.Prim.prefetchMutableByteArray1# a1 a2 a3
prefetchAddr1# :: Addr# -> Int# -> State# s -> State# s
prefetchAddr1# a1 a2 a3 = GHC.Prim.prefetchAddr1# a1 a2 a3
prefetchValue1# :: a -> State# s -> State# s
prefetchValue1# a1 a2 = GHC.Prim.prefetchValue1# a1 a2
prefetchByteArray0# :: ByteArray# -> Int# -> State# s -> State# s
prefetchByteArray0# a1 a2 a3 = GHC.Prim.prefetchByteArray0# a1 a2 a3
prefetchMutableByteArray0# :: MutableByteArray# s -> Int# -> State# s -> State# s
prefetchMutableByteArray0# a1 a2 a3 = GHC.Prim.prefetchMutableByteArray0# a1 a2 a3
prefetchAddr0# :: Addr# -> Int# -> State# s -> State# s
prefetchAddr0# a1 a2 a3 = GHC.Prim.prefetchAddr0# a1 a2 a3
prefetchValue0# :: a -> State# s -> State# s
prefetchValue0# a1 a2 = GHC.Prim.prefetchValue0# a1 a2