diff --git a/GHC/CString.hs b/GHC/CString.hs new file mode 100644 --- /dev/null +++ b/GHC/CString.hs @@ -0,0 +1,122 @@ +{-# LANGUAGE MagicHash, NoImplicitPrelude, BangPatterns #-} +----------------------------------------------------------------------------- +-- | +-- Module : GHC.CString +-- Copyright : (c) The University of Glasgow 2011 +-- License : see libraries/ghc-prim/LICENSE +-- +-- Maintainer : cvs-ghc@haskell.org +-- Stability : internal +-- Portability : non-portable (GHC Extensions) +-- +-- GHC C strings definitions (previously in GHC.Base). +-- Use GHC.Exts from the base package instead of importing this +-- module directly. +-- +----------------------------------------------------------------------------- + +module GHC.CString ( + unpackCString#, unpackAppendCString#, unpackFoldrCString#, + unpackCStringUtf8#, unpackNBytes# + ) where + +import GHC.Types +import GHC.Prim + +----------------------------------------------------------------------------- +-- Unpacking C strings} +----------------------------------------------------------------------------- + +-- This code is needed for virtually all programs, since it's used for +-- unpacking the strings of error messages. + +-- Used to be in GHC.Base, but was moved to ghc-prim because the new generics +-- stuff uses Strings in the representation, so to give representations for +-- ghc-prim types we need unpackCString# + +unpackCString# :: Addr# -> [Char] +{-# NOINLINE unpackCString# #-} + -- There's really no point in inlining this, ever, as the loop doesn't + -- specialise in an interesting But it's pretty small, so there's a danger + -- that it'll be inlined at every literal, which is a waste +unpackCString# addr + = unpack 0# + where + unpack nh + | isTrue# (ch `eqChar#` '\0'#) = [] + | True = C# ch : unpack (nh +# 1#) + where + !ch = indexCharOffAddr# addr nh + +unpackAppendCString# :: Addr# -> [Char] -> [Char] +{-# NOINLINE unpackAppendCString# #-} + -- See the NOINLINE note on unpackCString# +unpackAppendCString# addr rest + = unpack 0# + where + unpack nh + | isTrue# (ch `eqChar#` '\0'#) = rest + | True = C# ch : unpack (nh +# 1#) + where + !ch = indexCharOffAddr# addr nh + +unpackFoldrCString# :: Addr# -> (Char -> a -> a) -> a -> a + +-- Usually the unpack-list rule turns unpackFoldrCString# into unpackCString# + +-- It also has a BuiltInRule in PrelRules.lhs: +-- unpackFoldrCString# "foo" c (unpackFoldrCString# "baz" c n) +-- = unpackFoldrCString# "foobaz" c n + +{-# NOINLINE unpackFoldrCString# #-} +-- At one stage I had NOINLINE [0] on the grounds that, unlike +-- unpackCString#, there *is* some point in inlining +-- unpackFoldrCString#, because we get better code for the +-- higher-order function call. BUT there may be a lot of +-- literal strings, and making a separate 'unpack' loop for +-- each is highly gratuitous. See nofib/real/anna/PrettyPrint. + +unpackFoldrCString# addr f z + = unpack 0# + where + unpack nh + | isTrue# (ch `eqChar#` '\0'#) = z + | True = C# ch `f` unpack (nh +# 1#) + where + !ch = indexCharOffAddr# addr nh + +unpackCStringUtf8# :: Addr# -> [Char] +unpackCStringUtf8# addr + = unpack 0# + where + unpack nh + | isTrue# (ch `eqChar#` '\0'# ) = [] + | isTrue# (ch `leChar#` '\x7F'#) = C# ch : unpack (nh +# 1#) + | isTrue# (ch `leChar#` '\xDF'#) = + C# (chr# (((ord# ch -# 0xC0#) `uncheckedIShiftL#` 6#) +# + (ord# (indexCharOffAddr# addr (nh +# 1#)) -# 0x80#))) : + unpack (nh +# 2#) + | isTrue# (ch `leChar#` '\xEF'#) = + C# (chr# (((ord# ch -# 0xE0#) `uncheckedIShiftL#` 12#) +# + ((ord# (indexCharOffAddr# addr (nh +# 1#)) -# 0x80#) `uncheckedIShiftL#` 6#) +# + (ord# (indexCharOffAddr# addr (nh +# 2#)) -# 0x80#))) : + unpack (nh +# 3#) + | True = + C# (chr# (((ord# ch -# 0xF0#) `uncheckedIShiftL#` 18#) +# + ((ord# (indexCharOffAddr# addr (nh +# 1#)) -# 0x80#) `uncheckedIShiftL#` 12#) +# + ((ord# (indexCharOffAddr# addr (nh +# 2#)) -# 0x80#) `uncheckedIShiftL#` 6#) +# + (ord# (indexCharOffAddr# addr (nh +# 3#)) -# 0x80#))) : + unpack (nh +# 4#) + where + !ch = indexCharOffAddr# addr nh + +unpackNBytes# :: Addr# -> Int# -> [Char] +unpackNBytes# _addr 0# = [] +unpackNBytes# addr len# = unpack [] (len# -# 1#) + where + unpack acc i# + | isTrue# (i# <# 0#) = acc + | True = + case indexCharOffAddr# addr i# of + ch -> unpack (C# ch : acc) (i# -# 1#) + diff --git a/GHC/Classes.hs b/GHC/Classes.hs new file mode 100644 --- /dev/null +++ b/GHC/Classes.hs @@ -0,0 +1,296 @@ +{-# LANGUAGE Trustworthy #-} +{-# LANGUAGE NoImplicitPrelude, MagicHash, StandaloneDeriving, BangPatterns #-} +{-# OPTIONS_GHC -fno-warn-unused-imports #-} +-- XXX -fno-warn-unused-imports needed for the GHC.Tuple import below. Sigh. +{-# OPTIONS_HADDOCK hide #-} +----------------------------------------------------------------------------- +-- | +-- Module : GHC.Classes +-- Copyright : (c) The University of Glasgow, 1992-2002 +-- License : see libraries/base/LICENSE +-- +-- Maintainer : cvs-ghc@haskell.org +-- Stability : internal +-- Portability : non-portable (GHC extensions) +-- +-- Basic classes. +-- +----------------------------------------------------------------------------- + +-- #hide +module GHC.Classes where + +-- GHC.Magic is used in some derived instances +import GHC.Magic () +import GHC.Prim +import GHC.Tuple +import GHC.Types + + +infix 4 ==, /=, <, <=, >=, > +infixr 3 && +infixr 2 || + +default () -- Double isn't available yet + +-- | The 'Eq' class defines equality ('==') and inequality ('/='). +-- All the basic datatypes exported by the "Prelude" are instances of 'Eq', +-- and 'Eq' may be derived for any datatype whose constituents are also +-- instances of 'Eq'. +-- +-- Minimal complete definition: either '==' or '/='. +-- +class Eq a where + (==), (/=) :: a -> a -> Bool + + {-# INLINE (/=) #-} + {-# INLINE (==) #-} + x /= y = not (x == y) + x == y = not (x /= y) + {-# MINIMAL (==) | (/=) #-} + +deriving instance Eq () +deriving instance (Eq a, Eq b) => Eq (a, b) +deriving instance (Eq a, Eq b, Eq c) => Eq (a, b, c) +deriving instance (Eq a, Eq b, Eq c, Eq d) => Eq (a, b, c, d) +deriving instance (Eq a, Eq b, Eq c, Eq d, Eq e) => Eq (a, b, c, d, e) +deriving instance (Eq a, Eq b, Eq c, Eq d, Eq e, Eq f) + => Eq (a, b, c, d, e, f) +deriving instance (Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g) + => Eq (a, b, c, d, e, f, g) +deriving instance (Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, + Eq h) + => Eq (a, b, c, d, e, f, g, h) +deriving instance (Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, + Eq h, Eq i) + => Eq (a, b, c, d, e, f, g, h, i) +deriving instance (Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, + Eq h, Eq i, Eq j) + => Eq (a, b, c, d, e, f, g, h, i, j) +deriving instance (Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, + Eq h, Eq i, Eq j, Eq k) + => Eq (a, b, c, d, e, f, g, h, i, j, k) +deriving instance (Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, + Eq h, Eq i, Eq j, Eq k, Eq l) + => Eq (a, b, c, d, e, f, g, h, i, j, k, l) +deriving instance (Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, + Eq h, Eq i, Eq j, Eq k, Eq l, Eq m) + => Eq (a, b, c, d, e, f, g, h, i, j, k, l, m) +deriving instance (Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, + Eq h, Eq i, Eq j, Eq k, Eq l, Eq m, Eq n) + => Eq (a, b, c, d, e, f, g, h, i, j, k, l, m, n) +deriving instance (Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, + Eq h, Eq i, Eq j, Eq k, Eq l, Eq m, Eq n, Eq o) + => Eq (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) + +instance (Eq a) => Eq [a] where + {-# SPECIALISE instance Eq [Char] #-} + [] == [] = True + (x:xs) == (y:ys) = x == y && xs == ys + _xs == _ys = False + +deriving instance Eq Bool +deriving instance Eq Ordering +deriving instance Eq Word + +instance Eq Char where + (C# c1) == (C# c2) = isTrue# (c1 `eqChar#` c2) + (C# c1) /= (C# c2) = isTrue# (c1 `neChar#` c2) + +instance Eq Float where + (F# x) == (F# y) = isTrue# (x `eqFloat#` y) + +instance Eq Double where + (D# x) == (D# y) = isTrue# (x ==## y) + +instance Eq Int where + (==) = eqInt + (/=) = neInt + +{-# INLINE eqInt #-} +{-# INLINE neInt #-} +eqInt, neInt :: Int -> Int -> Bool +(I# x) `eqInt` (I# y) = isTrue# (x ==# y) +(I# x) `neInt` (I# y) = isTrue# (x /=# y) + +-- | The 'Ord' class is used for totally ordered datatypes. +-- +-- Instances of 'Ord' can be derived for any user-defined +-- datatype whose constituent types are in 'Ord'. The declared order +-- of the constructors in the data declaration determines the ordering +-- in derived 'Ord' instances. The 'Ordering' datatype allows a single +-- comparison to determine the precise ordering of two objects. +-- +-- Minimal complete definition: either 'compare' or '<='. +-- Using 'compare' can be more efficient for complex types. +-- +class (Eq a) => Ord a where + compare :: a -> a -> Ordering + (<), (<=), (>), (>=) :: a -> a -> Bool + max, min :: a -> a -> a + + compare x y = if x == y then EQ + -- NB: must be '<=' not '<' to validate the + -- above claim about the minimal things that + -- can be defined for an instance of Ord: + else if x <= y then LT + else GT + + x < y = case compare x y of { LT -> True; _ -> False } + x <= y = case compare x y of { GT -> False; _ -> True } + x > y = case compare x y of { GT -> True; _ -> False } + x >= y = case compare x y of { LT -> False; _ -> True } + + -- These two default methods use '<=' rather than 'compare' + -- because the latter is often more expensive + max x y = if x <= y then y else x + min x y = if x <= y then x else y + {-# MINIMAL compare | (<=) #-} + +deriving instance Ord () +deriving instance (Ord a, Ord b) => Ord (a, b) +deriving instance (Ord a, Ord b, Ord c) => Ord (a, b, c) +deriving instance (Ord a, Ord b, Ord c, Ord d) => Ord (a, b, c, d) +deriving instance (Ord a, Ord b, Ord c, Ord d, Ord e) => Ord (a, b, c, d, e) +deriving instance (Ord a, Ord b, Ord c, Ord d, Ord e, Ord f) + => Ord (a, b, c, d, e, f) +deriving instance (Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g) + => Ord (a, b, c, d, e, f, g) +deriving instance (Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, + Ord h) + => Ord (a, b, c, d, e, f, g, h) +deriving instance (Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, + Ord h, Ord i) + => Ord (a, b, c, d, e, f, g, h, i) +deriving instance (Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, + Ord h, Ord i, Ord j) + => Ord (a, b, c, d, e, f, g, h, i, j) +deriving instance (Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, + Ord h, Ord i, Ord j, Ord k) + => Ord (a, b, c, d, e, f, g, h, i, j, k) +deriving instance (Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, + Ord h, Ord i, Ord j, Ord k, Ord l) + => Ord (a, b, c, d, e, f, g, h, i, j, k, l) +deriving instance (Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, + Ord h, Ord i, Ord j, Ord k, Ord l, Ord m) + => Ord (a, b, c, d, e, f, g, h, i, j, k, l, m) +deriving instance (Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, + Ord h, Ord i, Ord j, Ord k, Ord l, Ord m, Ord n) + => Ord (a, b, c, d, e, f, g, h, i, j, k, l, m, n) +deriving instance (Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, + Ord h, Ord i, Ord j, Ord k, Ord l, Ord m, Ord n, Ord o) + => Ord (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) + +instance (Ord a) => Ord [a] where + {-# SPECIALISE instance Ord [Char] #-} + compare [] [] = EQ + compare [] (_:_) = LT + compare (_:_) [] = GT + compare (x:xs) (y:ys) = case compare x y of + EQ -> compare xs ys + other -> other + +deriving instance Ord Bool +deriving instance Ord Ordering +deriving instance Ord Word + +-- We don't use deriving for Ord Char, because for Ord the derived +-- instance defines only compare, which takes two primops. Then +-- '>' uses compare, and therefore takes two primops instead of one. +instance Ord Char where + (C# c1) > (C# c2) = isTrue# (c1 `gtChar#` c2) + (C# c1) >= (C# c2) = isTrue# (c1 `geChar#` c2) + (C# c1) <= (C# c2) = isTrue# (c1 `leChar#` c2) + (C# c1) < (C# c2) = isTrue# (c1 `ltChar#` c2) + +instance Ord Float where + (F# x) `compare` (F# y) + = if isTrue# (x `ltFloat#` y) then LT + else if isTrue# (x `eqFloat#` y) then EQ + else GT + + (F# x) < (F# y) = isTrue# (x `ltFloat#` y) + (F# x) <= (F# y) = isTrue# (x `leFloat#` y) + (F# x) >= (F# y) = isTrue# (x `geFloat#` y) + (F# x) > (F# y) = isTrue# (x `gtFloat#` y) + +instance Ord Double where + (D# x) `compare` (D# y) + = if isTrue# (x <## y) then LT + else if isTrue# (x ==## y) then EQ + else GT + + (D# x) < (D# y) = isTrue# (x <## y) + (D# x) <= (D# y) = isTrue# (x <=## y) + (D# x) >= (D# y) = isTrue# (x >=## y) + (D# x) > (D# y) = isTrue# (x >## y) + +instance Ord Int where + compare = compareInt + (<) = ltInt + (<=) = leInt + (>=) = geInt + (>) = gtInt + +{-# INLINE gtInt #-} +{-# INLINE geInt #-} +{-# INLINE ltInt #-} +{-# INLINE leInt #-} +gtInt, geInt, ltInt, leInt :: Int -> Int -> Bool +(I# x) `gtInt` (I# y) = isTrue# (x ># y) +(I# x) `geInt` (I# y) = isTrue# (x >=# y) +(I# x) `ltInt` (I# y) = isTrue# (x <# y) +(I# x) `leInt` (I# y) = isTrue# (x <=# y) + +compareInt :: Int -> Int -> Ordering +(I# x#) `compareInt` (I# y#) = compareInt# x# y# + +compareInt# :: Int# -> Int# -> Ordering +compareInt# x# y# + | isTrue# (x# <# y#) = LT + | isTrue# (x# ==# y#) = EQ + | True = GT + +-- OK, so they're technically not part of a class...: + +-- Boolean functions + +-- | Boolean \"and\" +(&&) :: Bool -> Bool -> Bool +True && x = x +False && _ = False + +-- | Boolean \"or\" +(||) :: Bool -> Bool -> Bool +True || _ = True +False || x = x + +-- | Boolean \"not\" +not :: Bool -> Bool +not True = False +not False = True + + +------------------------------------------------------------------------ +-- These don't really belong here, but we don't have a better place to +-- put them + +divInt# :: Int# -> Int# -> Int# +x# `divInt#` y# + -- Be careful NOT to overflow if we do any additional arithmetic + -- on the arguments... the following previous version of this + -- code has problems with overflow: +-- | (x# ># 0#) && (y# <# 0#) = ((x# -# y#) -# 1#) `quotInt#` y# +-- | (x# <# 0#) && (y# ># 0#) = ((x# -# y#) +# 1#) `quotInt#` y# + = if isTrue# (x# ># 0#) && isTrue# (y# <# 0#) then ((x# -# 1#) `quotInt#` y#) -# 1# + else if isTrue# (x# <# 0#) && isTrue# (y# ># 0#) then ((x# +# 1#) `quotInt#` y#) -# 1# + else x# `quotInt#` y# + +modInt# :: Int# -> Int# -> Int# +x# `modInt#` y# + = if isTrue# (x# ># 0#) && isTrue# (y# <# 0#) || + isTrue# (x# <# 0#) && isTrue# (y# ># 0#) + then if isTrue# (r# /=# 0#) then r# +# y# else 0# + else r# + where + !r# = x# `remInt#` y# diff --git a/GHC/Debug.hs b/GHC/Debug.hs new file mode 100644 --- /dev/null +++ b/GHC/Debug.hs @@ -0,0 +1,47 @@ +{-# LANGUAGE MagicHash, NoImplicitPrelude, UnboxedTuples, UnliftedFFITypes, Trustworthy #-} + +module GHC.Debug ( debugLn, debugErrLn ) where + +import GHC.Prim +import GHC.Types +import GHC.Tuple () + +debugLn :: [Char] -> IO () +debugLn xs = IO (\s0 -> + case mkMBA s0 xs of + (# s1, mba #) -> + case c_debugLn mba of + IO f -> f s1) + +debugErrLn :: [Char] -> IO () +debugErrLn xs = IO (\s0 -> + case mkMBA s0 xs of + (# s1, mba #) -> + case c_debugErrLn mba of + IO f -> f s1) + +foreign import ccall unsafe "debugLn" + c_debugLn :: MutableByteArray# RealWorld -> IO () + +foreign import ccall unsafe "debugErrLn" + c_debugErrLn :: MutableByteArray# RealWorld -> IO () + +mkMBA :: State# RealWorld -> [Char] -> + (# State# RealWorld, MutableByteArray# RealWorld #) +mkMBA s0 xs = -- Start with 1 so that we have space to put in a \0 at + -- the end + case len 1# xs of + l -> + case newByteArray# l s0 of + (# s1, mba #) -> + case write mba 0# xs s1 of + s2 -> (# s2, mba #) + where len l [] = l + len l (_ : xs') = len (l +# 1#) xs' + + write mba offset [] s = writeCharArray# mba offset '\0'# s + write mba offset (C# x : xs') s + = case writeCharArray# mba offset x s of + s' -> + write mba (offset +# 1#) xs' s' + diff --git a/GHC/IntWord64.hs b/GHC/IntWord64.hs new file mode 100644 --- /dev/null +++ b/GHC/IntWord64.hs @@ -0,0 +1,72 @@ +{-# LANGUAGE CPP, MagicHash, NoImplicitPrelude, UnliftedFFITypes #-} +{-# OPTIONS_HADDOCK hide #-} +----------------------------------------------------------------------------- +-- | +-- Module : GHC.IntWord64 +-- Copyright : (c) The University of Glasgow, 1997-2008 +-- License : see libraries/ghc-prim/LICENSE +-- +-- Maintainer : cvs-ghc@haskell.org +-- Stability : internal +-- Portability : non-portable (GHC Extensions) +-- +-- Primitive operations on Int64# and Word64# on platforms where +-- WORD_SIZE_IN_BITS < 64. +-- +----------------------------------------------------------------------------- + +#include "MachDeps.h" + +-- #hide +module GHC.IntWord64 ( +#if WORD_SIZE_IN_BITS < 64 + Int64#, Word64#, module GHC.IntWord64 +#endif + ) where + +#if WORD_SIZE_IN_BITS < 64 +import GHC.Prim + +foreign import ccall unsafe "hs_eqWord64" eqWord64# :: Word64# -> Word64# -> Int# +foreign import ccall unsafe "hs_neWord64" neWord64# :: Word64# -> Word64# -> Int# +foreign import ccall unsafe "hs_ltWord64" ltWord64# :: Word64# -> Word64# -> Int# +foreign import ccall unsafe "hs_leWord64" leWord64# :: Word64# -> Word64# -> Int# +foreign import ccall unsafe "hs_gtWord64" gtWord64# :: Word64# -> Word64# -> Int# +foreign import ccall unsafe "hs_geWord64" geWord64# :: Word64# -> Word64# -> Int# + +foreign import ccall unsafe "hs_eqInt64" eqInt64# :: Int64# -> Int64# -> Int# +foreign import ccall unsafe "hs_neInt64" neInt64# :: Int64# -> Int64# -> Int# +foreign import ccall unsafe "hs_ltInt64" ltInt64# :: Int64# -> Int64# -> Int# +foreign import ccall unsafe "hs_leInt64" leInt64# :: Int64# -> Int64# -> Int# +foreign import ccall unsafe "hs_gtInt64" gtInt64# :: Int64# -> Int64# -> Int# +foreign import ccall unsafe "hs_geInt64" geInt64# :: Int64# -> Int64# -> Int# +foreign import ccall unsafe "hs_quotInt64" quotInt64# :: Int64# -> Int64# -> Int64# +foreign import ccall unsafe "hs_remInt64" remInt64# :: Int64# -> Int64# -> Int64# + +foreign import ccall unsafe "hs_plusInt64" plusInt64# :: Int64# -> Int64# -> Int64# +foreign import ccall unsafe "hs_minusInt64" minusInt64# :: Int64# -> Int64# -> Int64# +foreign import ccall unsafe "hs_timesInt64" timesInt64# :: Int64# -> Int64# -> Int64# +foreign import ccall unsafe "hs_negateInt64" negateInt64# :: Int64# -> Int64# +foreign import ccall unsafe "hs_quotWord64" quotWord64# :: Word64# -> Word64# -> Word64# +foreign import ccall unsafe "hs_remWord64" remWord64# :: Word64# -> Word64# -> Word64# + +foreign import ccall unsafe "hs_and64" and64# :: Word64# -> Word64# -> Word64# +foreign import ccall unsafe "hs_or64" or64# :: Word64# -> Word64# -> Word64# +foreign import ccall unsafe "hs_xor64" xor64# :: Word64# -> Word64# -> Word64# +foreign import ccall unsafe "hs_not64" not64# :: Word64# -> Word64# + +foreign import ccall unsafe "hs_uncheckedShiftL64" uncheckedShiftL64# :: Word64# -> Int# -> Word64# +foreign import ccall unsafe "hs_uncheckedShiftRL64" uncheckedShiftRL64# :: Word64# -> Int# -> Word64# +foreign import ccall unsafe "hs_uncheckedIShiftL64" uncheckedIShiftL64# :: Int64# -> Int# -> Int64# +foreign import ccall unsafe "hs_uncheckedIShiftRA64" uncheckedIShiftRA64# :: Int64# -> Int# -> Int64# +foreign import ccall unsafe "hs_uncheckedIShiftRL64" uncheckedIShiftRL64# :: Int64# -> Int# -> Int64# + +foreign import ccall unsafe "hs_int64ToWord64" int64ToWord64# :: Int64# -> Word64# +foreign import ccall unsafe "hs_word64ToInt64" word64ToInt64# :: Word64# -> Int64# +foreign import ccall unsafe "hs_intToInt64" intToInt64# :: Int# -> Int64# +foreign import ccall unsafe "hs_int64ToInt" int64ToInt# :: Int64# -> Int# +foreign import ccall unsafe "hs_wordToWord64" wordToWord64# :: Word# -> Word64# +foreign import ccall unsafe "hs_word64ToWord" word64ToWord# :: Word64# -> Word# + +#endif + diff --git a/GHC/Magic.hs b/GHC/Magic.hs new file mode 100644 --- /dev/null +++ b/GHC/Magic.hs @@ -0,0 +1,66 @@ +{-# LANGUAGE Trustworthy #-} +{-# LANGUAGE NoImplicitPrelude #-} +----------------------------------------------------------------------------- +-- | +-- Module : GHC.Magic +-- Copyright : (c) The University of Glasgow 2009 +-- License : see libraries/ghc-prim/LICENSE +-- +-- Maintainer : cvs-ghc@haskell.org +-- Stability : internal +-- Portability : non-portable (GHC Extensions) +-- +-- GHC magic. +-- +-- Use GHC.Exts from the base package instead of importing this +-- module directly. +-- +----------------------------------------------------------------------------- + +module GHC.Magic ( inline, lazy ) where + +-- | The call '(inline f)' arranges that 'f' is inlined, regardless of +-- its size. More precisely, the call '(inline f)' rewrites to the +-- right-hand side of 'f'\'s definition. This allows the programmer to +-- control inlining from a particular call site rather than the +-- definition site of the function (c.f. 'INLINE' pragmas). +-- +-- This inlining occurs regardless of the argument to the call or the +-- size of 'f'\'s definition; it is unconditional. The main caveat is +-- that 'f'\'s definition must be visible to the compiler; it is +-- therefore recommended to mark the function with an 'INLINABLE' +-- pragma at its definition so that GHC guarantees to record its +-- unfolding regardless of size. +-- +-- If no inlining takes place, the 'inline' function expands to the +-- identity function in Phase zero, so its use imposes no overhead. +{-# NOINLINE[0] inline #-} +inline :: a -> a +inline x = x + +-- | The 'lazy' function restrains strictness analysis a little. The +-- call '(lazy e)' means the same as 'e', but 'lazy' has a magical +-- property so far as strictness analysis is concerned: it is lazy in +-- its first argument, even though its semantics is strict. After +-- strictness analysis has run, calls to 'lazy' are inlined to be the +-- identity function. +-- +-- This behaviour is occasionally useful when controlling evaluation +-- order. Notably, 'lazy' is used in the library definition of +-- 'Control.Parallel.par': +-- +-- > par :: a -> b -> b +-- > par x y = case (par# x) of _ -> lazy y +-- +-- If 'lazy' were not lazy, 'par' would look strict in 'y' which +-- would defeat the whole purpose of 'par'. +-- +-- Like 'seq', the argument of 'lazy' can have an unboxed type. +lazy :: a -> a +lazy x = x +-- Implementation note: its strictness and unfolding are over-ridden +-- by the definition in MkId.lhs; in both cases to nothing at all. +-- That way, 'lazy' does not get inlined, and the strictness analyser +-- sees it as lazy. Then the worker/wrapper phase inlines it. +-- Result: happiness + diff --git a/GHC/Prim.hs b/GHC/Prim.hs new file mode 100644 --- /dev/null +++ b/GHC/Prim.hs @@ -0,0 +1,6291 @@ +{- +This is a generated file (generated by genprimopcode). +It is not code to actually be used. Its only purpose is to be +consumed by haddock. +-} + +----------------------------------------------------------------------------- +-- | +-- Module : GHC.Prim +-- +-- Maintainer : ghc-devs@haskell.org +-- Stability : internal +-- Portability : non-portable (GHC extensions) +-- +-- GHC's primitive types and operations. +-- Use GHC.Exts from the base package instead of importing this +-- module directly. +-- +----------------------------------------------------------------------------- +{-# LANGUAGE MagicHash, MultiParamTypeClasses, NoImplicitPrelude, UnboxedTuples #-} +module GHC.Prim ( + +-- * The word size story. +-- |Haskell98 specifies that signed integers (type @Int@) +-- must contain at least 30 bits. GHC always implements @Int@ using the primitive type @Int\#@, whose size equals +-- the @MachDeps.h@ constant @WORD\_SIZE\_IN\_BITS@. +-- This is normally set based on the @config.h@ parameter +-- @SIZEOF\_HSWORD@, i.e., 32 bits on 32-bit machines, 64 +-- bits on 64-bit machines. However, it can also be explicitly +-- set to a smaller number, e.g., 31 bits, to allow the +-- possibility of using tag bits. Currently GHC itself has only +-- 32-bit and 64-bit variants, but 30 or 31-bit code can be +-- exported as an external core file for use in other back ends. +-- +-- GHC also implements a primitive unsigned integer type @Word\#@ which always has the same number of bits as @Int\#@. +-- +-- In addition, GHC supports families of explicit-sized integers +-- and words at 8, 16, 32, and 64 bits, with the usual +-- arithmetic operations, comparisons, and a range of +-- conversions. The 8-bit and 16-bit sizes are always +-- represented as @Int\#@ and @Word\#@, and the +-- operations implemented in terms of the the primops on these +-- types, with suitable range restrictions on the results (using +-- the @narrow$n$Int\#@ and @narrow$n$Word\#@ families +-- of primops. The 32-bit sizes are represented using @Int\#@ and @Word\#@ when @WORD\_SIZE\_IN\_BITS@ +-- $\geq$ 32; otherwise, these are represented using distinct +-- primitive types @Int32\#@ and @Word32\#@. These (when +-- needed) have a complete set of corresponding operations; +-- however, nearly all of these are implemented as external C +-- functions rather than as primops. Exactly the same story +-- applies to the 64-bit sizes. All of these details are hidden +-- under the @PrelInt@ and @PrelWord@ modules, which use +-- @\#if@-defs to invoke the appropriate types and +-- operators. +-- +-- Word size also matters for the families of primops for +-- indexing\/reading\/writing fixed-size quantities at offsets +-- from an array base, address, or foreign pointer. Here, a +-- slightly different approach is taken. The names of these +-- primops are fixed, but their /types/ vary according to +-- the value of @WORD\_SIZE\_IN\_BITS@. For example, if word +-- size is at least 32 bits then an operator like +-- @indexInt32Array\#@ has type @ByteArray\# -> Int\# -> Int\#@; otherwise it has type @ByteArray\# -> Int\# -> Int32\#@. This approach confines the necessary @\#if@-defs to this file; no conditional compilation is needed +-- in the files that expose these primops. +-- +-- Finally, there are strongly deprecated primops for coercing +-- between @Addr\#@, the primitive type of machine +-- addresses, and @Int\#@. These are pretty bogus anyway, +-- but will work on existing 32-bit and 64-bit GHC targets; they +-- are completely bogus when tag bits are used in @Int\#@, +-- so are not available in this case. + + + +-- * Char# +-- |Operations on 31-bit characters. + + + Char#, + gtChar#, + geChar#, + eqChar#, + neChar#, + ltChar#, + leChar#, + ord#, + +-- * Int# +-- |Operations on native-size integers (30+ bits). + + + Int#, + (+#), + (-#), + (*#), + mulIntMayOflo#, + quotInt#, + remInt#, + quotRemInt#, + andI#, + orI#, + xorI#, + notI#, + negateInt#, + addIntC#, + subIntC#, + (>#), + (>=#), + (==#), + (/=#), + (<#), + (<=#), + chr#, + int2Word#, + int2Float#, + int2Double#, + word2Float#, + word2Double#, + uncheckedIShiftL#, + uncheckedIShiftRA#, + uncheckedIShiftRL#, + +-- * Word# +-- |Operations on native-sized unsigned words (30+ bits). + + + Word#, + plusWord#, + plusWord2#, + minusWord#, + timesWord#, + timesWord2#, + quotWord#, + remWord#, + quotRemWord#, + quotRemWord2#, + and#, + or#, + xor#, + not#, + uncheckedShiftL#, + uncheckedShiftRL#, + word2Int#, + gtWord#, + geWord#, + eqWord#, + neWord#, + ltWord#, + leWord#, + popCnt8#, + popCnt16#, + popCnt32#, + popCnt64#, + popCnt#, + byteSwap16#, + byteSwap32#, + byteSwap64#, + byteSwap#, + +-- * Narrowings +-- |Explicit narrowing of native-sized ints or words. + + + narrow8Int#, + narrow16Int#, + narrow32Int#, + narrow8Word#, + narrow16Word#, + narrow32Word#, + +-- * Double# +-- |Operations on double-precision (64 bit) floating-point numbers. + + + Double#, + (>##), + (>=##), + (==##), + (/=##), + (<##), + (<=##), + (+##), + (-##), + (*##), + (/##), + negateDouble#, + double2Int#, + double2Float#, + expDouble#, + logDouble#, + sqrtDouble#, + sinDouble#, + cosDouble#, + tanDouble#, + asinDouble#, + acosDouble#, + atanDouble#, + sinhDouble#, + coshDouble#, + tanhDouble#, + (**##), + decodeDouble_2Int#, + +-- * Float# +-- |Operations on single-precision (32-bit) floating-point numbers. + + + Float#, + gtFloat#, + geFloat#, + eqFloat#, + neFloat#, + ltFloat#, + leFloat#, + plusFloat#, + minusFloat#, + timesFloat#, + divideFloat#, + negateFloat#, + float2Int#, + expFloat#, + logFloat#, + sqrtFloat#, + sinFloat#, + cosFloat#, + tanFloat#, + asinFloat#, + acosFloat#, + atanFloat#, + sinhFloat#, + coshFloat#, + tanhFloat#, + powerFloat#, + float2Double#, + decodeFloat_Int#, + +-- * Arrays +-- |Operations on @Array\#@. + + + Array#, + MutableArray#, + newArray#, + sameMutableArray#, + readArray#, + writeArray#, + sizeofArray#, + sizeofMutableArray#, + indexArray#, + unsafeFreezeArray#, + unsafeThawArray#, + copyArray#, + copyMutableArray#, + cloneArray#, + cloneMutableArray#, + freezeArray#, + thawArray#, + casArray#, + +-- * Byte Arrays +-- |Operations on @ByteArray\#@. A @ByteArray\#@ is a just a region of +-- raw memory in the garbage-collected heap, which is not +-- scanned for pointers. It carries its own size (in bytes). +-- There are +-- three sets of operations for accessing byte array contents: +-- index for reading from immutable byte arrays, and read\/write +-- for mutable byte arrays. Each set contains operations for a +-- range of useful primitive data types. Each operation takes +-- an offset measured in terms of the size of the primitive type +-- being read or written. + + + ByteArray#, + MutableByteArray#, + newByteArray#, + newPinnedByteArray#, + newAlignedPinnedByteArray#, + byteArrayContents#, + sameMutableByteArray#, + unsafeFreezeByteArray#, + sizeofByteArray#, + sizeofMutableByteArray#, + indexCharArray#, + indexWideCharArray#, + indexIntArray#, + indexWordArray#, + indexAddrArray#, + indexFloatArray#, + indexDoubleArray#, + indexStablePtrArray#, + indexInt8Array#, + indexInt16Array#, + indexInt32Array#, + indexInt64Array#, + indexWord8Array#, + indexWord16Array#, + indexWord32Array#, + indexWord64Array#, + readCharArray#, + readWideCharArray#, + readIntArray#, + readWordArray#, + readAddrArray#, + readFloatArray#, + readDoubleArray#, + readStablePtrArray#, + readInt8Array#, + readInt16Array#, + readInt32Array#, + readInt64Array#, + readWord8Array#, + readWord16Array#, + readWord32Array#, + readWord64Array#, + writeCharArray#, + writeWideCharArray#, + writeIntArray#, + writeWordArray#, + writeAddrArray#, + writeFloatArray#, + writeDoubleArray#, + writeStablePtrArray#, + writeInt8Array#, + writeInt16Array#, + writeInt32Array#, + writeInt64Array#, + writeWord8Array#, + writeWord16Array#, + writeWord32Array#, + writeWord64Array#, + copyByteArray#, + copyMutableByteArray#, + copyByteArrayToAddr#, + copyMutableByteArrayToAddr#, + copyAddrToByteArray#, + setByteArray#, + casIntArray#, + fetchAddIntArray#, + +-- * Arrays of arrays +-- |Operations on @ArrayArray\#@. An @ArrayArray\#@ contains references to {\em unpointed} +-- arrays, such as @ByteArray\#s@. Hence, it is not parameterised by the element types, +-- just like a @ByteArray\#@, but it needs to be scanned during GC, just like an @Array#@. +-- We represent an @ArrayArray\#@ exactly as a @Array\#@, but provide element-type-specific +-- indexing, reading, and writing. + + + ArrayArray#, + MutableArrayArray#, + newArrayArray#, + sameMutableArrayArray#, + unsafeFreezeArrayArray#, + sizeofArrayArray#, + sizeofMutableArrayArray#, + indexByteArrayArray#, + indexArrayArrayArray#, + readByteArrayArray#, + readMutableByteArrayArray#, + readArrayArrayArray#, + readMutableArrayArrayArray#, + writeByteArrayArray#, + writeMutableByteArrayArray#, + writeArrayArrayArray#, + writeMutableArrayArrayArray#, + copyArrayArray#, + copyMutableArrayArray#, + +-- * Addr# +-- | + + + Addr#, + nullAddr#, + plusAddr#, + minusAddr#, + remAddr#, + addr2Int#, + int2Addr#, + gtAddr#, + geAddr#, + eqAddr#, + neAddr#, + ltAddr#, + leAddr#, + indexCharOffAddr#, + indexWideCharOffAddr#, + indexIntOffAddr#, + indexWordOffAddr#, + indexAddrOffAddr#, + indexFloatOffAddr#, + indexDoubleOffAddr#, + indexStablePtrOffAddr#, + indexInt8OffAddr#, + indexInt16OffAddr#, + indexInt32OffAddr#, + indexInt64OffAddr#, + indexWord8OffAddr#, + indexWord16OffAddr#, + indexWord32OffAddr#, + indexWord64OffAddr#, + readCharOffAddr#, + readWideCharOffAddr#, + readIntOffAddr#, + readWordOffAddr#, + readAddrOffAddr#, + readFloatOffAddr#, + readDoubleOffAddr#, + readStablePtrOffAddr#, + readInt8OffAddr#, + readInt16OffAddr#, + readInt32OffAddr#, + readInt64OffAddr#, + readWord8OffAddr#, + readWord16OffAddr#, + readWord32OffAddr#, + readWord64OffAddr#, + writeCharOffAddr#, + writeWideCharOffAddr#, + writeIntOffAddr#, + writeWordOffAddr#, + writeAddrOffAddr#, + writeFloatOffAddr#, + writeDoubleOffAddr#, + writeStablePtrOffAddr#, + writeInt8OffAddr#, + writeInt16OffAddr#, + writeInt32OffAddr#, + writeInt64OffAddr#, + writeWord8OffAddr#, + writeWord16OffAddr#, + writeWord32OffAddr#, + writeWord64OffAddr#, + +-- * Mutable variables +-- |Operations on MutVar\#s. + + + MutVar#, + newMutVar#, + readMutVar#, + writeMutVar#, + sameMutVar#, + atomicModifyMutVar#, + casMutVar#, + +-- * Exceptions +-- | + + + catch#, + raise#, + raiseIO#, + maskAsyncExceptions#, + maskUninterruptible#, + unmaskAsyncExceptions#, + getMaskingState#, + +-- * STM-accessible Mutable Variables +-- | + + + TVar#, + atomically#, + retry#, + catchRetry#, + catchSTM#, + check#, + newTVar#, + readTVar#, + readTVarIO#, + writeTVar#, + sameTVar#, + +-- * Synchronized Mutable Variables +-- |Operations on @MVar\#@s. + + + MVar#, + newMVar#, + takeMVar#, + tryTakeMVar#, + putMVar#, + tryPutMVar#, + readMVar#, + tryReadMVar#, + sameMVar#, + isEmptyMVar#, + +-- * Delay\/wait operations +-- | + + + delay#, + waitRead#, + waitWrite#, + +-- * Concurrency primitives +-- | + + + State#, + RealWorld, + ThreadId#, + fork#, + forkOn#, + killThread#, + yield#, + myThreadId#, + labelThread#, + isCurrentThreadBound#, + noDuplicate#, + threadStatus#, + +-- * Weak pointers +-- | + + + Weak#, + mkWeak#, + mkWeakNoFinalizer#, + addCFinalizerToWeak#, + deRefWeak#, + finalizeWeak#, + touch#, + +-- * Stable pointers and names +-- | + + + StablePtr#, + StableName#, + makeStablePtr#, + deRefStablePtr#, + eqStablePtr#, + makeStableName#, + eqStableName#, + stableNameToInt#, + +-- * Unsafe pointer equality +-- | + + + reallyUnsafePtrEquality#, + +-- * Parallelism +-- | + + + par#, + spark#, + seq#, + getSpark#, + numSparks#, + parGlobal#, + parLocal#, + parAt#, + parAtAbs#, + parAtRel#, + parAtForNow#, + +-- * Tag to enum stuff +-- |Convert back and forth between values of enumerated types +-- and small integers. + + + dataToTag#, + tagToEnum#, + +-- * Bytecode operations +-- |Support for the bytecode interpreter and linker. + + + BCO#, + addrToAny#, + mkApUpd0#, + newBCO#, + unpackClosure#, + getApStackVal#, + +-- * Misc +-- |These aren\'t nearly as wired in as Etc... + + + getCCSOf#, + getCurrentCCS#, + +-- * Etc +-- |Miscellaneous built-ins + + + Proxy#, + proxy#, + seq, + Any, + AnyK, + unsafeCoerce#, + traceEvent#, + traceMarker#, + +-- * Safe coercions +-- | + + + coerce, + Coercible, + +-- * SIMD Vectors +-- |Operations on SIMD vectors. + + + Int8X16#, + Int16X8#, + Int32X4#, + Int64X2#, + Int8X32#, + Int16X16#, + Int32X8#, + Int64X4#, + Int8X64#, + Int16X32#, + Int32X16#, + Int64X8#, + Word8X16#, + Word16X8#, + Word32X4#, + Word64X2#, + Word8X32#, + Word16X16#, + Word32X8#, + Word64X4#, + Word8X64#, + Word16X32#, + Word32X16#, + Word64X8#, + FloatX4#, + DoubleX2#, + FloatX8#, + DoubleX4#, + FloatX16#, + DoubleX8#, + broadcastInt8X16#, + broadcastInt16X8#, + broadcastInt32X4#, + broadcastInt64X2#, + broadcastInt8X32#, + broadcastInt16X16#, + broadcastInt32X8#, + broadcastInt64X4#, + broadcastInt8X64#, + broadcastInt16X32#, + broadcastInt32X16#, + broadcastInt64X8#, + broadcastWord8X16#, + broadcastWord16X8#, + broadcastWord32X4#, + broadcastWord64X2#, + broadcastWord8X32#, + broadcastWord16X16#, + broadcastWord32X8#, + broadcastWord64X4#, + broadcastWord8X64#, + broadcastWord16X32#, + broadcastWord32X16#, + broadcastWord64X8#, + broadcastFloatX4#, + broadcastDoubleX2#, + broadcastFloatX8#, + broadcastDoubleX4#, + broadcastFloatX16#, + broadcastDoubleX8#, + packInt8X16#, + packInt16X8#, + packInt32X4#, + packInt64X2#, + packInt8X32#, + packInt16X16#, + packInt32X8#, + packInt64X4#, + packInt8X64#, + packInt16X32#, + packInt32X16#, + packInt64X8#, + packWord8X16#, + packWord16X8#, + packWord32X4#, + packWord64X2#, + packWord8X32#, + packWord16X16#, + packWord32X8#, + packWord64X4#, + packWord8X64#, + packWord16X32#, + packWord32X16#, + packWord64X8#, + packFloatX4#, + packDoubleX2#, + packFloatX8#, + packDoubleX4#, + packFloatX16#, + packDoubleX8#, + unpackInt8X16#, + unpackInt16X8#, + unpackInt32X4#, + unpackInt64X2#, + unpackInt8X32#, + unpackInt16X16#, + unpackInt32X8#, + unpackInt64X4#, + unpackInt8X64#, + unpackInt16X32#, + unpackInt32X16#, + unpackInt64X8#, + unpackWord8X16#, + unpackWord16X8#, + unpackWord32X4#, + unpackWord64X2#, + unpackWord8X32#, + unpackWord16X16#, + unpackWord32X8#, + unpackWord64X4#, + unpackWord8X64#, + unpackWord16X32#, + unpackWord32X16#, + unpackWord64X8#, + unpackFloatX4#, + unpackDoubleX2#, + unpackFloatX8#, + unpackDoubleX4#, + unpackFloatX16#, + unpackDoubleX8#, + insertInt8X16#, + insertInt16X8#, + insertInt32X4#, + insertInt64X2#, + insertInt8X32#, + insertInt16X16#, + insertInt32X8#, + insertInt64X4#, + insertInt8X64#, + insertInt16X32#, + insertInt32X16#, + insertInt64X8#, + insertWord8X16#, + insertWord16X8#, + insertWord32X4#, + insertWord64X2#, + insertWord8X32#, + insertWord16X16#, + insertWord32X8#, + insertWord64X4#, + insertWord8X64#, + insertWord16X32#, + insertWord32X16#, + insertWord64X8#, + insertFloatX4#, + insertDoubleX2#, + insertFloatX8#, + insertDoubleX4#, + insertFloatX16#, + insertDoubleX8#, + plusInt8X16#, + plusInt16X8#, + plusInt32X4#, + plusInt64X2#, + plusInt8X32#, + plusInt16X16#, + plusInt32X8#, + plusInt64X4#, + plusInt8X64#, + plusInt16X32#, + plusInt32X16#, + plusInt64X8#, + plusWord8X16#, + plusWord16X8#, + plusWord32X4#, + plusWord64X2#, + plusWord8X32#, + plusWord16X16#, + plusWord32X8#, + plusWord64X4#, + plusWord8X64#, + plusWord16X32#, + plusWord32X16#, + plusWord64X8#, + plusFloatX4#, + plusDoubleX2#, + plusFloatX8#, + plusDoubleX4#, + plusFloatX16#, + plusDoubleX8#, + minusInt8X16#, + minusInt16X8#, + minusInt32X4#, + minusInt64X2#, + minusInt8X32#, + minusInt16X16#, + minusInt32X8#, + minusInt64X4#, + minusInt8X64#, + minusInt16X32#, + minusInt32X16#, + minusInt64X8#, + minusWord8X16#, + minusWord16X8#, + minusWord32X4#, + minusWord64X2#, + minusWord8X32#, + minusWord16X16#, + minusWord32X8#, + minusWord64X4#, + minusWord8X64#, + minusWord16X32#, + minusWord32X16#, + minusWord64X8#, + minusFloatX4#, + minusDoubleX2#, + minusFloatX8#, + minusDoubleX4#, + minusFloatX16#, + minusDoubleX8#, + timesInt8X16#, + timesInt16X8#, + timesInt32X4#, + timesInt64X2#, + timesInt8X32#, + timesInt16X16#, + timesInt32X8#, + timesInt64X4#, + timesInt8X64#, + timesInt16X32#, + timesInt32X16#, + timesInt64X8#, + timesWord8X16#, + timesWord16X8#, + timesWord32X4#, + timesWord64X2#, + timesWord8X32#, + timesWord16X16#, + timesWord32X8#, + timesWord64X4#, + timesWord8X64#, + timesWord16X32#, + timesWord32X16#, + timesWord64X8#, + timesFloatX4#, + timesDoubleX2#, + timesFloatX8#, + timesDoubleX4#, + timesFloatX16#, + timesDoubleX8#, + divideFloatX4#, + divideDoubleX2#, + divideFloatX8#, + divideDoubleX4#, + divideFloatX16#, + divideDoubleX8#, + quotInt8X16#, + quotInt16X8#, + quotInt32X4#, + quotInt64X2#, + quotInt8X32#, + quotInt16X16#, + quotInt32X8#, + quotInt64X4#, + quotInt8X64#, + quotInt16X32#, + quotInt32X16#, + quotInt64X8#, + quotWord8X16#, + quotWord16X8#, + quotWord32X4#, + quotWord64X2#, + quotWord8X32#, + quotWord16X16#, + quotWord32X8#, + quotWord64X4#, + quotWord8X64#, + quotWord16X32#, + quotWord32X16#, + quotWord64X8#, + remInt8X16#, + remInt16X8#, + remInt32X4#, + remInt64X2#, + remInt8X32#, + remInt16X16#, + remInt32X8#, + remInt64X4#, + remInt8X64#, + remInt16X32#, + remInt32X16#, + remInt64X8#, + remWord8X16#, + remWord16X8#, + remWord32X4#, + remWord64X2#, + remWord8X32#, + remWord16X16#, + remWord32X8#, + remWord64X4#, + remWord8X64#, + remWord16X32#, + remWord32X16#, + remWord64X8#, + negateInt8X16#, + negateInt16X8#, + negateInt32X4#, + negateInt64X2#, + negateInt8X32#, + negateInt16X16#, + negateInt32X8#, + negateInt64X4#, + negateInt8X64#, + negateInt16X32#, + negateInt32X16#, + negateInt64X8#, + negateFloatX4#, + negateDoubleX2#, + negateFloatX8#, + negateDoubleX4#, + negateFloatX16#, + negateDoubleX8#, + indexInt8X16Array#, + indexInt16X8Array#, + indexInt32X4Array#, + indexInt64X2Array#, + indexInt8X32Array#, + indexInt16X16Array#, + indexInt32X8Array#, + indexInt64X4Array#, + indexInt8X64Array#, + indexInt16X32Array#, + indexInt32X16Array#, + indexInt64X8Array#, + indexWord8X16Array#, + indexWord16X8Array#, + indexWord32X4Array#, + indexWord64X2Array#, + indexWord8X32Array#, + indexWord16X16Array#, + indexWord32X8Array#, + indexWord64X4Array#, + indexWord8X64Array#, + indexWord16X32Array#, + indexWord32X16Array#, + indexWord64X8Array#, + indexFloatX4Array#, + indexDoubleX2Array#, + indexFloatX8Array#, + indexDoubleX4Array#, + indexFloatX16Array#, + indexDoubleX8Array#, + readInt8X16Array#, + readInt16X8Array#, + readInt32X4Array#, + readInt64X2Array#, + readInt8X32Array#, + readInt16X16Array#, + readInt32X8Array#, + readInt64X4Array#, + readInt8X64Array#, + readInt16X32Array#, + readInt32X16Array#, + readInt64X8Array#, + readWord8X16Array#, + readWord16X8Array#, + readWord32X4Array#, + readWord64X2Array#, + readWord8X32Array#, + readWord16X16Array#, + readWord32X8Array#, + readWord64X4Array#, + readWord8X64Array#, + readWord16X32Array#, + readWord32X16Array#, + readWord64X8Array#, + readFloatX4Array#, + readDoubleX2Array#, + readFloatX8Array#, + readDoubleX4Array#, + readFloatX16Array#, + readDoubleX8Array#, + writeInt8X16Array#, + writeInt16X8Array#, + writeInt32X4Array#, + writeInt64X2Array#, + writeInt8X32Array#, + writeInt16X16Array#, + writeInt32X8Array#, + writeInt64X4Array#, + writeInt8X64Array#, + writeInt16X32Array#, + writeInt32X16Array#, + writeInt64X8Array#, + writeWord8X16Array#, + writeWord16X8Array#, + writeWord32X4Array#, + writeWord64X2Array#, + writeWord8X32Array#, + writeWord16X16Array#, + writeWord32X8Array#, + writeWord64X4Array#, + writeWord8X64Array#, + writeWord16X32Array#, + writeWord32X16Array#, + writeWord64X8Array#, + writeFloatX4Array#, + writeDoubleX2Array#, + writeFloatX8Array#, + writeDoubleX4Array#, + writeFloatX16Array#, + writeDoubleX8Array#, + indexInt8X16OffAddr#, + indexInt16X8OffAddr#, + indexInt32X4OffAddr#, + indexInt64X2OffAddr#, + indexInt8X32OffAddr#, + indexInt16X16OffAddr#, + indexInt32X8OffAddr#, + indexInt64X4OffAddr#, + indexInt8X64OffAddr#, + indexInt16X32OffAddr#, + indexInt32X16OffAddr#, + indexInt64X8OffAddr#, + indexWord8X16OffAddr#, + indexWord16X8OffAddr#, + indexWord32X4OffAddr#, + indexWord64X2OffAddr#, + indexWord8X32OffAddr#, + indexWord16X16OffAddr#, + indexWord32X8OffAddr#, + indexWord64X4OffAddr#, + indexWord8X64OffAddr#, + indexWord16X32OffAddr#, + indexWord32X16OffAddr#, + indexWord64X8OffAddr#, + indexFloatX4OffAddr#, + indexDoubleX2OffAddr#, + indexFloatX8OffAddr#, + indexDoubleX4OffAddr#, + indexFloatX16OffAddr#, + indexDoubleX8OffAddr#, + readInt8X16OffAddr#, + readInt16X8OffAddr#, + readInt32X4OffAddr#, + readInt64X2OffAddr#, + readInt8X32OffAddr#, + readInt16X16OffAddr#, + readInt32X8OffAddr#, + readInt64X4OffAddr#, + readInt8X64OffAddr#, + readInt16X32OffAddr#, + readInt32X16OffAddr#, + readInt64X8OffAddr#, + readWord8X16OffAddr#, + readWord16X8OffAddr#, + readWord32X4OffAddr#, + readWord64X2OffAddr#, + readWord8X32OffAddr#, + readWord16X16OffAddr#, + readWord32X8OffAddr#, + readWord64X4OffAddr#, + readWord8X64OffAddr#, + readWord16X32OffAddr#, + readWord32X16OffAddr#, + readWord64X8OffAddr#, + readFloatX4OffAddr#, + readDoubleX2OffAddr#, + readFloatX8OffAddr#, + readDoubleX4OffAddr#, + readFloatX16OffAddr#, + readDoubleX8OffAddr#, + writeInt8X16OffAddr#, + writeInt16X8OffAddr#, + writeInt32X4OffAddr#, + writeInt64X2OffAddr#, + writeInt8X32OffAddr#, + writeInt16X16OffAddr#, + writeInt32X8OffAddr#, + writeInt64X4OffAddr#, + writeInt8X64OffAddr#, + writeInt16X32OffAddr#, + writeInt32X16OffAddr#, + writeInt64X8OffAddr#, + writeWord8X16OffAddr#, + writeWord16X8OffAddr#, + writeWord32X4OffAddr#, + writeWord64X2OffAddr#, + writeWord8X32OffAddr#, + writeWord16X16OffAddr#, + writeWord32X8OffAddr#, + writeWord64X4OffAddr#, + writeWord8X64OffAddr#, + writeWord16X32OffAddr#, + writeWord32X16OffAddr#, + writeWord64X8OffAddr#, + writeFloatX4OffAddr#, + writeDoubleX2OffAddr#, + writeFloatX8OffAddr#, + writeDoubleX4OffAddr#, + writeFloatX16OffAddr#, + writeDoubleX8OffAddr#, + indexInt8ArrayAsInt8X16#, + indexInt16ArrayAsInt16X8#, + indexInt32ArrayAsInt32X4#, + indexInt64ArrayAsInt64X2#, + indexInt8ArrayAsInt8X32#, + indexInt16ArrayAsInt16X16#, + indexInt32ArrayAsInt32X8#, + indexInt64ArrayAsInt64X4#, + indexInt8ArrayAsInt8X64#, + indexInt16ArrayAsInt16X32#, + indexInt32ArrayAsInt32X16#, + indexInt64ArrayAsInt64X8#, + indexWord8ArrayAsWord8X16#, + indexWord16ArrayAsWord16X8#, + indexWord32ArrayAsWord32X4#, + indexWord64ArrayAsWord64X2#, + indexWord8ArrayAsWord8X32#, + indexWord16ArrayAsWord16X16#, + indexWord32ArrayAsWord32X8#, + indexWord64ArrayAsWord64X4#, + indexWord8ArrayAsWord8X64#, + indexWord16ArrayAsWord16X32#, + indexWord32ArrayAsWord32X16#, + indexWord64ArrayAsWord64X8#, + indexFloatArrayAsFloatX4#, + indexDoubleArrayAsDoubleX2#, + indexFloatArrayAsFloatX8#, + indexDoubleArrayAsDoubleX4#, + indexFloatArrayAsFloatX16#, + indexDoubleArrayAsDoubleX8#, + readInt8ArrayAsInt8X16#, + readInt16ArrayAsInt16X8#, + readInt32ArrayAsInt32X4#, + readInt64ArrayAsInt64X2#, + readInt8ArrayAsInt8X32#, + readInt16ArrayAsInt16X16#, + readInt32ArrayAsInt32X8#, + readInt64ArrayAsInt64X4#, + readInt8ArrayAsInt8X64#, + readInt16ArrayAsInt16X32#, + readInt32ArrayAsInt32X16#, + readInt64ArrayAsInt64X8#, + readWord8ArrayAsWord8X16#, + readWord16ArrayAsWord16X8#, + readWord32ArrayAsWord32X4#, + readWord64ArrayAsWord64X2#, + readWord8ArrayAsWord8X32#, + readWord16ArrayAsWord16X16#, + readWord32ArrayAsWord32X8#, + readWord64ArrayAsWord64X4#, + readWord8ArrayAsWord8X64#, + readWord16ArrayAsWord16X32#, + readWord32ArrayAsWord32X16#, + readWord64ArrayAsWord64X8#, + readFloatArrayAsFloatX4#, + readDoubleArrayAsDoubleX2#, + readFloatArrayAsFloatX8#, + readDoubleArrayAsDoubleX4#, + readFloatArrayAsFloatX16#, + readDoubleArrayAsDoubleX8#, + writeInt8ArrayAsInt8X16#, + writeInt16ArrayAsInt16X8#, + writeInt32ArrayAsInt32X4#, + writeInt64ArrayAsInt64X2#, + writeInt8ArrayAsInt8X32#, + writeInt16ArrayAsInt16X16#, + writeInt32ArrayAsInt32X8#, + writeInt64ArrayAsInt64X4#, + writeInt8ArrayAsInt8X64#, + writeInt16ArrayAsInt16X32#, + writeInt32ArrayAsInt32X16#, + writeInt64ArrayAsInt64X8#, + writeWord8ArrayAsWord8X16#, + writeWord16ArrayAsWord16X8#, + writeWord32ArrayAsWord32X4#, + writeWord64ArrayAsWord64X2#, + writeWord8ArrayAsWord8X32#, + writeWord16ArrayAsWord16X16#, + writeWord32ArrayAsWord32X8#, + writeWord64ArrayAsWord64X4#, + writeWord8ArrayAsWord8X64#, + writeWord16ArrayAsWord16X32#, + writeWord32ArrayAsWord32X16#, + writeWord64ArrayAsWord64X8#, + writeFloatArrayAsFloatX4#, + writeDoubleArrayAsDoubleX2#, + writeFloatArrayAsFloatX8#, + writeDoubleArrayAsDoubleX4#, + writeFloatArrayAsFloatX16#, + writeDoubleArrayAsDoubleX8#, + indexInt8OffAddrAsInt8X16#, + indexInt16OffAddrAsInt16X8#, + indexInt32OffAddrAsInt32X4#, + indexInt64OffAddrAsInt64X2#, + indexInt8OffAddrAsInt8X32#, + indexInt16OffAddrAsInt16X16#, + indexInt32OffAddrAsInt32X8#, + indexInt64OffAddrAsInt64X4#, + indexInt8OffAddrAsInt8X64#, + indexInt16OffAddrAsInt16X32#, + indexInt32OffAddrAsInt32X16#, + indexInt64OffAddrAsInt64X8#, + indexWord8OffAddrAsWord8X16#, + indexWord16OffAddrAsWord16X8#, + indexWord32OffAddrAsWord32X4#, + indexWord64OffAddrAsWord64X2#, + indexWord8OffAddrAsWord8X32#, + indexWord16OffAddrAsWord16X16#, + indexWord32OffAddrAsWord32X8#, + indexWord64OffAddrAsWord64X4#, + indexWord8OffAddrAsWord8X64#, + indexWord16OffAddrAsWord16X32#, + indexWord32OffAddrAsWord32X16#, + indexWord64OffAddrAsWord64X8#, + indexFloatOffAddrAsFloatX4#, + indexDoubleOffAddrAsDoubleX2#, + indexFloatOffAddrAsFloatX8#, + indexDoubleOffAddrAsDoubleX4#, + indexFloatOffAddrAsFloatX16#, + indexDoubleOffAddrAsDoubleX8#, + readInt8OffAddrAsInt8X16#, + readInt16OffAddrAsInt16X8#, + readInt32OffAddrAsInt32X4#, + readInt64OffAddrAsInt64X2#, + readInt8OffAddrAsInt8X32#, + readInt16OffAddrAsInt16X16#, + readInt32OffAddrAsInt32X8#, + readInt64OffAddrAsInt64X4#, + readInt8OffAddrAsInt8X64#, + readInt16OffAddrAsInt16X32#, + readInt32OffAddrAsInt32X16#, + readInt64OffAddrAsInt64X8#, + readWord8OffAddrAsWord8X16#, + readWord16OffAddrAsWord16X8#, + readWord32OffAddrAsWord32X4#, + readWord64OffAddrAsWord64X2#, + readWord8OffAddrAsWord8X32#, + readWord16OffAddrAsWord16X16#, + readWord32OffAddrAsWord32X8#, + readWord64OffAddrAsWord64X4#, + readWord8OffAddrAsWord8X64#, + readWord16OffAddrAsWord16X32#, + readWord32OffAddrAsWord32X16#, + readWord64OffAddrAsWord64X8#, + readFloatOffAddrAsFloatX4#, + readDoubleOffAddrAsDoubleX2#, + readFloatOffAddrAsFloatX8#, + readDoubleOffAddrAsDoubleX4#, + readFloatOffAddrAsFloatX16#, + readDoubleOffAddrAsDoubleX8#, + writeInt8OffAddrAsInt8X16#, + writeInt16OffAddrAsInt16X8#, + writeInt32OffAddrAsInt32X4#, + writeInt64OffAddrAsInt64X2#, + writeInt8OffAddrAsInt8X32#, + writeInt16OffAddrAsInt16X16#, + writeInt32OffAddrAsInt32X8#, + writeInt64OffAddrAsInt64X4#, + writeInt8OffAddrAsInt8X64#, + writeInt16OffAddrAsInt16X32#, + writeInt32OffAddrAsInt32X16#, + writeInt64OffAddrAsInt64X8#, + writeWord8OffAddrAsWord8X16#, + writeWord16OffAddrAsWord16X8#, + writeWord32OffAddrAsWord32X4#, + writeWord64OffAddrAsWord64X2#, + writeWord8OffAddrAsWord8X32#, + writeWord16OffAddrAsWord16X16#, + writeWord32OffAddrAsWord32X8#, + writeWord64OffAddrAsWord64X4#, + writeWord8OffAddrAsWord8X64#, + writeWord16OffAddrAsWord16X32#, + writeWord32OffAddrAsWord32X16#, + writeWord64OffAddrAsWord64X8#, + writeFloatOffAddrAsFloatX4#, + writeDoubleOffAddrAsDoubleX2#, + writeFloatOffAddrAsFloatX8#, + writeDoubleOffAddrAsDoubleX4#, + writeFloatOffAddrAsFloatX16#, + writeDoubleOffAddrAsDoubleX8#, + +-- * Prefetch +-- |Prefetch operations: Note how every prefetch operation has a name +-- with the pattern prefetch*N#, where N is either 0,1,2, or 3. +-- +-- This suffix number, N, is the \"locality level\" of the prefetch, following the +-- convention in GCC and other compilers. +-- Higher locality numbers correspond to the memory being loaded in more +-- levels of the cpu cache, and being retained after initial use. The naming +-- convention follows the naming convention of the prefetch intrinsic found +-- in the GCC and Clang C compilers. +-- +-- On the LLVM backend, prefetch*N# uses the LLVM prefetch intrinsic +-- with locality level N. The code generated by LLVM is target architecture +-- dependent, but should agree with the GHC NCG on x86 systems. +-- +-- On the Sparc and PPC native backends, prefetch*N is a No-Op. +-- +-- On the x86 NCG, N=0 will generate prefetchNTA, +-- N=1 generates prefetcht2, N=2 generates prefetcht1, and +-- N=3 generates prefetcht0. +-- +-- For streaming workloads, the prefetch*0 operations are recommended. +-- For workloads which do many reads or writes to a memory location in a short period of time, +-- prefetch*3 operations are recommended. +-- +-- For further reading about prefetch and associated systems performance optimization, +-- the instruction set and optimization manuals by Intel and other CPU vendors are +-- excellent starting place. +-- +-- +-- The \"Intel 64 and IA-32 Architectures Optimization Reference Manual\" is +-- especially a helpful read, even if your software is meant for other CPU +-- architectures or vendor hardware. The manual can be found at +-- http:\/\/www.intel.com\/content\/www\/us\/en\/architecture-and-technology\/64-ia-32-architectures-optimization-manual.html . +-- +-- The @prefetchMutableByteArray@ family of operations has the order of operations +-- determined by passing around the @State#@ token. +-- +-- For the @prefetchByteArray@ +-- and @prefetchAddr@ families of operations, consider the following example: +-- +-- @let a1 = prefetchByteArray2# a n in ...a1... @ +-- +-- In the above fragement, @a@ is the input variable for the prefetch +-- and @a1 == a@ will be true. To ensure that the prefetch is not treated as deadcode, +-- the body of the let should only use @a1@ and NOT @a@. The same principle +-- applies for uses of prefetch in a loop. +-- +-- + + + prefetchByteArray3#, + prefetchMutableByteArray3#, + prefetchAddr3#, + prefetchByteArray2#, + prefetchMutableByteArray2#, + prefetchAddr2#, + prefetchByteArray1#, + prefetchMutableByteArray1#, + prefetchAddr1#, + prefetchByteArray0#, + prefetchMutableByteArray0#, + prefetchAddr0#, +) where + +{- +has_side_effects = False +out_of_line = False +can_fail = False +commutable = False +code_size = { primOpCodeSizeDefault } +strictness = { \ arity -> mkClosedStrictSig (replicate arity topDmd) topRes } +fixity = Nothing +llvm_only = False + +-} + +data Char# + +gtChar# :: Char# -> Char# -> Int# +gtChar# = let x = x in x + +geChar# :: Char# -> Char# -> Int# +geChar# = let x = x in x + +eqChar# :: Char# -> Char# -> Int# +eqChar# = let x = x in x + +neChar# :: Char# -> Char# -> Int# +neChar# = let x = x in x + +ltChar# :: Char# -> Char# -> Int# +ltChar# = let x = x in x + +leChar# :: Char# -> Char# -> Int# +leChar# = let x = x in x + +ord# :: Char# -> Int# +ord# = let x = x in x + +data Int# + +infixl 6 +# +(+#) :: Int# -> Int# -> Int# +(+#) = let x = x in x + +infixl 6 -# +(-#) :: Int# -> Int# -> Int# +(-#) = let x = x in x + +-- |Low word of signed integer multiply. + +infixl 7 *# +(*#) :: Int# -> Int# -> Int# +(*#) = let x = x in x + +-- |Return non-zero if there is any possibility that the upper word of a +-- signed integer multiply might contain useful information. Return +-- zero only if you are completely sure that no overflow can occur. +-- On a 32-bit platform, the recommmended implementation is to do a +-- 32 x 32 -> 64 signed multiply, and subtract result[63:32] from +-- (result[31] >>signed 31). If this is zero, meaning that the +-- upper word is merely a sign extension of the lower one, no +-- overflow can occur. +-- +-- On a 64-bit platform it is not always possible to +-- acquire the top 64 bits of the result. Therefore, a recommended +-- implementation is to take the absolute value of both operands, and +-- return 0 iff bits[63:31] of them are zero, since that means that their +-- magnitudes fit within 31 bits, so the magnitude of the product must fit +-- into 62 bits. +-- +-- If in doubt, return non-zero, but do make an effort to create the +-- correct answer for small args, since otherwise the performance of +-- @(*) :: Integer -> Integer -> Integer@ will be poor. +-- + +mulIntMayOflo# :: Int# -> Int# -> Int# +mulIntMayOflo# = let x = x in x + +-- |Rounds towards zero. + +quotInt# :: Int# -> Int# -> Int# +quotInt# = let x = x in x + +-- |Satisfies @(quotInt\# x y) *\# y +\# (remInt\# x y) == x@. + +remInt# :: Int# -> Int# -> Int# +remInt# = let x = x in x + +-- |Rounds towards zero. + +quotRemInt# :: Int# -> Int# -> (# Int#,Int# #) +quotRemInt# = let x = x in x + +andI# :: Int# -> Int# -> Int# +andI# = let x = x in x + +orI# :: Int# -> Int# -> Int# +orI# = let x = x in x + +xorI# :: Int# -> Int# -> Int# +xorI# = let x = x in x + +notI# :: Int# -> Int# +notI# = let x = x in x + +negateInt# :: Int# -> Int# +negateInt# = let x = x in x + +-- |Add with carry. First member of result is (wrapped) sum; +-- second member is 0 iff no overflow occured. + +addIntC# :: Int# -> Int# -> (# Int#,Int# #) +addIntC# = let x = x in x + +-- |Subtract with carry. First member of result is (wrapped) difference; +-- second member is 0 iff no overflow occured. + +subIntC# :: Int# -> Int# -> (# Int#,Int# #) +subIntC# = let x = x in x + +infix 4 ># +(>#) :: Int# -> Int# -> Int# +(>#) = let x = x in x + +infix 4 >=# +(>=#) :: Int# -> Int# -> Int# +(>=#) = let x = x in x + +infix 4 ==# +(==#) :: Int# -> Int# -> Int# +(==#) = let x = x in x + +infix 4 /=# +(/=#) :: Int# -> Int# -> Int# +(/=#) = let x = x in x + +infix 4 <# +(<#) :: Int# -> Int# -> Int# +(<#) = let x = x in x + +infix 4 <=# +(<=#) :: Int# -> Int# -> Int# +(<=#) = let x = x in x + +chr# :: Int# -> Char# +chr# = let x = x in x + +int2Word# :: Int# -> Word# +int2Word# = let x = x in x + +int2Float# :: Int# -> Float# +int2Float# = let x = x in x + +int2Double# :: Int# -> Double# +int2Double# = let x = x in x + +word2Float# :: Word# -> Float# +word2Float# = let x = x in x + +word2Double# :: Word# -> Double# +word2Double# = let x = x in x + +-- |Shift left. Result undefined if shift amount is not +-- in the range 0 to word size - 1 inclusive. + +uncheckedIShiftL# :: Int# -> Int# -> Int# +uncheckedIShiftL# = let x = x in x + +-- |Shift right arithmetic. Result undefined if shift amount is not +-- in the range 0 to word size - 1 inclusive. + +uncheckedIShiftRA# :: Int# -> Int# -> Int# +uncheckedIShiftRA# = let x = x in x + +-- |Shift right logical. Result undefined if shift amount is not +-- in the range 0 to word size - 1 inclusive. + +uncheckedIShiftRL# :: Int# -> Int# -> Int# +uncheckedIShiftRL# = let x = x in x + +data Word# + +plusWord# :: Word# -> Word# -> Word# +plusWord# = let x = x in x + +plusWord2# :: Word# -> Word# -> (# Word#,Word# #) +plusWord2# = let x = x in x + +minusWord# :: Word# -> Word# -> Word# +minusWord# = let x = x in x + +timesWord# :: Word# -> Word# -> Word# +timesWord# = let x = x in x + +timesWord2# :: Word# -> Word# -> (# Word#,Word# #) +timesWord2# = let x = x in x + +quotWord# :: Word# -> Word# -> Word# +quotWord# = let x = x in x + +remWord# :: Word# -> Word# -> Word# +remWord# = let x = x in x + +quotRemWord# :: Word# -> Word# -> (# Word#,Word# #) +quotRemWord# = let x = x in x + +quotRemWord2# :: Word# -> Word# -> Word# -> (# Word#,Word# #) +quotRemWord2# = let x = x in x + +and# :: Word# -> Word# -> Word# +and# = let x = x in x + +or# :: Word# -> Word# -> Word# +or# = let x = x in x + +xor# :: Word# -> Word# -> Word# +xor# = let x = x in x + +not# :: Word# -> Word# +not# = let x = x in x + +-- |Shift left logical. Result undefined if shift amount is not +-- in the range 0 to word size - 1 inclusive. + +uncheckedShiftL# :: Word# -> Int# -> Word# +uncheckedShiftL# = let x = x in x + +-- |Shift right logical. Result undefined if shift amount is not +-- in the range 0 to word size - 1 inclusive. + +uncheckedShiftRL# :: Word# -> Int# -> Word# +uncheckedShiftRL# = let x = x in x + +word2Int# :: Word# -> Int# +word2Int# = let x = x in x + +gtWord# :: Word# -> Word# -> Int# +gtWord# = let x = x in x + +geWord# :: Word# -> Word# -> Int# +geWord# = let x = x in x + +eqWord# :: Word# -> Word# -> Int# +eqWord# = let x = x in x + +neWord# :: Word# -> Word# -> Int# +neWord# = let x = x in x + +ltWord# :: Word# -> Word# -> Int# +ltWord# = let x = x in x + +leWord# :: Word# -> Word# -> Int# +leWord# = let x = x in x + +-- |Count the number of set bits in the lower 8 bits of a word. + +popCnt8# :: Word# -> Word# +popCnt8# = let x = x in x + +-- |Count the number of set bits in the lower 16 bits of a word. + +popCnt16# :: Word# -> Word# +popCnt16# = let x = x in x + +-- |Count the number of set bits in the lower 32 bits of a word. + +popCnt32# :: Word# -> Word# +popCnt32# = let x = x in x + +-- |Count the number of set bits in a 64-bit word. + +popCnt64# :: Word# -> Word# +popCnt64# = let x = x in x + +-- |Count the number of set bits in a word. + +popCnt# :: Word# -> Word# +popCnt# = let x = x in x + +-- |Swap bytes in the lower 16 bits of a word. The higher bytes are undefined. + +byteSwap16# :: Word# -> Word# +byteSwap16# = let x = x in x + +-- |Swap bytes in the lower 32 bits of a word. The higher bytes are undefined. + +byteSwap32# :: Word# -> Word# +byteSwap32# = let x = x in x + +-- |Swap bytes in a 64 bits of a word. + +byteSwap64# :: Word# -> Word# +byteSwap64# = let x = x in x + +-- |Swap bytes in a word. + +byteSwap# :: Word# -> Word# +byteSwap# = let x = x in x + +narrow8Int# :: Int# -> Int# +narrow8Int# = let x = x in x + +narrow16Int# :: Int# -> Int# +narrow16Int# = let x = x in x + +narrow32Int# :: Int# -> Int# +narrow32Int# = let x = x in x + +narrow8Word# :: Word# -> Word# +narrow8Word# = let x = x in x + +narrow16Word# :: Word# -> Word# +narrow16Word# = let x = x in x + +narrow32Word# :: Word# -> Word# +narrow32Word# = let x = x in x + +data Double# + +infix 4 >## +(>##) :: Double# -> Double# -> Int# +(>##) = let x = x in x + +infix 4 >=## +(>=##) :: Double# -> Double# -> Int# +(>=##) = let x = x in x + +infix 4 ==## +(==##) :: Double# -> Double# -> Int# +(==##) = let x = x in x + +infix 4 /=## +(/=##) :: Double# -> Double# -> Int# +(/=##) = let x = x in x + +infix 4 <## +(<##) :: Double# -> Double# -> Int# +(<##) = let x = x in x + +infix 4 <=## +(<=##) :: Double# -> Double# -> Int# +(<=##) = let x = x in x + +infixl 6 +## +(+##) :: Double# -> Double# -> Double# +(+##) = let x = x in x + +infixl 6 -## +(-##) :: Double# -> Double# -> Double# +(-##) = let x = x in x + +infixl 7 *## +(*##) :: Double# -> Double# -> Double# +(*##) = let x = x in x + +infixl 7 /## +(/##) :: Double# -> Double# -> Double# +(/##) = let x = x in x + +negateDouble# :: Double# -> Double# +negateDouble# = let x = x in x + +-- |Truncates a @Double#@ value to the nearest @Int#@. +-- Results are undefined if the truncation if truncation yields +-- a value outside the range of @Int#@. + +double2Int# :: Double# -> Int# +double2Int# = let x = x in x + +double2Float# :: Double# -> Float# +double2Float# = let x = x in x + +expDouble# :: Double# -> Double# +expDouble# = let x = x in x + +logDouble# :: Double# -> Double# +logDouble# = let x = x in x + +sqrtDouble# :: Double# -> Double# +sqrtDouble# = let x = x in x + +sinDouble# :: Double# -> Double# +sinDouble# = let x = x in x + +cosDouble# :: Double# -> Double# +cosDouble# = let x = x in x + +tanDouble# :: Double# -> Double# +tanDouble# = let x = x in x + +asinDouble# :: Double# -> Double# +asinDouble# = let x = x in x + +acosDouble# :: Double# -> Double# +acosDouble# = let x = x in x + +atanDouble# :: Double# -> Double# +atanDouble# = let x = x in x + +sinhDouble# :: Double# -> Double# +sinhDouble# = let x = x in x + +coshDouble# :: Double# -> Double# +coshDouble# = let x = x in x + +tanhDouble# :: Double# -> Double# +tanhDouble# = let x = x in x + +-- |Exponentiation. + +(**##) :: Double# -> Double# -> Double# +(**##) = let x = x in x + +-- |Convert to integer. +-- First component of the result is -1 or 1, indicating the sign of the +-- mantissa. The next two are the high and low 32 bits of the mantissa +-- respectively, and the last is the exponent. + +decodeDouble_2Int# :: Double# -> (# Int#,Word#,Word#,Int# #) +decodeDouble_2Int# = let x = x in x + +data Float# + +gtFloat# :: Float# -> Float# -> Int# +gtFloat# = let x = x in x + +geFloat# :: Float# -> Float# -> Int# +geFloat# = let x = x in x + +eqFloat# :: Float# -> Float# -> Int# +eqFloat# = let x = x in x + +neFloat# :: Float# -> Float# -> Int# +neFloat# = let x = x in x + +ltFloat# :: Float# -> Float# -> Int# +ltFloat# = let x = x in x + +leFloat# :: Float# -> Float# -> Int# +leFloat# = let x = x in x + +plusFloat# :: Float# -> Float# -> Float# +plusFloat# = let x = x in x + +minusFloat# :: Float# -> Float# -> Float# +minusFloat# = let x = x in x + +timesFloat# :: Float# -> Float# -> Float# +timesFloat# = let x = x in x + +divideFloat# :: Float# -> Float# -> Float# +divideFloat# = let x = x in x + +negateFloat# :: Float# -> Float# +negateFloat# = let x = x in x + +-- |Truncates a @Float#@ value to the nearest @Int#@. +-- Results are undefined if the truncation if truncation yields +-- a value outside the range of @Int#@. + +float2Int# :: Float# -> Int# +float2Int# = let x = x in x + +expFloat# :: Float# -> Float# +expFloat# = let x = x in x + +logFloat# :: Float# -> Float# +logFloat# = let x = x in x + +sqrtFloat# :: Float# -> Float# +sqrtFloat# = let x = x in x + +sinFloat# :: Float# -> Float# +sinFloat# = let x = x in x + +cosFloat# :: Float# -> Float# +cosFloat# = let x = x in x + +tanFloat# :: Float# -> Float# +tanFloat# = let x = x in x + +asinFloat# :: Float# -> Float# +asinFloat# = let x = x in x + +acosFloat# :: Float# -> Float# +acosFloat# = let x = x in x + +atanFloat# :: Float# -> Float# +atanFloat# = let x = x in x + +sinhFloat# :: Float# -> Float# +sinhFloat# = let x = x in x + +coshFloat# :: Float# -> Float# +coshFloat# = let x = x in x + +tanhFloat# :: Float# -> Float# +tanhFloat# = let x = x in x + +powerFloat# :: Float# -> Float# -> Float# +powerFloat# = let x = x in x + +float2Double# :: Float# -> Double# +float2Double# = let x = x in x + +-- |Convert to integers. +-- First @Int\#@ in result is the mantissa; second is the exponent. + +decodeFloat_Int# :: Float# -> (# Int#,Int# #) +decodeFloat_Int# = let x = x in x + +data Array# a + +data MutableArray# s a + +-- |Create a new mutable array with the specified number of elements, +-- in the specified state thread, +-- with each element containing the specified initial value. + +newArray# :: Int# -> a -> State# s -> (# State# s,MutableArray# s a #) +newArray# = let x = x in x + +sameMutableArray# :: MutableArray# s a -> MutableArray# s a -> Int# +sameMutableArray# = let x = x in x + +-- |Read from specified index of mutable array. Result is not yet evaluated. + +readArray# :: MutableArray# s a -> Int# -> State# s -> (# State# s,a #) +readArray# = let x = x in x + +-- |Write to specified index of mutable array. + +writeArray# :: MutableArray# s a -> Int# -> a -> State# s -> State# s +writeArray# = let x = x in x + +-- |Return the number of elements in the array. + +sizeofArray# :: Array# a -> Int# +sizeofArray# = let x = x in x + +-- |Return the number of elements in the array. + +sizeofMutableArray# :: MutableArray# s a -> Int# +sizeofMutableArray# = let x = x in x + +-- |Read from specified index of immutable array. Result is packaged into +-- an unboxed singleton; the result itself is not yet evaluated. + +indexArray# :: Array# a -> Int# -> (# a #) +indexArray# = let x = x in x + +-- |Make a mutable array immutable, without copying. + +unsafeFreezeArray# :: MutableArray# s a -> State# s -> (# State# s,Array# a #) +unsafeFreezeArray# = let x = x in x + +-- |Make an immutable array mutable, without copying. + +unsafeThawArray# :: Array# a -> State# s -> (# State# s,MutableArray# s a #) +unsafeThawArray# = let x = x in x + +-- |Copy a range of the Array# to the specified region in the MutableArray#. +-- Both arrays must fully contain the specified ranges, but this is not checked. +-- The two arrays must not be the same array in different states, but this is not checked either. + +copyArray# :: Array# a -> Int# -> MutableArray# s a -> Int# -> Int# -> State# s -> State# s +copyArray# = let x = x in x + +-- |Copy a range of the first MutableArray# to the specified region in the second MutableArray#. +-- Both arrays must fully contain the specified ranges, but this is not checked. + +copyMutableArray# :: MutableArray# s a -> Int# -> MutableArray# s a -> Int# -> Int# -> State# s -> State# s +copyMutableArray# = let x = x in x + +-- |Return a newly allocated Array# with the specified subrange of the provided Array#. +-- The provided Array# should contain the full subrange specified by the two Int#s, but this is not checked. + +cloneArray# :: Array# a -> Int# -> Int# -> Array# a +cloneArray# = let x = x in x + +-- |Return a newly allocated Array# with the specified subrange of the provided Array#. +-- The provided MutableArray# should contain the full subrange specified by the two Int#s, but this is not checked. + +cloneMutableArray# :: MutableArray# s a -> Int# -> Int# -> State# s -> (# State# s,MutableArray# s a #) +cloneMutableArray# = let x = x in x + +-- |Return a newly allocated Array# with the specified subrange of the provided MutableArray#. +-- The provided MutableArray# should contain the full subrange specified by the two Int#s, but this is not checked. + +freezeArray# :: MutableArray# s a -> Int# -> Int# -> State# s -> (# State# s,Array# a #) +freezeArray# = let x = x in x + +-- |Return a newly allocated Array# with the specified subrange of the provided MutableArray#. +-- The provided Array# should contain the full subrange specified by the two Int#s, but this is not checked. + +thawArray# :: Array# a -> Int# -> Int# -> State# s -> (# State# s,MutableArray# s a #) +thawArray# = let x = x in x + +-- |Unsafe, machine-level atomic compare and swap on an element within an Array. + +casArray# :: MutableArray# s a -> Int# -> a -> a -> State# s -> (# State# s,Int#,a #) +casArray# = let x = x in x + +data ByteArray# + +data MutableByteArray# s + +-- |Create a new mutable byte array of specified size (in bytes), in +-- the specified state thread. + +newByteArray# :: Int# -> State# s -> (# State# s,MutableByteArray# s #) +newByteArray# = let x = x in x + +-- |Create a mutable byte array that the GC guarantees not to move. + +newPinnedByteArray# :: Int# -> State# s -> (# State# s,MutableByteArray# s #) +newPinnedByteArray# = let x = x in x + +-- |Create a mutable byte array, aligned by the specified amount, that the GC guarantees not to move. + +newAlignedPinnedByteArray# :: Int# -> Int# -> State# s -> (# State# s,MutableByteArray# s #) +newAlignedPinnedByteArray# = let x = x in x + +-- |Intended for use with pinned arrays; otherwise very unsafe! + +byteArrayContents# :: ByteArray# -> Addr# +byteArrayContents# = let x = x in x + +sameMutableByteArray# :: MutableByteArray# s -> MutableByteArray# s -> Int# +sameMutableByteArray# = let x = x in x + +-- |Make a mutable byte array immutable, without copying. + +unsafeFreezeByteArray# :: MutableByteArray# s -> State# s -> (# State# s,ByteArray# #) +unsafeFreezeByteArray# = let x = x in x + +-- |Return the size of the array in bytes. + +sizeofByteArray# :: ByteArray# -> Int# +sizeofByteArray# = let x = x in x + +-- |Return the size of the array in bytes. + +sizeofMutableByteArray# :: MutableByteArray# s -> Int# +sizeofMutableByteArray# = let x = x in x + +-- |Read 8-bit character; offset in bytes. + +indexCharArray# :: ByteArray# -> Int# -> Char# +indexCharArray# = let x = x in x + +-- |Read 31-bit character; offset in 4-byte words. + +indexWideCharArray# :: ByteArray# -> Int# -> Char# +indexWideCharArray# = let x = x in x + +indexIntArray# :: ByteArray# -> Int# -> Int# +indexIntArray# = let x = x in x + +indexWordArray# :: ByteArray# -> Int# -> Word# +indexWordArray# = let x = x in x + +indexAddrArray# :: ByteArray# -> Int# -> Addr# +indexAddrArray# = let x = x in x + +indexFloatArray# :: ByteArray# -> Int# -> Float# +indexFloatArray# = let x = x in x + +indexDoubleArray# :: ByteArray# -> Int# -> Double# +indexDoubleArray# = let x = x in x + +indexStablePtrArray# :: ByteArray# -> Int# -> StablePtr# a +indexStablePtrArray# = let x = x in x + +indexInt8Array# :: ByteArray# -> Int# -> Int# +indexInt8Array# = let x = x in x + +indexInt16Array# :: ByteArray# -> Int# -> Int# +indexInt16Array# = let x = x in x + +indexInt32Array# :: ByteArray# -> Int# -> Int# +indexInt32Array# = let x = x in x + +indexInt64Array# :: ByteArray# -> Int# -> Int# +indexInt64Array# = let x = x in x + +indexWord8Array# :: ByteArray# -> Int# -> Word# +indexWord8Array# = let x = x in x + +indexWord16Array# :: ByteArray# -> Int# -> Word# +indexWord16Array# = let x = x in x + +indexWord32Array# :: ByteArray# -> Int# -> Word# +indexWord32Array# = let x = x in x + +indexWord64Array# :: ByteArray# -> Int# -> Word# +indexWord64Array# = let x = x in x + +-- |Read 8-bit character; offset in bytes. + +readCharArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Char# #) +readCharArray# = let x = x in x + +-- |Read 31-bit character; offset in 4-byte words. + +readWideCharArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Char# #) +readWideCharArray# = let x = x in x + +readIntArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int# #) +readIntArray# = let x = x in x + +readWordArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word# #) +readWordArray# = let x = x in x + +readAddrArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Addr# #) +readAddrArray# = let x = x in x + +readFloatArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Float# #) +readFloatArray# = let x = x in x + +readDoubleArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Double# #) +readDoubleArray# = let x = x in x + +readStablePtrArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,StablePtr# a #) +readStablePtrArray# = let x = x in x + +readInt8Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int# #) +readInt8Array# = let x = x in x + +readInt16Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int# #) +readInt16Array# = let x = x in x + +readInt32Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int# #) +readInt32Array# = let x = x in x + +readInt64Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int# #) +readInt64Array# = let x = x in x + +readWord8Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word# #) +readWord8Array# = let x = x in x + +readWord16Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word# #) +readWord16Array# = let x = x in x + +readWord32Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word# #) +readWord32Array# = let x = x in x + +readWord64Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word# #) +readWord64Array# = let x = x in x + +-- |Write 8-bit character; offset in bytes. + +writeCharArray# :: MutableByteArray# s -> Int# -> Char# -> State# s -> State# s +writeCharArray# = let x = x in x + +-- |Write 31-bit character; offset in 4-byte words. + +writeWideCharArray# :: MutableByteArray# s -> Int# -> Char# -> State# s -> State# s +writeWideCharArray# = let x = x in x + +writeIntArray# :: MutableByteArray# s -> Int# -> Int# -> State# s -> State# s +writeIntArray# = let x = x in x + +writeWordArray# :: MutableByteArray# s -> Int# -> Word# -> State# s -> State# s +writeWordArray# = let x = x in x + +writeAddrArray# :: MutableByteArray# s -> Int# -> Addr# -> State# s -> State# s +writeAddrArray# = let x = x in x + +writeFloatArray# :: MutableByteArray# s -> Int# -> Float# -> State# s -> State# s +writeFloatArray# = let x = x in x + +writeDoubleArray# :: MutableByteArray# s -> Int# -> Double# -> State# s -> State# s +writeDoubleArray# = let x = x in x + +writeStablePtrArray# :: MutableByteArray# s -> Int# -> StablePtr# a -> State# s -> State# s +writeStablePtrArray# = let x = x in x + +writeInt8Array# :: MutableByteArray# s -> Int# -> Int# -> State# s -> State# s +writeInt8Array# = let x = x in x + +writeInt16Array# :: MutableByteArray# s -> Int# -> Int# -> State# s -> State# s +writeInt16Array# = let x = x in x + +writeInt32Array# :: MutableByteArray# s -> Int# -> Int# -> State# s -> State# s +writeInt32Array# = let x = x in x + +writeInt64Array# :: MutableByteArray# s -> Int# -> Int# -> State# s -> State# s +writeInt64Array# = let x = x in x + +writeWord8Array# :: MutableByteArray# s -> Int# -> Word# -> State# s -> State# s +writeWord8Array# = let x = x in x + +writeWord16Array# :: MutableByteArray# s -> Int# -> Word# -> State# s -> State# s +writeWord16Array# = let x = x in x + +writeWord32Array# :: MutableByteArray# s -> Int# -> Word# -> State# s -> State# s +writeWord32Array# = let x = x in x + +writeWord64Array# :: MutableByteArray# s -> Int# -> Word# -> State# s -> State# s +writeWord64Array# = let x = x in x + +-- |Copy a range of the ByteArray# to the specified region in the MutableByteArray#. +-- Both arrays must fully contain the specified ranges, but this is not checked. +-- The two arrays must not be the same array in different states, but this is not checked either. + +copyByteArray# :: ByteArray# -> Int# -> MutableByteArray# s -> Int# -> Int# -> State# s -> State# s +copyByteArray# = let x = x in x + +-- |Copy a range of the first MutableByteArray# to the specified region in the second MutableByteArray#. +-- Both arrays must fully contain the specified ranges, but this is not checked. + +copyMutableByteArray# :: MutableByteArray# s -> Int# -> MutableByteArray# s -> Int# -> Int# -> State# s -> State# s +copyMutableByteArray# = let x = x in x + +-- |Copy a range of the ByteArray# to the memory range starting at the Addr#. +-- The ByteArray# and the memory region at Addr# must fully contain the +-- specified ranges, but this is not checked. The Addr# must not point into the +-- ByteArray# (e.g. if the ByteArray# were pinned), but this is not checked +-- either. + +copyByteArrayToAddr# :: ByteArray# -> Int# -> Addr# -> Int# -> State# s -> State# s +copyByteArrayToAddr# = let x = x in x + +-- |Copy a range of the MutableByteArray# to the memory range starting at the +-- Addr#. The MutableByteArray# and the memory region at Addr# must fully +-- contain the specified ranges, but this is not checked. The Addr# must not +-- point into the MutableByteArray# (e.g. if the MutableByteArray# were +-- pinned), but this is not checked either. + +copyMutableByteArrayToAddr# :: MutableByteArray# s -> Int# -> Addr# -> Int# -> State# s -> State# s +copyMutableByteArrayToAddr# = let x = x in x + +-- |Copy a memory range starting at the Addr# to the specified range in the +-- MutableByteArray#. The memory region at Addr# and the ByteArray# must fully +-- contain the specified ranges, but this is not checked. The Addr# must not +-- point into the MutableByteArray# (e.g. if the MutableByteArray# were pinned), +-- but this is not checked either. + +copyAddrToByteArray# :: Addr# -> MutableByteArray# s -> Int# -> Int# -> State# s -> State# s +copyAddrToByteArray# = let x = x in x + +-- |Set the range of the MutableByteArray# to the specified character. + +setByteArray# :: MutableByteArray# s -> Int# -> Int# -> Int# -> State# s -> State# s +setByteArray# = let x = x in x + +-- |Machine-level atomic compare and swap on a word within a ByteArray. + +casIntArray# :: MutableByteArray# s -> Int# -> Int# -> Int# -> State# s -> (# State# s,Int# #) +casIntArray# = let x = x in x + +-- |Machine-level word-sized fetch-and-add within a ByteArray. + +fetchAddIntArray# :: MutableByteArray# s -> Int# -> Int# -> State# s -> (# State# s,Int# #) +fetchAddIntArray# = let x = x in x + +data ArrayArray# + +data MutableArrayArray# s + +-- |Create a new mutable array of arrays with the specified number of elements, +-- in the specified state thread, with each element recursively referring to the +-- newly created array. + +newArrayArray# :: Int# -> State# s -> (# State# s,MutableArrayArray# s #) +newArrayArray# = let x = x in x + +sameMutableArrayArray# :: MutableArrayArray# s -> MutableArrayArray# s -> Int# +sameMutableArrayArray# = let x = x in x + +-- |Make a mutable array of arrays immutable, without copying. + +unsafeFreezeArrayArray# :: MutableArrayArray# s -> State# s -> (# State# s,ArrayArray# #) +unsafeFreezeArrayArray# = let x = x in x + +-- |Return the number of elements in the array. + +sizeofArrayArray# :: ArrayArray# -> Int# +sizeofArrayArray# = let x = x in x + +-- |Return the number of elements in the array. + +sizeofMutableArrayArray# :: MutableArrayArray# s -> Int# +sizeofMutableArrayArray# = let x = x in x + +indexByteArrayArray# :: ArrayArray# -> Int# -> ByteArray# +indexByteArrayArray# = let x = x in x + +indexArrayArrayArray# :: ArrayArray# -> Int# -> ArrayArray# +indexArrayArrayArray# = let x = x in x + +readByteArrayArray# :: MutableArrayArray# s -> Int# -> State# s -> (# State# s,ByteArray# #) +readByteArrayArray# = let x = x in x + +readMutableByteArrayArray# :: MutableArrayArray# s -> Int# -> State# s -> (# State# s,MutableByteArray# s #) +readMutableByteArrayArray# = let x = x in x + +readArrayArrayArray# :: MutableArrayArray# s -> Int# -> State# s -> (# State# s,ArrayArray# #) +readArrayArrayArray# = let x = x in x + +readMutableArrayArrayArray# :: MutableArrayArray# s -> Int# -> State# s -> (# State# s,MutableArrayArray# s #) +readMutableArrayArrayArray# = let x = x in x + +writeByteArrayArray# :: MutableArrayArray# s -> Int# -> ByteArray# -> State# s -> State# s +writeByteArrayArray# = let x = x in x + +writeMutableByteArrayArray# :: MutableArrayArray# s -> Int# -> MutableByteArray# s -> State# s -> State# s +writeMutableByteArrayArray# = let x = x in x + +writeArrayArrayArray# :: MutableArrayArray# s -> Int# -> ArrayArray# -> State# s -> State# s +writeArrayArrayArray# = let x = x in x + +writeMutableArrayArrayArray# :: MutableArrayArray# s -> Int# -> MutableArrayArray# s -> State# s -> State# s +writeMutableArrayArrayArray# = let x = x in x + +-- |Copy a range of the ArrayArray# to the specified region in the MutableArrayArray#. +-- Both arrays must fully contain the specified ranges, but this is not checked. +-- The two arrays must not be the same array in different states, but this is not checked either. + +copyArrayArray# :: ArrayArray# -> Int# -> MutableArrayArray# s -> Int# -> Int# -> State# s -> State# s +copyArrayArray# = let x = x in x + +-- |Copy a range of the first MutableArrayArray# to the specified region in the second +-- MutableArrayArray#. +-- Both arrays must fully contain the specified ranges, but this is not checked. + +copyMutableArrayArray# :: MutableArrayArray# s -> Int# -> MutableArrayArray# s -> Int# -> Int# -> State# s -> State# s +copyMutableArrayArray# = let x = x in x + +-- | An arbitrary machine address assumed to point outside +-- the garbage-collected heap. + +data Addr# + +-- | The null address. + +nullAddr# :: Addr# +nullAddr# = let x = x in x + +plusAddr# :: Addr# -> Int# -> Addr# +plusAddr# = let x = x in x + +-- |Result is meaningless if two @Addr\#@s are so far apart that their +-- difference doesn\'t fit in an @Int\#@. + +minusAddr# :: Addr# -> Addr# -> Int# +minusAddr# = let x = x in x + +-- |Return the remainder when the @Addr\#@ arg, treated like an @Int\#@, +-- is divided by the @Int\#@ arg. + +remAddr# :: Addr# -> Int# -> Int# +remAddr# = let x = x in x + +-- |Coerce directly from address to int. Strongly deprecated. + +addr2Int# :: Addr# -> Int# +addr2Int# = let x = x in x + +-- |Coerce directly from int to address. Strongly deprecated. + +int2Addr# :: Int# -> Addr# +int2Addr# = let x = x in x + +gtAddr# :: Addr# -> Addr# -> Int# +gtAddr# = let x = x in x + +geAddr# :: Addr# -> Addr# -> Int# +geAddr# = let x = x in x + +eqAddr# :: Addr# -> Addr# -> Int# +eqAddr# = let x = x in x + +neAddr# :: Addr# -> Addr# -> Int# +neAddr# = let x = x in x + +ltAddr# :: Addr# -> Addr# -> Int# +ltAddr# = let x = x in x + +leAddr# :: Addr# -> Addr# -> Int# +leAddr# = let x = x in x + +-- |Reads 8-bit character; offset in bytes. + +indexCharOffAddr# :: Addr# -> Int# -> Char# +indexCharOffAddr# = let x = x in x + +-- |Reads 31-bit character; offset in 4-byte words. + +indexWideCharOffAddr# :: Addr# -> Int# -> Char# +indexWideCharOffAddr# = let x = x in x + +indexIntOffAddr# :: Addr# -> Int# -> Int# +indexIntOffAddr# = let x = x in x + +indexWordOffAddr# :: Addr# -> Int# -> Word# +indexWordOffAddr# = let x = x in x + +indexAddrOffAddr# :: Addr# -> Int# -> Addr# +indexAddrOffAddr# = let x = x in x + +indexFloatOffAddr# :: Addr# -> Int# -> Float# +indexFloatOffAddr# = let x = x in x + +indexDoubleOffAddr# :: Addr# -> Int# -> Double# +indexDoubleOffAddr# = let x = x in x + +indexStablePtrOffAddr# :: Addr# -> Int# -> StablePtr# a +indexStablePtrOffAddr# = let x = x in x + +indexInt8OffAddr# :: Addr# -> Int# -> Int# +indexInt8OffAddr# = let x = x in x + +indexInt16OffAddr# :: Addr# -> Int# -> Int# +indexInt16OffAddr# = let x = x in x + +indexInt32OffAddr# :: Addr# -> Int# -> Int# +indexInt32OffAddr# = let x = x in x + +indexInt64OffAddr# :: Addr# -> Int# -> Int# +indexInt64OffAddr# = let x = x in x + +indexWord8OffAddr# :: Addr# -> Int# -> Word# +indexWord8OffAddr# = let x = x in x + +indexWord16OffAddr# :: Addr# -> Int# -> Word# +indexWord16OffAddr# = let x = x in x + +indexWord32OffAddr# :: Addr# -> Int# -> Word# +indexWord32OffAddr# = let x = x in x + +indexWord64OffAddr# :: Addr# -> Int# -> Word# +indexWord64OffAddr# = let x = x in x + +-- |Reads 8-bit character; offset in bytes. + +readCharOffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Char# #) +readCharOffAddr# = let x = x in x + +-- |Reads 31-bit character; offset in 4-byte words. + +readWideCharOffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Char# #) +readWideCharOffAddr# = let x = x in x + +readIntOffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int# #) +readIntOffAddr# = let x = x in x + +readWordOffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word# #) +readWordOffAddr# = let x = x in x + +readAddrOffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Addr# #) +readAddrOffAddr# = let x = x in x + +readFloatOffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Float# #) +readFloatOffAddr# = let x = x in x + +readDoubleOffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Double# #) +readDoubleOffAddr# = let x = x in x + +readStablePtrOffAddr# :: Addr# -> Int# -> State# s -> (# State# s,StablePtr# a #) +readStablePtrOffAddr# = let x = x in x + +readInt8OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int# #) +readInt8OffAddr# = let x = x in x + +readInt16OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int# #) +readInt16OffAddr# = let x = x in x + +readInt32OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int# #) +readInt32OffAddr# = let x = x in x + +readInt64OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int# #) +readInt64OffAddr# = let x = x in x + +readWord8OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word# #) +readWord8OffAddr# = let x = x in x + +readWord16OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word# #) +readWord16OffAddr# = let x = x in x + +readWord32OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word# #) +readWord32OffAddr# = let x = x in x + +readWord64OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word# #) +readWord64OffAddr# = let x = x in x + +writeCharOffAddr# :: Addr# -> Int# -> Char# -> State# s -> State# s +writeCharOffAddr# = let x = x in x + +writeWideCharOffAddr# :: Addr# -> Int# -> Char# -> State# s -> State# s +writeWideCharOffAddr# = let x = x in x + +writeIntOffAddr# :: Addr# -> Int# -> Int# -> State# s -> State# s +writeIntOffAddr# = let x = x in x + +writeWordOffAddr# :: Addr# -> Int# -> Word# -> State# s -> State# s +writeWordOffAddr# = let x = x in x + +writeAddrOffAddr# :: Addr# -> Int# -> Addr# -> State# s -> State# s +writeAddrOffAddr# = let x = x in x + +writeFloatOffAddr# :: Addr# -> Int# -> Float# -> State# s -> State# s +writeFloatOffAddr# = let x = x in x + +writeDoubleOffAddr# :: Addr# -> Int# -> Double# -> State# s -> State# s +writeDoubleOffAddr# = let x = x in x + +writeStablePtrOffAddr# :: Addr# -> Int# -> StablePtr# a -> State# s -> State# s +writeStablePtrOffAddr# = let x = x in x + +writeInt8OffAddr# :: Addr# -> Int# -> Int# -> State# s -> State# s +writeInt8OffAddr# = let x = x in x + +writeInt16OffAddr# :: Addr# -> Int# -> Int# -> State# s -> State# s +writeInt16OffAddr# = let x = x in x + +writeInt32OffAddr# :: Addr# -> Int# -> Int# -> State# s -> State# s +writeInt32OffAddr# = let x = x in x + +writeInt64OffAddr# :: Addr# -> Int# -> Int# -> State# s -> State# s +writeInt64OffAddr# = let x = x in x + +writeWord8OffAddr# :: Addr# -> Int# -> Word# -> State# s -> State# s +writeWord8OffAddr# = let x = x in x + +writeWord16OffAddr# :: Addr# -> Int# -> Word# -> State# s -> State# s +writeWord16OffAddr# = let x = x in x + +writeWord32OffAddr# :: Addr# -> Int# -> Word# -> State# s -> State# s +writeWord32OffAddr# = let x = x in x + +writeWord64OffAddr# :: Addr# -> Int# -> Word# -> State# s -> State# s +writeWord64OffAddr# = let x = x in x + +-- |A @MutVar\#@ behaves like a single-element mutable array. + +data MutVar# s a + +-- |Create @MutVar\#@ with specified initial value in specified state thread. + +newMutVar# :: a -> State# s -> (# State# s,MutVar# s a #) +newMutVar# = let x = x in x + +-- |Read contents of @MutVar\#@. Result is not yet evaluated. + +readMutVar# :: MutVar# s a -> State# s -> (# State# s,a #) +readMutVar# = let x = x in x + +-- |Write contents of @MutVar\#@. + +writeMutVar# :: MutVar# s a -> a -> State# s -> State# s +writeMutVar# = let x = x in x + +sameMutVar# :: MutVar# s a -> MutVar# s a -> Int# +sameMutVar# = let x = x in x + +atomicModifyMutVar# :: MutVar# s a -> (a -> b) -> State# s -> (# State# s,c #) +atomicModifyMutVar# = let x = x in x + +casMutVar# :: MutVar# s a -> a -> a -> State# s -> (# State# s,Int#,a #) +casMutVar# = let x = x in x + +catch# :: (State# (RealWorld) -> (# State# (RealWorld),a #)) -> (b -> State# (RealWorld) -> (# State# (RealWorld),a #)) -> State# (RealWorld) -> (# State# (RealWorld),a #) +catch# = let x = x in x + +raise# :: a -> b +raise# = let x = x in x + +raiseIO# :: a -> State# (RealWorld) -> (# State# (RealWorld),b #) +raiseIO# = let x = x in x + +maskAsyncExceptions# :: (State# (RealWorld) -> (# State# (RealWorld),a #)) -> State# (RealWorld) -> (# State# (RealWorld),a #) +maskAsyncExceptions# = let x = x in x + +maskUninterruptible# :: (State# (RealWorld) -> (# State# (RealWorld),a #)) -> State# (RealWorld) -> (# State# (RealWorld),a #) +maskUninterruptible# = let x = x in x + +unmaskAsyncExceptions# :: (State# (RealWorld) -> (# State# (RealWorld),a #)) -> State# (RealWorld) -> (# State# (RealWorld),a #) +unmaskAsyncExceptions# = let x = x in x + +getMaskingState# :: State# (RealWorld) -> (# State# (RealWorld),Int# #) +getMaskingState# = let x = x in x + +data TVar# s a + +atomically# :: (State# (RealWorld) -> (# State# (RealWorld),a #)) -> State# (RealWorld) -> (# State# (RealWorld),a #) +atomically# = let x = x in x + +retry# :: State# (RealWorld) -> (# State# (RealWorld),a #) +retry# = let x = x in x + +catchRetry# :: (State# (RealWorld) -> (# State# (RealWorld),a #)) -> (State# (RealWorld) -> (# State# (RealWorld),a #)) -> State# (RealWorld) -> (# State# (RealWorld),a #) +catchRetry# = let x = x in x + +catchSTM# :: (State# (RealWorld) -> (# State# (RealWorld),a #)) -> (b -> State# (RealWorld) -> (# State# (RealWorld),a #)) -> State# (RealWorld) -> (# State# (RealWorld),a #) +catchSTM# = let x = x in x + +check# :: (State# (RealWorld) -> (# State# (RealWorld),a #)) -> State# (RealWorld) -> (# State# (RealWorld),() #) +check# = let x = x in x + +-- |Create a new @TVar\#@ holding a specified initial value. + +newTVar# :: a -> State# s -> (# State# s,TVar# s a #) +newTVar# = let x = x in x + +-- |Read contents of @TVar\#@. Result is not yet evaluated. + +readTVar# :: TVar# s a -> State# s -> (# State# s,a #) +readTVar# = let x = x in x + +-- |Read contents of @TVar\#@ outside an STM transaction + +readTVarIO# :: TVar# s a -> State# s -> (# State# s,a #) +readTVarIO# = let x = x in x + +-- |Write contents of @TVar\#@. + +writeTVar# :: TVar# s a -> a -> State# s -> State# s +writeTVar# = let x = x in x + +sameTVar# :: TVar# s a -> TVar# s a -> Int# +sameTVar# = let x = x in x + +-- | A shared mutable variable (/not/ the same as a @MutVar\#@!). +-- (Note: in a non-concurrent implementation, @(MVar\# a)@ can be +-- represented by @(MutVar\# (Maybe a))@.) + +data MVar# s a + +-- |Create new @MVar\#@; initially empty. + +newMVar# :: State# s -> (# State# s,MVar# s a #) +newMVar# = let x = x in x + +-- |If @MVar\#@ is empty, block until it becomes full. +-- Then remove and return its contents, and set it empty. + +takeMVar# :: MVar# s a -> State# s -> (# State# s,a #) +takeMVar# = let x = x in x + +-- |If @MVar\#@ is empty, immediately return with integer 0 and value undefined. +-- Otherwise, return with integer 1 and contents of @MVar\#@, and set @MVar\#@ empty. + +tryTakeMVar# :: MVar# s a -> State# s -> (# State# s,Int#,a #) +tryTakeMVar# = let x = x in x + +-- |If @MVar\#@ is full, block until it becomes empty. +-- Then store value arg as its new contents. + +putMVar# :: MVar# s a -> a -> State# s -> State# s +putMVar# = let x = x in x + +-- |If @MVar\#@ is full, immediately return with integer 0. +-- Otherwise, store value arg as @MVar\#@\'s new contents, and return with integer 1. + +tryPutMVar# :: MVar# s a -> a -> State# s -> (# State# s,Int# #) +tryPutMVar# = let x = x in x + +-- |If @MVar\#@ is empty, block until it becomes full. +-- Then read its contents without modifying the MVar, without possibility +-- of intervention from other threads. + +readMVar# :: MVar# s a -> State# s -> (# State# s,a #) +readMVar# = let x = x in x + +-- |If @MVar\#@ is empty, immediately return with integer 0 and value undefined. +-- Otherwise, return with integer 1 and contents of @MVar\#@. + +tryReadMVar# :: MVar# s a -> State# s -> (# State# s,Int#,a #) +tryReadMVar# = let x = x in x + +sameMVar# :: MVar# s a -> MVar# s a -> Int# +sameMVar# = let x = x in x + +-- |Return 1 if @MVar\#@ is empty; 0 otherwise. + +isEmptyMVar# :: MVar# s a -> State# s -> (# State# s,Int# #) +isEmptyMVar# = let x = x in x + +-- |Sleep specified number of microseconds. + +delay# :: Int# -> State# s -> State# s +delay# = let x = x in x + +-- |Block until input is available on specified file descriptor. + +waitRead# :: Int# -> State# s -> State# s +waitRead# = let x = x in x + +-- |Block until output is possible on specified file descriptor. + +waitWrite# :: Int# -> State# s -> State# s +waitWrite# = let x = x in x + +-- | @State\#@ is the primitive, unlifted type of states. It has +-- one type parameter, thus @State\# RealWorld@, or @State\# s@, +-- where s is a type variable. The only purpose of the type parameter +-- is to keep different state threads separate. It is represented by +-- nothing at all. + +data State# s + +-- | @RealWorld@ is deeply magical. It is /primitive/, but it is not +-- /unlifted/ (hence @ptrArg@). We never manipulate values of type +-- @RealWorld@; it\'s only used in the type system, to parameterise @State\#@. + +data RealWorld + +-- |(In a non-concurrent implementation, this can be a singleton +-- type, whose (unique) value is returned by @myThreadId\#@. The +-- other operations can be omitted.) + +data ThreadId# + +fork# :: a -> State# (RealWorld) -> (# State# (RealWorld),ThreadId# #) +fork# = let x = x in x + +forkOn# :: Int# -> a -> State# (RealWorld) -> (# State# (RealWorld),ThreadId# #) +forkOn# = let x = x in x + +killThread# :: ThreadId# -> a -> State# (RealWorld) -> State# (RealWorld) +killThread# = let x = x in x + +yield# :: State# (RealWorld) -> State# (RealWorld) +yield# = let x = x in x + +myThreadId# :: State# (RealWorld) -> (# State# (RealWorld),ThreadId# #) +myThreadId# = let x = x in x + +labelThread# :: ThreadId# -> Addr# -> State# (RealWorld) -> State# (RealWorld) +labelThread# = let x = x in x + +isCurrentThreadBound# :: State# (RealWorld) -> (# State# (RealWorld),Int# #) +isCurrentThreadBound# = let x = x in x + +noDuplicate# :: State# (RealWorld) -> State# (RealWorld) +noDuplicate# = let x = x in x + +threadStatus# :: ThreadId# -> State# (RealWorld) -> (# State# (RealWorld),Int#,Int#,Int# #) +threadStatus# = let x = x in x + +data Weak# b + +mkWeak# :: o -> b -> c -> State# (RealWorld) -> (# State# (RealWorld),Weak# b #) +mkWeak# = let x = x in x + +mkWeakNoFinalizer# :: o -> b -> State# (RealWorld) -> (# State# (RealWorld),Weak# b #) +mkWeakNoFinalizer# = let x = x in x + +-- | @addCFinalizerToWeak# fptr ptr flag eptr w@ attaches a C +-- function pointer @fptr@ to a weak pointer @w@ as a finalizer. If +-- @flag@ is zero, @fptr@ will be called with one argument, +-- @ptr@. Otherwise, it will be called with two arguments, +-- @eptr@ and @ptr@. @addCFinalizerToWeak#@ returns +-- 1 on success, or 0 if @w@ is already dead. + +addCFinalizerToWeak# :: Addr# -> Addr# -> Int# -> Addr# -> Weak# b -> State# (RealWorld) -> (# State# (RealWorld),Int# #) +addCFinalizerToWeak# = let x = x in x + +deRefWeak# :: Weak# a -> State# (RealWorld) -> (# State# (RealWorld),Int#,a #) +deRefWeak# = let x = x in x + +finalizeWeak# :: Weak# a -> State# (RealWorld) -> (# State# (RealWorld),Int#,State# (RealWorld) -> (# State# (RealWorld),() #) #) +finalizeWeak# = let x = x in x + +touch# :: o -> State# (RealWorld) -> State# (RealWorld) +touch# = let x = x in x + +data StablePtr# a + +data StableName# a + +makeStablePtr# :: a -> State# (RealWorld) -> (# State# (RealWorld),StablePtr# a #) +makeStablePtr# = let x = x in x + +deRefStablePtr# :: StablePtr# a -> State# (RealWorld) -> (# State# (RealWorld),a #) +deRefStablePtr# = let x = x in x + +eqStablePtr# :: StablePtr# a -> StablePtr# a -> Int# +eqStablePtr# = let x = x in x + +makeStableName# :: a -> State# (RealWorld) -> (# State# (RealWorld),StableName# a #) +makeStableName# = let x = x in x + +eqStableName# :: StableName# a -> StableName# b -> Int# +eqStableName# = let x = x in x + +stableNameToInt# :: StableName# a -> Int# +stableNameToInt# = let x = x in x + +reallyUnsafePtrEquality# :: a -> a -> Int# +reallyUnsafePtrEquality# = let x = x in x + +par# :: a -> Int# +par# = let x = x in x + +spark# :: a -> State# s -> (# State# s,a #) +spark# = let x = x in x + +seq# :: a -> State# s -> (# State# s,a #) +seq# = let x = x in x + +getSpark# :: State# s -> (# State# s,Int#,a #) +getSpark# = let x = x in x + +-- | Returns the number of sparks in the local spark pool. + +numSparks# :: State# s -> (# State# s,Int# #) +numSparks# = let x = x in x + +parGlobal# :: a -> Int# -> Int# -> Int# -> Int# -> b -> Int# +parGlobal# = let x = x in x + +parLocal# :: a -> Int# -> Int# -> Int# -> Int# -> b -> Int# +parLocal# = let x = x in x + +parAt# :: b -> a -> Int# -> Int# -> Int# -> Int# -> c -> Int# +parAt# = let x = x in x + +parAtAbs# :: a -> Int# -> Int# -> Int# -> Int# -> Int# -> b -> Int# +parAtAbs# = let x = x in x + +parAtRel# :: a -> Int# -> Int# -> Int# -> Int# -> Int# -> b -> Int# +parAtRel# = let x = x in x + +parAtForNow# :: b -> a -> Int# -> Int# -> Int# -> Int# -> c -> Int# +parAtForNow# = let x = x in x + +dataToTag# :: a -> Int# +dataToTag# = let x = x in x + +tagToEnum# :: Int# -> a +tagToEnum# = let x = x in x + +-- |Primitive bytecode type. + +data BCO# + +-- |Convert an @Addr\#@ to a followable Any type. + +addrToAny# :: Addr# -> (# a #) +addrToAny# = let x = x in x + +mkApUpd0# :: BCO# -> (# a #) +mkApUpd0# = let x = x in x + +newBCO# :: ByteArray# -> ByteArray# -> Array# a -> Int# -> ByteArray# -> State# s -> (# State# s,BCO# #) +newBCO# = let x = x in x + +unpackClosure# :: a -> (# Addr#,Array# b,ByteArray# #) +unpackClosure# = let x = x in x + +getApStackVal# :: a -> Int# -> (# Int#,b #) +getApStackVal# = let x = x in x + +getCCSOf# :: a -> State# s -> (# State# s,Addr# #) +getCCSOf# = let x = x in x + +-- | Returns the current @CostCentreStack@ (value is @NULL@ if +-- not profiling). Takes a dummy argument which can be used to +-- avoid the call to @getCCCS\#@ being floated out by the +-- simplifier, which would result in an uninformative stack +-- (\"CAF\"). + +getCurrentCCS# :: a -> State# s -> (# State# s,Addr# #) +getCurrentCCS# = let x = x in x + +-- | The type constructor @Proxy#@ is used to bear witness to some +-- type variable. It\'s used when you want to pass around proxy values +-- for doing things like modelling type applications. A @Proxy#@ +-- is not only unboxed, it also has a polymorphic kind, and has no +-- runtime representation, being totally free. + +data Proxy# a + +-- | Witness for an unboxed @Proxy#@ value, which has no runtime +-- representation. + +proxy# :: Proxy# a +proxy# = let x = x in x + +-- | Evaluates its first argument to head normal form, and then returns its second +-- argument as the result. + +seq :: a -> b -> b +seq = let x = x in x + +-- | The type constructor @Any@ is type to which you can unsafely coerce any +-- lifted type, and back. +-- +-- * It is lifted, and hence represented by a pointer +-- +-- * It does not claim to be a /data/ type, and that\'s important for +-- the code generator, because the code gen may /enter/ a data value +-- but never enters a function value. +-- +-- It\'s also used to instantiate un-constrained type variables after type +-- checking. For example, @length@ has type +-- +-- @length :: forall a. [a] -> Int@ +-- +-- and the list datacon for the empty list has type +-- +-- @[] :: forall a. [a]@ +-- +-- In order to compose these two terms as @length []@ a type +-- application is required, but there is no constraint on the +-- choice. In this situation GHC uses @Any@: +-- +-- @length (Any *) ([] (Any *))@ +-- +-- Note that @Any@ is kind polymorphic, and takes a kind @k@ as its +-- first argument. The kind of @Any@ is thus @forall k. k -> k@. + +data Any k + +-- | The kind @AnyK@ is the kind level counterpart to @Any@. In a +-- kind polymorphic setting, a similar example to the length of the empty +-- list can be given at the type level: +-- +-- @type family Length (l :: [k]) :: Nat@ +-- @type instance Length [] = Zero@ +-- +-- When @Length@ is applied to the empty (promoted) list it will have +-- the kind @Length AnyK []@. +-- +-- @AnyK@ is currently not exported and cannot be used directly, but +-- you might see it in debug output from the compiler. +-- + +data AnyK + +-- | The function @unsafeCoerce\#@ allows you to side-step the typechecker entirely. That +-- is, it allows you to coerce any type into any other type. If you use this function, +-- you had better get it right, otherwise segmentation faults await. It is generally +-- used when you want to write a program that you know is well-typed, but where Haskell\'s +-- type system is not expressive enough to prove that it is well typed. +-- +-- The following uses of @unsafeCoerce\#@ are supposed to work (i.e. not lead to +-- spurious compile-time or run-time crashes): +-- +-- * Casting any lifted type to @Any@ +-- +-- * Casting @Any@ back to the real type +-- +-- * Casting an unboxed type to another unboxed type of the same size +-- (but not coercions between floating-point and integral types) +-- +-- * Casting between two types that have the same runtime representation. One case is when +-- the two types differ only in \"phantom\" type parameters, for example +-- @Ptr Int@ to @Ptr Float@, or @[Int]@ to @[Float]@ when the list is +-- known to be empty. Also, a @newtype@ of a type @T@ has the same representation +-- at runtime as @T@. +-- +-- Other uses of @unsafeCoerce\#@ are undefined. In particular, you should not use +-- @unsafeCoerce\#@ to cast a T to an algebraic data type D, unless T is also +-- an algebraic data type. For example, do not cast @Int->Int@ to @Bool@, even if +-- you later cast that @Bool@ back to @Int->Int@ before applying it. The reasons +-- have to do with GHC\'s internal representation details (for the congnoscenti, data values +-- can be entered but function closures cannot). If you want a safe type to cast things +-- to, use @Any@, which is not an algebraic data type. +-- +-- + +unsafeCoerce# :: a -> b +unsafeCoerce# = let x = x in x + +-- | Emits an event via the RTS tracing framework. The contents +-- of the event is the zero-terminated byte string passed as the first +-- argument. The event will be emitted either to the .eventlog file, +-- or to stderr, depending on the runtime RTS flags. + +traceEvent# :: Addr# -> State# s -> State# s +traceEvent# = let x = x in x + +-- | Emits a marker event via the RTS tracing framework. The contents +-- of the event is the zero-terminated byte string passed as the first +-- argument. The event will be emitted either to the .eventlog file, +-- or to stderr, depending on the runtime RTS flags. + +traceMarker# :: Addr# -> State# s -> State# s +traceMarker# = let x = x in x + +-- | The function @coerce@ allows you to safely convert between values of +-- types that have the same representation with no run-time overhead. In the +-- simplest case you can use it instead of a newtype constructor, to go from +-- the newtype\'s concrete type to the abstract type. But it also works in +-- more complicated settings, e.g. converting a list of newtypes to a list of +-- concrete types. +-- + +coerce :: Coercible a b => a -> b +coerce = let x = x in x + +-- | This two-parameter class has instances for types @a@ and @b@ if +-- the compiler can infer that they have the same representation. This class +-- does not have regular instances; instead they are created on-the-fly during +-- type-checking. Trying to manually declare an instance of @Coercible@ +-- is an error. +-- +-- Nevertheless one can pretend that the following three kinds of instances +-- exist. First, as a trivial base-case: +-- +-- @instance a a@ +-- +-- Furthermore, for every type constructor there is +-- an instance that allows to coerce under the type constructor. For +-- example, let @D@ be a prototypical type constructor (@data@ or @newtype@) with three type arguments, which have roles Nominal, +-- Representational resp. Phantom. Then there is an instance of the form +-- +-- @instance Coercible b b\' => Coercible (D a b c) (D a b\' c\')@ +-- +-- Note that the nominal type arguments are equal, the representational type +-- arguments can differ, but need to have a @Coercible@ instance +-- themself, and the phantom type arguments can be changed arbitrarily. +-- +-- In SafeHaskell code, this instance is only usable if the constructors of +-- every type constructor used in the definition of @D@ (including +-- those of @D@ itself) are in scope. +-- +-- The third kind of instance exists for every @newtype NT = MkNT T@ and +-- comes in two variants, namely +-- +-- @instance Coercible a T => Coercible a NT@ +-- +-- @instance Coercible T b => Coercible NT b@ +-- +-- This instance is only usable if the constructor @MkNT@ is in scope. +-- +-- If, as a library author of a type constructor like @Set a@, you +-- want to prevent a user of your module to write +-- @coerce :: Set T -> Set NT@, +-- you need to set the role of @Set@\'s type parameter to Nominal. +-- + +class Coercible a b + +data Int8X16# + +data Int16X8# + +data Int32X4# + +data Int64X2# + +data Int8X32# + +data Int16X16# + +data Int32X8# + +data Int64X4# + +data Int8X64# + +data Int16X32# + +data Int32X16# + +data Int64X8# + +data Word8X16# + +data Word16X8# + +data Word32X4# + +data Word64X2# + +data Word8X32# + +data Word16X16# + +data Word32X8# + +data Word64X4# + +data Word8X64# + +data Word16X32# + +data Word32X16# + +data Word64X8# + +data FloatX4# + +data DoubleX2# + +data FloatX8# + +data DoubleX4# + +data FloatX16# + +data DoubleX8# + +-- | Broadcast a scalar to all elements of a vector. + +broadcastInt8X16# :: Int# -> Int8X16# +broadcastInt8X16# = let x = x in x + +-- | Broadcast a scalar to all elements of a vector. + +broadcastInt16X8# :: Int# -> Int16X8# +broadcastInt16X8# = let x = x in x + +-- | Broadcast a scalar to all elements of a vector. + +broadcastInt32X4# :: Int# -> Int32X4# +broadcastInt32X4# = let x = x in x + +-- | Broadcast a scalar to all elements of a vector. + +broadcastInt64X2# :: Int# -> Int64X2# +broadcastInt64X2# = let x = x in x + +-- | Broadcast a scalar to all elements of a vector. + +broadcastInt8X32# :: Int# -> Int8X32# +broadcastInt8X32# = let x = x in x + +-- | Broadcast a scalar to all elements of a vector. + +broadcastInt16X16# :: Int# -> Int16X16# +broadcastInt16X16# = let x = x in x + +-- | Broadcast a scalar to all elements of a vector. + +broadcastInt32X8# :: Int# -> Int32X8# +broadcastInt32X8# = let x = x in x + +-- | Broadcast a scalar to all elements of a vector. + +broadcastInt64X4# :: Int# -> Int64X4# +broadcastInt64X4# = let x = x in x + +-- | Broadcast a scalar to all elements of a vector. + +broadcastInt8X64# :: Int# -> Int8X64# +broadcastInt8X64# = let x = x in x + +-- | Broadcast a scalar to all elements of a vector. + +broadcastInt16X32# :: Int# -> Int16X32# +broadcastInt16X32# = let x = x in x + +-- | Broadcast a scalar to all elements of a vector. + +broadcastInt32X16# :: Int# -> Int32X16# +broadcastInt32X16# = let x = x in x + +-- | Broadcast a scalar to all elements of a vector. + +broadcastInt64X8# :: Int# -> Int64X8# +broadcastInt64X8# = let x = x in x + +-- | Broadcast a scalar to all elements of a vector. + +broadcastWord8X16# :: Word# -> Word8X16# +broadcastWord8X16# = let x = x in x + +-- | Broadcast a scalar to all elements of a vector. + +broadcastWord16X8# :: Word# -> Word16X8# +broadcastWord16X8# = let x = x in x + +-- | Broadcast a scalar to all elements of a vector. + +broadcastWord32X4# :: Word# -> Word32X4# +broadcastWord32X4# = let x = x in x + +-- | Broadcast a scalar to all elements of a vector. + +broadcastWord64X2# :: Word# -> Word64X2# +broadcastWord64X2# = let x = x in x + +-- | Broadcast a scalar to all elements of a vector. + +broadcastWord8X32# :: Word# -> Word8X32# +broadcastWord8X32# = let x = x in x + +-- | Broadcast a scalar to all elements of a vector. + +broadcastWord16X16# :: Word# -> Word16X16# +broadcastWord16X16# = let x = x in x + +-- | Broadcast a scalar to all elements of a vector. + +broadcastWord32X8# :: Word# -> Word32X8# +broadcastWord32X8# = let x = x in x + +-- | Broadcast a scalar to all elements of a vector. + +broadcastWord64X4# :: Word# -> Word64X4# +broadcastWord64X4# = let x = x in x + +-- | Broadcast a scalar to all elements of a vector. + +broadcastWord8X64# :: Word# -> Word8X64# +broadcastWord8X64# = let x = x in x + +-- | Broadcast a scalar to all elements of a vector. + +broadcastWord16X32# :: Word# -> Word16X32# +broadcastWord16X32# = let x = x in x + +-- | Broadcast a scalar to all elements of a vector. + +broadcastWord32X16# :: Word# -> Word32X16# +broadcastWord32X16# = let x = x in x + +-- | Broadcast a scalar to all elements of a vector. + +broadcastWord64X8# :: Word# -> Word64X8# +broadcastWord64X8# = let x = x in x + +-- | Broadcast a scalar to all elements of a vector. + +broadcastFloatX4# :: Float# -> FloatX4# +broadcastFloatX4# = let x = x in x + +-- | Broadcast a scalar to all elements of a vector. + +broadcastDoubleX2# :: Double# -> DoubleX2# +broadcastDoubleX2# = let x = x in x + +-- | Broadcast a scalar to all elements of a vector. + +broadcastFloatX8# :: Float# -> FloatX8# +broadcastFloatX8# = let x = x in x + +-- | Broadcast a scalar to all elements of a vector. + +broadcastDoubleX4# :: Double# -> DoubleX4# +broadcastDoubleX4# = let x = x in x + +-- | Broadcast a scalar to all elements of a vector. + +broadcastFloatX16# :: Float# -> FloatX16# +broadcastFloatX16# = let x = x in x + +-- | Broadcast a scalar to all elements of a vector. + +broadcastDoubleX8# :: Double# -> DoubleX8# +broadcastDoubleX8# = let x = x in x + +-- | Pack the elements of an unboxed tuple into a vector. + +packInt8X16# :: (# Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int# #) -> Int8X16# +packInt8X16# = let x = x in x + +-- | Pack the elements of an unboxed tuple into a vector. + +packInt16X8# :: (# Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int# #) -> Int16X8# +packInt16X8# = let x = x in x + +-- | Pack the elements of an unboxed tuple into a vector. + +packInt32X4# :: (# Int#,Int#,Int#,Int# #) -> Int32X4# +packInt32X4# = let x = x in x + +-- | Pack the elements of an unboxed tuple into a vector. + +packInt64X2# :: (# Int#,Int# #) -> Int64X2# +packInt64X2# = let x = x in x + +-- | Pack the elements of an unboxed tuple into a vector. + +packInt8X32# :: (# Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int# #) -> Int8X32# +packInt8X32# = let x = x in x + +-- | Pack the elements of an unboxed tuple into a vector. + +packInt16X16# :: (# Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int# #) -> Int16X16# +packInt16X16# = let x = x in x + +-- | Pack the elements of an unboxed tuple into a vector. + +packInt32X8# :: (# Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int# #) -> Int32X8# +packInt32X8# = let x = x in x + +-- | Pack the elements of an unboxed tuple into a vector. + +packInt64X4# :: (# Int#,Int#,Int#,Int# #) -> Int64X4# +packInt64X4# = let x = x in x + +-- | Pack the elements of an unboxed tuple into a vector. + +packInt8X64# :: (# Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int# #) -> Int8X64# +packInt8X64# = let x = x in x + +-- | Pack the elements of an unboxed tuple into a vector. + +packInt16X32# :: (# Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int# #) -> Int16X32# +packInt16X32# = let x = x in x + +-- | Pack the elements of an unboxed tuple into a vector. + +packInt32X16# :: (# Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int# #) -> Int32X16# +packInt32X16# = let x = x in x + +-- | Pack the elements of an unboxed tuple into a vector. + +packInt64X8# :: (# Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int# #) -> Int64X8# +packInt64X8# = let x = x in x + +-- | Pack the elements of an unboxed tuple into a vector. + +packWord8X16# :: (# Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word# #) -> Word8X16# +packWord8X16# = let x = x in x + +-- | Pack the elements of an unboxed tuple into a vector. + +packWord16X8# :: (# Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word# #) -> Word16X8# +packWord16X8# = let x = x in x + +-- | Pack the elements of an unboxed tuple into a vector. + +packWord32X4# :: (# Word#,Word#,Word#,Word# #) -> Word32X4# +packWord32X4# = let x = x in x + +-- | Pack the elements of an unboxed tuple into a vector. + +packWord64X2# :: (# Word#,Word# #) -> Word64X2# +packWord64X2# = let x = x in x + +-- | Pack the elements of an unboxed tuple into a vector. + +packWord8X32# :: (# Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word# #) -> Word8X32# +packWord8X32# = let x = x in x + +-- | Pack the elements of an unboxed tuple into a vector. + +packWord16X16# :: (# Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word# #) -> Word16X16# +packWord16X16# = let x = x in x + +-- | Pack the elements of an unboxed tuple into a vector. + +packWord32X8# :: (# Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word# #) -> Word32X8# +packWord32X8# = let x = x in x + +-- | Pack the elements of an unboxed tuple into a vector. + +packWord64X4# :: (# Word#,Word#,Word#,Word# #) -> Word64X4# +packWord64X4# = let x = x in x + +-- | Pack the elements of an unboxed tuple into a vector. + +packWord8X64# :: (# Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word# #) -> Word8X64# +packWord8X64# = let x = x in x + +-- | Pack the elements of an unboxed tuple into a vector. + +packWord16X32# :: (# Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word# #) -> Word16X32# +packWord16X32# = let x = x in x + +-- | Pack the elements of an unboxed tuple into a vector. + +packWord32X16# :: (# Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word# #) -> Word32X16# +packWord32X16# = let x = x in x + +-- | Pack the elements of an unboxed tuple into a vector. + +packWord64X8# :: (# Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word# #) -> Word64X8# +packWord64X8# = let x = x in x + +-- | Pack the elements of an unboxed tuple into a vector. + +packFloatX4# :: (# Float#,Float#,Float#,Float# #) -> FloatX4# +packFloatX4# = let x = x in x + +-- | Pack the elements of an unboxed tuple into a vector. + +packDoubleX2# :: (# Double#,Double# #) -> DoubleX2# +packDoubleX2# = let x = x in x + +-- | Pack the elements of an unboxed tuple into a vector. + +packFloatX8# :: (# Float#,Float#,Float#,Float#,Float#,Float#,Float#,Float# #) -> FloatX8# +packFloatX8# = let x = x in x + +-- | Pack the elements of an unboxed tuple into a vector. + +packDoubleX4# :: (# Double#,Double#,Double#,Double# #) -> DoubleX4# +packDoubleX4# = let x = x in x + +-- | Pack the elements of an unboxed tuple into a vector. + +packFloatX16# :: (# Float#,Float#,Float#,Float#,Float#,Float#,Float#,Float#,Float#,Float#,Float#,Float#,Float#,Float#,Float#,Float# #) -> FloatX16# +packFloatX16# = let x = x in x + +-- | Pack the elements of an unboxed tuple into a vector. + +packDoubleX8# :: (# Double#,Double#,Double#,Double#,Double#,Double#,Double#,Double# #) -> DoubleX8# +packDoubleX8# = let x = x in x + +-- | Unpack the elements of a vector into an unboxed tuple. # + +unpackInt8X16# :: Int8X16# -> (# Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int# #) +unpackInt8X16# = let x = x in x + +-- | Unpack the elements of a vector into an unboxed tuple. # + +unpackInt16X8# :: Int16X8# -> (# Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int# #) +unpackInt16X8# = let x = x in x + +-- | Unpack the elements of a vector into an unboxed tuple. # + +unpackInt32X4# :: Int32X4# -> (# Int#,Int#,Int#,Int# #) +unpackInt32X4# = let x = x in x + +-- | Unpack the elements of a vector into an unboxed tuple. # + +unpackInt64X2# :: Int64X2# -> (# Int#,Int# #) +unpackInt64X2# = let x = x in x + +-- | Unpack the elements of a vector into an unboxed tuple. # + +unpackInt8X32# :: Int8X32# -> (# Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int# #) +unpackInt8X32# = let x = x in x + +-- | Unpack the elements of a vector into an unboxed tuple. # + +unpackInt16X16# :: Int16X16# -> (# Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int# #) +unpackInt16X16# = let x = x in x + +-- | Unpack the elements of a vector into an unboxed tuple. # + +unpackInt32X8# :: Int32X8# -> (# Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int# #) +unpackInt32X8# = let x = x in x + +-- | Unpack the elements of a vector into an unboxed tuple. # + +unpackInt64X4# :: Int64X4# -> (# Int#,Int#,Int#,Int# #) +unpackInt64X4# = let x = x in x + +-- | Unpack the elements of a vector into an unboxed tuple. # + +unpackInt8X64# :: Int8X64# -> (# Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int# #) +unpackInt8X64# = let x = x in x + +-- | Unpack the elements of a vector into an unboxed tuple. # + +unpackInt16X32# :: Int16X32# -> (# Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int# #) +unpackInt16X32# = let x = x in x + +-- | Unpack the elements of a vector into an unboxed tuple. # + +unpackInt32X16# :: Int32X16# -> (# Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int# #) +unpackInt32X16# = let x = x in x + +-- | Unpack the elements of a vector into an unboxed tuple. # + +unpackInt64X8# :: Int64X8# -> (# Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int# #) +unpackInt64X8# = let x = x in x + +-- | Unpack the elements of a vector into an unboxed tuple. # + +unpackWord8X16# :: Word8X16# -> (# Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word# #) +unpackWord8X16# = let x = x in x + +-- | Unpack the elements of a vector into an unboxed tuple. # + +unpackWord16X8# :: Word16X8# -> (# Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word# #) +unpackWord16X8# = let x = x in x + +-- | Unpack the elements of a vector into an unboxed tuple. # + +unpackWord32X4# :: Word32X4# -> (# Word#,Word#,Word#,Word# #) +unpackWord32X4# = let x = x in x + +-- | Unpack the elements of a vector into an unboxed tuple. # + +unpackWord64X2# :: Word64X2# -> (# Word#,Word# #) +unpackWord64X2# = let x = x in x + +-- | Unpack the elements of a vector into an unboxed tuple. # + +unpackWord8X32# :: Word8X32# -> (# Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word# #) +unpackWord8X32# = let x = x in x + +-- | Unpack the elements of a vector into an unboxed tuple. # + +unpackWord16X16# :: Word16X16# -> (# Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word# #) +unpackWord16X16# = let x = x in x + +-- | Unpack the elements of a vector into an unboxed tuple. # + +unpackWord32X8# :: Word32X8# -> (# Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word# #) +unpackWord32X8# = let x = x in x + +-- | Unpack the elements of a vector into an unboxed tuple. # + +unpackWord64X4# :: Word64X4# -> (# Word#,Word#,Word#,Word# #) +unpackWord64X4# = let x = x in x + +-- | Unpack the elements of a vector into an unboxed tuple. # + +unpackWord8X64# :: Word8X64# -> (# Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word# #) +unpackWord8X64# = let x = x in x + +-- | Unpack the elements of a vector into an unboxed tuple. # + +unpackWord16X32# :: Word16X32# -> (# Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word# #) +unpackWord16X32# = let x = x in x + +-- | Unpack the elements of a vector into an unboxed tuple. # + +unpackWord32X16# :: Word32X16# -> (# Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word# #) +unpackWord32X16# = let x = x in x + +-- | Unpack the elements of a vector into an unboxed tuple. # + +unpackWord64X8# :: Word64X8# -> (# Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word# #) +unpackWord64X8# = let x = x in x + +-- | Unpack the elements of a vector into an unboxed tuple. # + +unpackFloatX4# :: FloatX4# -> (# Float#,Float#,Float#,Float# #) +unpackFloatX4# = let x = x in x + +-- | Unpack the elements of a vector into an unboxed tuple. # + +unpackDoubleX2# :: DoubleX2# -> (# Double#,Double# #) +unpackDoubleX2# = let x = x in x + +-- | Unpack the elements of a vector into an unboxed tuple. # + +unpackFloatX8# :: FloatX8# -> (# Float#,Float#,Float#,Float#,Float#,Float#,Float#,Float# #) +unpackFloatX8# = let x = x in x + +-- | Unpack the elements of a vector into an unboxed tuple. # + +unpackDoubleX4# :: DoubleX4# -> (# Double#,Double#,Double#,Double# #) +unpackDoubleX4# = let x = x in x + +-- | Unpack the elements of a vector into an unboxed tuple. # + +unpackFloatX16# :: FloatX16# -> (# Float#,Float#,Float#,Float#,Float#,Float#,Float#,Float#,Float#,Float#,Float#,Float#,Float#,Float#,Float#,Float# #) +unpackFloatX16# = let x = x in x + +-- | Unpack the elements of a vector into an unboxed tuple. # + +unpackDoubleX8# :: DoubleX8# -> (# Double#,Double#,Double#,Double#,Double#,Double#,Double#,Double# #) +unpackDoubleX8# = let x = x in x + +-- | Insert a scalar at the given position in a vector. + +insertInt8X16# :: Int8X16# -> Int# -> Int# -> Int8X16# +insertInt8X16# = let x = x in x + +-- | Insert a scalar at the given position in a vector. + +insertInt16X8# :: Int16X8# -> Int# -> Int# -> Int16X8# +insertInt16X8# = let x = x in x + +-- | Insert a scalar at the given position in a vector. + +insertInt32X4# :: Int32X4# -> Int# -> Int# -> Int32X4# +insertInt32X4# = let x = x in x + +-- | Insert a scalar at the given position in a vector. + +insertInt64X2# :: Int64X2# -> Int# -> Int# -> Int64X2# +insertInt64X2# = let x = x in x + +-- | Insert a scalar at the given position in a vector. + +insertInt8X32# :: Int8X32# -> Int# -> Int# -> Int8X32# +insertInt8X32# = let x = x in x + +-- | Insert a scalar at the given position in a vector. + +insertInt16X16# :: Int16X16# -> Int# -> Int# -> Int16X16# +insertInt16X16# = let x = x in x + +-- | Insert a scalar at the given position in a vector. + +insertInt32X8# :: Int32X8# -> Int# -> Int# -> Int32X8# +insertInt32X8# = let x = x in x + +-- | Insert a scalar at the given position in a vector. + +insertInt64X4# :: Int64X4# -> Int# -> Int# -> Int64X4# +insertInt64X4# = let x = x in x + +-- | Insert a scalar at the given position in a vector. + +insertInt8X64# :: Int8X64# -> Int# -> Int# -> Int8X64# +insertInt8X64# = let x = x in x + +-- | Insert a scalar at the given position in a vector. + +insertInt16X32# :: Int16X32# -> Int# -> Int# -> Int16X32# +insertInt16X32# = let x = x in x + +-- | Insert a scalar at the given position in a vector. + +insertInt32X16# :: Int32X16# -> Int# -> Int# -> Int32X16# +insertInt32X16# = let x = x in x + +-- | Insert a scalar at the given position in a vector. + +insertInt64X8# :: Int64X8# -> Int# -> Int# -> Int64X8# +insertInt64X8# = let x = x in x + +-- | Insert a scalar at the given position in a vector. + +insertWord8X16# :: Word8X16# -> Word# -> Int# -> Word8X16# +insertWord8X16# = let x = x in x + +-- | Insert a scalar at the given position in a vector. + +insertWord16X8# :: Word16X8# -> Word# -> Int# -> Word16X8# +insertWord16X8# = let x = x in x + +-- | Insert a scalar at the given position in a vector. + +insertWord32X4# :: Word32X4# -> Word# -> Int# -> Word32X4# +insertWord32X4# = let x = x in x + +-- | Insert a scalar at the given position in a vector. + +insertWord64X2# :: Word64X2# -> Word# -> Int# -> Word64X2# +insertWord64X2# = let x = x in x + +-- | Insert a scalar at the given position in a vector. + +insertWord8X32# :: Word8X32# -> Word# -> Int# -> Word8X32# +insertWord8X32# = let x = x in x + +-- | Insert a scalar at the given position in a vector. + +insertWord16X16# :: Word16X16# -> Word# -> Int# -> Word16X16# +insertWord16X16# = let x = x in x + +-- | Insert a scalar at the given position in a vector. + +insertWord32X8# :: Word32X8# -> Word# -> Int# -> Word32X8# +insertWord32X8# = let x = x in x + +-- | Insert a scalar at the given position in a vector. + +insertWord64X4# :: Word64X4# -> Word# -> Int# -> Word64X4# +insertWord64X4# = let x = x in x + +-- | Insert a scalar at the given position in a vector. + +insertWord8X64# :: Word8X64# -> Word# -> Int# -> Word8X64# +insertWord8X64# = let x = x in x + +-- | Insert a scalar at the given position in a vector. + +insertWord16X32# :: Word16X32# -> Word# -> Int# -> Word16X32# +insertWord16X32# = let x = x in x + +-- | Insert a scalar at the given position in a vector. + +insertWord32X16# :: Word32X16# -> Word# -> Int# -> Word32X16# +insertWord32X16# = let x = x in x + +-- | Insert a scalar at the given position in a vector. + +insertWord64X8# :: Word64X8# -> Word# -> Int# -> Word64X8# +insertWord64X8# = let x = x in x + +-- | Insert a scalar at the given position in a vector. + +insertFloatX4# :: FloatX4# -> Float# -> Int# -> FloatX4# +insertFloatX4# = let x = x in x + +-- | Insert a scalar at the given position in a vector. + +insertDoubleX2# :: DoubleX2# -> Double# -> Int# -> DoubleX2# +insertDoubleX2# = let x = x in x + +-- | Insert a scalar at the given position in a vector. + +insertFloatX8# :: FloatX8# -> Float# -> Int# -> FloatX8# +insertFloatX8# = let x = x in x + +-- | Insert a scalar at the given position in a vector. + +insertDoubleX4# :: DoubleX4# -> Double# -> Int# -> DoubleX4# +insertDoubleX4# = let x = x in x + +-- | Insert a scalar at the given position in a vector. + +insertFloatX16# :: FloatX16# -> Float# -> Int# -> FloatX16# +insertFloatX16# = let x = x in x + +-- | Insert a scalar at the given position in a vector. + +insertDoubleX8# :: DoubleX8# -> Double# -> Int# -> DoubleX8# +insertDoubleX8# = let x = x in x + +-- | Add two vectors element-wise. + +plusInt8X16# :: Int8X16# -> Int8X16# -> Int8X16# +plusInt8X16# = let x = x in x + +-- | Add two vectors element-wise. + +plusInt16X8# :: Int16X8# -> Int16X8# -> Int16X8# +plusInt16X8# = let x = x in x + +-- | Add two vectors element-wise. + +plusInt32X4# :: Int32X4# -> Int32X4# -> Int32X4# +plusInt32X4# = let x = x in x + +-- | Add two vectors element-wise. + +plusInt64X2# :: Int64X2# -> Int64X2# -> Int64X2# +plusInt64X2# = let x = x in x + +-- | Add two vectors element-wise. + +plusInt8X32# :: Int8X32# -> Int8X32# -> Int8X32# +plusInt8X32# = let x = x in x + +-- | Add two vectors element-wise. + +plusInt16X16# :: Int16X16# -> Int16X16# -> Int16X16# +plusInt16X16# = let x = x in x + +-- | Add two vectors element-wise. + +plusInt32X8# :: Int32X8# -> Int32X8# -> Int32X8# +plusInt32X8# = let x = x in x + +-- | Add two vectors element-wise. + +plusInt64X4# :: Int64X4# -> Int64X4# -> Int64X4# +plusInt64X4# = let x = x in x + +-- | Add two vectors element-wise. + +plusInt8X64# :: Int8X64# -> Int8X64# -> Int8X64# +plusInt8X64# = let x = x in x + +-- | Add two vectors element-wise. + +plusInt16X32# :: Int16X32# -> Int16X32# -> Int16X32# +plusInt16X32# = let x = x in x + +-- | Add two vectors element-wise. + +plusInt32X16# :: Int32X16# -> Int32X16# -> Int32X16# +plusInt32X16# = let x = x in x + +-- | Add two vectors element-wise. + +plusInt64X8# :: Int64X8# -> Int64X8# -> Int64X8# +plusInt64X8# = let x = x in x + +-- | Add two vectors element-wise. + +plusWord8X16# :: Word8X16# -> Word8X16# -> Word8X16# +plusWord8X16# = let x = x in x + +-- | Add two vectors element-wise. + +plusWord16X8# :: Word16X8# -> Word16X8# -> Word16X8# +plusWord16X8# = let x = x in x + +-- | Add two vectors element-wise. + +plusWord32X4# :: Word32X4# -> Word32X4# -> Word32X4# +plusWord32X4# = let x = x in x + +-- | Add two vectors element-wise. + +plusWord64X2# :: Word64X2# -> Word64X2# -> Word64X2# +plusWord64X2# = let x = x in x + +-- | Add two vectors element-wise. + +plusWord8X32# :: Word8X32# -> Word8X32# -> Word8X32# +plusWord8X32# = let x = x in x + +-- | Add two vectors element-wise. + +plusWord16X16# :: Word16X16# -> Word16X16# -> Word16X16# +plusWord16X16# = let x = x in x + +-- | Add two vectors element-wise. + +plusWord32X8# :: Word32X8# -> Word32X8# -> Word32X8# +plusWord32X8# = let x = x in x + +-- | Add two vectors element-wise. + +plusWord64X4# :: Word64X4# -> Word64X4# -> Word64X4# +plusWord64X4# = let x = x in x + +-- | Add two vectors element-wise. + +plusWord8X64# :: Word8X64# -> Word8X64# -> Word8X64# +plusWord8X64# = let x = x in x + +-- | Add two vectors element-wise. + +plusWord16X32# :: Word16X32# -> Word16X32# -> Word16X32# +plusWord16X32# = let x = x in x + +-- | Add two vectors element-wise. + +plusWord32X16# :: Word32X16# -> Word32X16# -> Word32X16# +plusWord32X16# = let x = x in x + +-- | Add two vectors element-wise. + +plusWord64X8# :: Word64X8# -> Word64X8# -> Word64X8# +plusWord64X8# = let x = x in x + +-- | Add two vectors element-wise. + +plusFloatX4# :: FloatX4# -> FloatX4# -> FloatX4# +plusFloatX4# = let x = x in x + +-- | Add two vectors element-wise. + +plusDoubleX2# :: DoubleX2# -> DoubleX2# -> DoubleX2# +plusDoubleX2# = let x = x in x + +-- | Add two vectors element-wise. + +plusFloatX8# :: FloatX8# -> FloatX8# -> FloatX8# +plusFloatX8# = let x = x in x + +-- | Add two vectors element-wise. + +plusDoubleX4# :: DoubleX4# -> DoubleX4# -> DoubleX4# +plusDoubleX4# = let x = x in x + +-- | Add two vectors element-wise. + +plusFloatX16# :: FloatX16# -> FloatX16# -> FloatX16# +plusFloatX16# = let x = x in x + +-- | Add two vectors element-wise. + +plusDoubleX8# :: DoubleX8# -> DoubleX8# -> DoubleX8# +plusDoubleX8# = let x = x in x + +-- | Subtract two vectors element-wise. + +minusInt8X16# :: Int8X16# -> Int8X16# -> Int8X16# +minusInt8X16# = let x = x in x + +-- | Subtract two vectors element-wise. + +minusInt16X8# :: Int16X8# -> Int16X8# -> Int16X8# +minusInt16X8# = let x = x in x + +-- | Subtract two vectors element-wise. + +minusInt32X4# :: Int32X4# -> Int32X4# -> Int32X4# +minusInt32X4# = let x = x in x + +-- | Subtract two vectors element-wise. + +minusInt64X2# :: Int64X2# -> Int64X2# -> Int64X2# +minusInt64X2# = let x = x in x + +-- | Subtract two vectors element-wise. + +minusInt8X32# :: Int8X32# -> Int8X32# -> Int8X32# +minusInt8X32# = let x = x in x + +-- | Subtract two vectors element-wise. + +minusInt16X16# :: Int16X16# -> Int16X16# -> Int16X16# +minusInt16X16# = let x = x in x + +-- | Subtract two vectors element-wise. + +minusInt32X8# :: Int32X8# -> Int32X8# -> Int32X8# +minusInt32X8# = let x = x in x + +-- | Subtract two vectors element-wise. + +minusInt64X4# :: Int64X4# -> Int64X4# -> Int64X4# +minusInt64X4# = let x = x in x + +-- | Subtract two vectors element-wise. + +minusInt8X64# :: Int8X64# -> Int8X64# -> Int8X64# +minusInt8X64# = let x = x in x + +-- | Subtract two vectors element-wise. + +minusInt16X32# :: Int16X32# -> Int16X32# -> Int16X32# +minusInt16X32# = let x = x in x + +-- | Subtract two vectors element-wise. + +minusInt32X16# :: Int32X16# -> Int32X16# -> Int32X16# +minusInt32X16# = let x = x in x + +-- | Subtract two vectors element-wise. + +minusInt64X8# :: Int64X8# -> Int64X8# -> Int64X8# +minusInt64X8# = let x = x in x + +-- | Subtract two vectors element-wise. + +minusWord8X16# :: Word8X16# -> Word8X16# -> Word8X16# +minusWord8X16# = let x = x in x + +-- | Subtract two vectors element-wise. + +minusWord16X8# :: Word16X8# -> Word16X8# -> Word16X8# +minusWord16X8# = let x = x in x + +-- | Subtract two vectors element-wise. + +minusWord32X4# :: Word32X4# -> Word32X4# -> Word32X4# +minusWord32X4# = let x = x in x + +-- | Subtract two vectors element-wise. + +minusWord64X2# :: Word64X2# -> Word64X2# -> Word64X2# +minusWord64X2# = let x = x in x + +-- | Subtract two vectors element-wise. + +minusWord8X32# :: Word8X32# -> Word8X32# -> Word8X32# +minusWord8X32# = let x = x in x + +-- | Subtract two vectors element-wise. + +minusWord16X16# :: Word16X16# -> Word16X16# -> Word16X16# +minusWord16X16# = let x = x in x + +-- | Subtract two vectors element-wise. + +minusWord32X8# :: Word32X8# -> Word32X8# -> Word32X8# +minusWord32X8# = let x = x in x + +-- | Subtract two vectors element-wise. + +minusWord64X4# :: Word64X4# -> Word64X4# -> Word64X4# +minusWord64X4# = let x = x in x + +-- | Subtract two vectors element-wise. + +minusWord8X64# :: Word8X64# -> Word8X64# -> Word8X64# +minusWord8X64# = let x = x in x + +-- | Subtract two vectors element-wise. + +minusWord16X32# :: Word16X32# -> Word16X32# -> Word16X32# +minusWord16X32# = let x = x in x + +-- | Subtract two vectors element-wise. + +minusWord32X16# :: Word32X16# -> Word32X16# -> Word32X16# +minusWord32X16# = let x = x in x + +-- | Subtract two vectors element-wise. + +minusWord64X8# :: Word64X8# -> Word64X8# -> Word64X8# +minusWord64X8# = let x = x in x + +-- | Subtract two vectors element-wise. + +minusFloatX4# :: FloatX4# -> FloatX4# -> FloatX4# +minusFloatX4# = let x = x in x + +-- | Subtract two vectors element-wise. + +minusDoubleX2# :: DoubleX2# -> DoubleX2# -> DoubleX2# +minusDoubleX2# = let x = x in x + +-- | Subtract two vectors element-wise. + +minusFloatX8# :: FloatX8# -> FloatX8# -> FloatX8# +minusFloatX8# = let x = x in x + +-- | Subtract two vectors element-wise. + +minusDoubleX4# :: DoubleX4# -> DoubleX4# -> DoubleX4# +minusDoubleX4# = let x = x in x + +-- | Subtract two vectors element-wise. + +minusFloatX16# :: FloatX16# -> FloatX16# -> FloatX16# +minusFloatX16# = let x = x in x + +-- | Subtract two vectors element-wise. + +minusDoubleX8# :: DoubleX8# -> DoubleX8# -> DoubleX8# +minusDoubleX8# = let x = x in x + +-- | Multiply two vectors element-wise. + +timesInt8X16# :: Int8X16# -> Int8X16# -> Int8X16# +timesInt8X16# = let x = x in x + +-- | Multiply two vectors element-wise. + +timesInt16X8# :: Int16X8# -> Int16X8# -> Int16X8# +timesInt16X8# = let x = x in x + +-- | Multiply two vectors element-wise. + +timesInt32X4# :: Int32X4# -> Int32X4# -> Int32X4# +timesInt32X4# = let x = x in x + +-- | Multiply two vectors element-wise. + +timesInt64X2# :: Int64X2# -> Int64X2# -> Int64X2# +timesInt64X2# = let x = x in x + +-- | Multiply two vectors element-wise. + +timesInt8X32# :: Int8X32# -> Int8X32# -> Int8X32# +timesInt8X32# = let x = x in x + +-- | Multiply two vectors element-wise. + +timesInt16X16# :: Int16X16# -> Int16X16# -> Int16X16# +timesInt16X16# = let x = x in x + +-- | Multiply two vectors element-wise. + +timesInt32X8# :: Int32X8# -> Int32X8# -> Int32X8# +timesInt32X8# = let x = x in x + +-- | Multiply two vectors element-wise. + +timesInt64X4# :: Int64X4# -> Int64X4# -> Int64X4# +timesInt64X4# = let x = x in x + +-- | Multiply two vectors element-wise. + +timesInt8X64# :: Int8X64# -> Int8X64# -> Int8X64# +timesInt8X64# = let x = x in x + +-- | Multiply two vectors element-wise. + +timesInt16X32# :: Int16X32# -> Int16X32# -> Int16X32# +timesInt16X32# = let x = x in x + +-- | Multiply two vectors element-wise. + +timesInt32X16# :: Int32X16# -> Int32X16# -> Int32X16# +timesInt32X16# = let x = x in x + +-- | Multiply two vectors element-wise. + +timesInt64X8# :: Int64X8# -> Int64X8# -> Int64X8# +timesInt64X8# = let x = x in x + +-- | Multiply two vectors element-wise. + +timesWord8X16# :: Word8X16# -> Word8X16# -> Word8X16# +timesWord8X16# = let x = x in x + +-- | Multiply two vectors element-wise. + +timesWord16X8# :: Word16X8# -> Word16X8# -> Word16X8# +timesWord16X8# = let x = x in x + +-- | Multiply two vectors element-wise. + +timesWord32X4# :: Word32X4# -> Word32X4# -> Word32X4# +timesWord32X4# = let x = x in x + +-- | Multiply two vectors element-wise. + +timesWord64X2# :: Word64X2# -> Word64X2# -> Word64X2# +timesWord64X2# = let x = x in x + +-- | Multiply two vectors element-wise. + +timesWord8X32# :: Word8X32# -> Word8X32# -> Word8X32# +timesWord8X32# = let x = x in x + +-- | Multiply two vectors element-wise. + +timesWord16X16# :: Word16X16# -> Word16X16# -> Word16X16# +timesWord16X16# = let x = x in x + +-- | Multiply two vectors element-wise. + +timesWord32X8# :: Word32X8# -> Word32X8# -> Word32X8# +timesWord32X8# = let x = x in x + +-- | Multiply two vectors element-wise. + +timesWord64X4# :: Word64X4# -> Word64X4# -> Word64X4# +timesWord64X4# = let x = x in x + +-- | Multiply two vectors element-wise. + +timesWord8X64# :: Word8X64# -> Word8X64# -> Word8X64# +timesWord8X64# = let x = x in x + +-- | Multiply two vectors element-wise. + +timesWord16X32# :: Word16X32# -> Word16X32# -> Word16X32# +timesWord16X32# = let x = x in x + +-- | Multiply two vectors element-wise. + +timesWord32X16# :: Word32X16# -> Word32X16# -> Word32X16# +timesWord32X16# = let x = x in x + +-- | Multiply two vectors element-wise. + +timesWord64X8# :: Word64X8# -> Word64X8# -> Word64X8# +timesWord64X8# = let x = x in x + +-- | Multiply two vectors element-wise. + +timesFloatX4# :: FloatX4# -> FloatX4# -> FloatX4# +timesFloatX4# = let x = x in x + +-- | Multiply two vectors element-wise. + +timesDoubleX2# :: DoubleX2# -> DoubleX2# -> DoubleX2# +timesDoubleX2# = let x = x in x + +-- | Multiply two vectors element-wise. + +timesFloatX8# :: FloatX8# -> FloatX8# -> FloatX8# +timesFloatX8# = let x = x in x + +-- | Multiply two vectors element-wise. + +timesDoubleX4# :: DoubleX4# -> DoubleX4# -> DoubleX4# +timesDoubleX4# = let x = x in x + +-- | Multiply two vectors element-wise. + +timesFloatX16# :: FloatX16# -> FloatX16# -> FloatX16# +timesFloatX16# = let x = x in x + +-- | Multiply two vectors element-wise. + +timesDoubleX8# :: DoubleX8# -> DoubleX8# -> DoubleX8# +timesDoubleX8# = let x = x in x + +-- | Divide two vectors element-wise. + +divideFloatX4# :: FloatX4# -> FloatX4# -> FloatX4# +divideFloatX4# = let x = x in x + +-- | Divide two vectors element-wise. + +divideDoubleX2# :: DoubleX2# -> DoubleX2# -> DoubleX2# +divideDoubleX2# = let x = x in x + +-- | Divide two vectors element-wise. + +divideFloatX8# :: FloatX8# -> FloatX8# -> FloatX8# +divideFloatX8# = let x = x in x + +-- | Divide two vectors element-wise. + +divideDoubleX4# :: DoubleX4# -> DoubleX4# -> DoubleX4# +divideDoubleX4# = let x = x in x + +-- | Divide two vectors element-wise. + +divideFloatX16# :: FloatX16# -> FloatX16# -> FloatX16# +divideFloatX16# = let x = x in x + +-- | Divide two vectors element-wise. + +divideDoubleX8# :: DoubleX8# -> DoubleX8# -> DoubleX8# +divideDoubleX8# = let x = x in x + +-- | Rounds towards zero element-wise. + +quotInt8X16# :: Int8X16# -> Int8X16# -> Int8X16# +quotInt8X16# = let x = x in x + +-- | Rounds towards zero element-wise. + +quotInt16X8# :: Int16X8# -> Int16X8# -> Int16X8# +quotInt16X8# = let x = x in x + +-- | Rounds towards zero element-wise. + +quotInt32X4# :: Int32X4# -> Int32X4# -> Int32X4# +quotInt32X4# = let x = x in x + +-- | Rounds towards zero element-wise. + +quotInt64X2# :: Int64X2# -> Int64X2# -> Int64X2# +quotInt64X2# = let x = x in x + +-- | Rounds towards zero element-wise. + +quotInt8X32# :: Int8X32# -> Int8X32# -> Int8X32# +quotInt8X32# = let x = x in x + +-- | Rounds towards zero element-wise. + +quotInt16X16# :: Int16X16# -> Int16X16# -> Int16X16# +quotInt16X16# = let x = x in x + +-- | Rounds towards zero element-wise. + +quotInt32X8# :: Int32X8# -> Int32X8# -> Int32X8# +quotInt32X8# = let x = x in x + +-- | Rounds towards zero element-wise. + +quotInt64X4# :: Int64X4# -> Int64X4# -> Int64X4# +quotInt64X4# = let x = x in x + +-- | Rounds towards zero element-wise. + +quotInt8X64# :: Int8X64# -> Int8X64# -> Int8X64# +quotInt8X64# = let x = x in x + +-- | Rounds towards zero element-wise. + +quotInt16X32# :: Int16X32# -> Int16X32# -> Int16X32# +quotInt16X32# = let x = x in x + +-- | Rounds towards zero element-wise. + +quotInt32X16# :: Int32X16# -> Int32X16# -> Int32X16# +quotInt32X16# = let x = x in x + +-- | Rounds towards zero element-wise. + +quotInt64X8# :: Int64X8# -> Int64X8# -> Int64X8# +quotInt64X8# = let x = x in x + +-- | Rounds towards zero element-wise. + +quotWord8X16# :: Word8X16# -> Word8X16# -> Word8X16# +quotWord8X16# = let x = x in x + +-- | Rounds towards zero element-wise. + +quotWord16X8# :: Word16X8# -> Word16X8# -> Word16X8# +quotWord16X8# = let x = x in x + +-- | Rounds towards zero element-wise. + +quotWord32X4# :: Word32X4# -> Word32X4# -> Word32X4# +quotWord32X4# = let x = x in x + +-- | Rounds towards zero element-wise. + +quotWord64X2# :: Word64X2# -> Word64X2# -> Word64X2# +quotWord64X2# = let x = x in x + +-- | Rounds towards zero element-wise. + +quotWord8X32# :: Word8X32# -> Word8X32# -> Word8X32# +quotWord8X32# = let x = x in x + +-- | Rounds towards zero element-wise. + +quotWord16X16# :: Word16X16# -> Word16X16# -> Word16X16# +quotWord16X16# = let x = x in x + +-- | Rounds towards zero element-wise. + +quotWord32X8# :: Word32X8# -> Word32X8# -> Word32X8# +quotWord32X8# = let x = x in x + +-- | Rounds towards zero element-wise. + +quotWord64X4# :: Word64X4# -> Word64X4# -> Word64X4# +quotWord64X4# = let x = x in x + +-- | Rounds towards zero element-wise. + +quotWord8X64# :: Word8X64# -> Word8X64# -> Word8X64# +quotWord8X64# = let x = x in x + +-- | Rounds towards zero element-wise. + +quotWord16X32# :: Word16X32# -> Word16X32# -> Word16X32# +quotWord16X32# = let x = x in x + +-- | Rounds towards zero element-wise. + +quotWord32X16# :: Word32X16# -> Word32X16# -> Word32X16# +quotWord32X16# = let x = x in x + +-- | Rounds towards zero element-wise. + +quotWord64X8# :: Word64X8# -> Word64X8# -> Word64X8# +quotWord64X8# = let x = x in x + +-- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. + +remInt8X16# :: Int8X16# -> Int8X16# -> Int8X16# +remInt8X16# = let x = x in x + +-- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. + +remInt16X8# :: Int16X8# -> Int16X8# -> Int16X8# +remInt16X8# = let x = x in x + +-- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. + +remInt32X4# :: Int32X4# -> Int32X4# -> Int32X4# +remInt32X4# = let x = x in x + +-- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. + +remInt64X2# :: Int64X2# -> Int64X2# -> Int64X2# +remInt64X2# = let x = x in x + +-- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. + +remInt8X32# :: Int8X32# -> Int8X32# -> Int8X32# +remInt8X32# = let x = x in x + +-- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. + +remInt16X16# :: Int16X16# -> Int16X16# -> Int16X16# +remInt16X16# = let x = x in x + +-- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. + +remInt32X8# :: Int32X8# -> Int32X8# -> Int32X8# +remInt32X8# = let x = x in x + +-- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. + +remInt64X4# :: Int64X4# -> Int64X4# -> Int64X4# +remInt64X4# = let x = x in x + +-- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. + +remInt8X64# :: Int8X64# -> Int8X64# -> Int8X64# +remInt8X64# = let x = x in x + +-- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. + +remInt16X32# :: Int16X32# -> Int16X32# -> Int16X32# +remInt16X32# = let x = x in x + +-- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. + +remInt32X16# :: Int32X16# -> Int32X16# -> Int32X16# +remInt32X16# = let x = x in x + +-- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. + +remInt64X8# :: Int64X8# -> Int64X8# -> Int64X8# +remInt64X8# = let x = x in x + +-- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. + +remWord8X16# :: Word8X16# -> Word8X16# -> Word8X16# +remWord8X16# = let x = x in x + +-- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. + +remWord16X8# :: Word16X8# -> Word16X8# -> Word16X8# +remWord16X8# = let x = x in x + +-- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. + +remWord32X4# :: Word32X4# -> Word32X4# -> Word32X4# +remWord32X4# = let x = x in x + +-- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. + +remWord64X2# :: Word64X2# -> Word64X2# -> Word64X2# +remWord64X2# = let x = x in x + +-- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. + +remWord8X32# :: Word8X32# -> Word8X32# -> Word8X32# +remWord8X32# = let x = x in x + +-- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. + +remWord16X16# :: Word16X16# -> Word16X16# -> Word16X16# +remWord16X16# = let x = x in x + +-- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. + +remWord32X8# :: Word32X8# -> Word32X8# -> Word32X8# +remWord32X8# = let x = x in x + +-- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. + +remWord64X4# :: Word64X4# -> Word64X4# -> Word64X4# +remWord64X4# = let x = x in x + +-- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. + +remWord8X64# :: Word8X64# -> Word8X64# -> Word8X64# +remWord8X64# = let x = x in x + +-- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. + +remWord16X32# :: Word16X32# -> Word16X32# -> Word16X32# +remWord16X32# = let x = x in x + +-- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. + +remWord32X16# :: Word32X16# -> Word32X16# -> Word32X16# +remWord32X16# = let x = x in x + +-- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. + +remWord64X8# :: Word64X8# -> Word64X8# -> Word64X8# +remWord64X8# = let x = x in x + +-- | Negate element-wise. + +negateInt8X16# :: Int8X16# -> Int8X16# +negateInt8X16# = let x = x in x + +-- | Negate element-wise. + +negateInt16X8# :: Int16X8# -> Int16X8# +negateInt16X8# = let x = x in x + +-- | Negate element-wise. + +negateInt32X4# :: Int32X4# -> Int32X4# +negateInt32X4# = let x = x in x + +-- | Negate element-wise. + +negateInt64X2# :: Int64X2# -> Int64X2# +negateInt64X2# = let x = x in x + +-- | Negate element-wise. + +negateInt8X32# :: Int8X32# -> Int8X32# +negateInt8X32# = let x = x in x + +-- | Negate element-wise. + +negateInt16X16# :: Int16X16# -> Int16X16# +negateInt16X16# = let x = x in x + +-- | Negate element-wise. + +negateInt32X8# :: Int32X8# -> Int32X8# +negateInt32X8# = let x = x in x + +-- | Negate element-wise. + +negateInt64X4# :: Int64X4# -> Int64X4# +negateInt64X4# = let x = x in x + +-- | Negate element-wise. + +negateInt8X64# :: Int8X64# -> Int8X64# +negateInt8X64# = let x = x in x + +-- | Negate element-wise. + +negateInt16X32# :: Int16X32# -> Int16X32# +negateInt16X32# = let x = x in x + +-- | Negate element-wise. + +negateInt32X16# :: Int32X16# -> Int32X16# +negateInt32X16# = let x = x in x + +-- | Negate element-wise. + +negateInt64X8# :: Int64X8# -> Int64X8# +negateInt64X8# = let x = x in x + +-- | Negate element-wise. + +negateFloatX4# :: FloatX4# -> FloatX4# +negateFloatX4# = let x = x in x + +-- | Negate element-wise. + +negateDoubleX2# :: DoubleX2# -> DoubleX2# +negateDoubleX2# = let x = x in x + +-- | Negate element-wise. + +negateFloatX8# :: FloatX8# -> FloatX8# +negateFloatX8# = let x = x in x + +-- | Negate element-wise. + +negateDoubleX4# :: DoubleX4# -> DoubleX4# +negateDoubleX4# = let x = x in x + +-- | Negate element-wise. + +negateFloatX16# :: FloatX16# -> FloatX16# +negateFloatX16# = let x = x in x + +-- | Negate element-wise. + +negateDoubleX8# :: DoubleX8# -> DoubleX8# +negateDoubleX8# = let x = x in x + +-- | Read a vector from specified index of immutable array. + +indexInt8X16Array# :: ByteArray# -> Int# -> Int8X16# +indexInt8X16Array# = let x = x in x + +-- | Read a vector from specified index of immutable array. + +indexInt16X8Array# :: ByteArray# -> Int# -> Int16X8# +indexInt16X8Array# = let x = x in x + +-- | Read a vector from specified index of immutable array. + +indexInt32X4Array# :: ByteArray# -> Int# -> Int32X4# +indexInt32X4Array# = let x = x in x + +-- | Read a vector from specified index of immutable array. + +indexInt64X2Array# :: ByteArray# -> Int# -> Int64X2# +indexInt64X2Array# = let x = x in x + +-- | Read a vector from specified index of immutable array. + +indexInt8X32Array# :: ByteArray# -> Int# -> Int8X32# +indexInt8X32Array# = let x = x in x + +-- | Read a vector from specified index of immutable array. + +indexInt16X16Array# :: ByteArray# -> Int# -> Int16X16# +indexInt16X16Array# = let x = x in x + +-- | Read a vector from specified index of immutable array. + +indexInt32X8Array# :: ByteArray# -> Int# -> Int32X8# +indexInt32X8Array# = let x = x in x + +-- | Read a vector from specified index of immutable array. + +indexInt64X4Array# :: ByteArray# -> Int# -> Int64X4# +indexInt64X4Array# = let x = x in x + +-- | Read a vector from specified index of immutable array. + +indexInt8X64Array# :: ByteArray# -> Int# -> Int8X64# +indexInt8X64Array# = let x = x in x + +-- | Read a vector from specified index of immutable array. + +indexInt16X32Array# :: ByteArray# -> Int# -> Int16X32# +indexInt16X32Array# = let x = x in x + +-- | Read a vector from specified index of immutable array. + +indexInt32X16Array# :: ByteArray# -> Int# -> Int32X16# +indexInt32X16Array# = let x = x in x + +-- | Read a vector from specified index of immutable array. + +indexInt64X8Array# :: ByteArray# -> Int# -> Int64X8# +indexInt64X8Array# = let x = x in x + +-- | Read a vector from specified index of immutable array. + +indexWord8X16Array# :: ByteArray# -> Int# -> Word8X16# +indexWord8X16Array# = let x = x in x + +-- | Read a vector from specified index of immutable array. + +indexWord16X8Array# :: ByteArray# -> Int# -> Word16X8# +indexWord16X8Array# = let x = x in x + +-- | Read a vector from specified index of immutable array. + +indexWord32X4Array# :: ByteArray# -> Int# -> Word32X4# +indexWord32X4Array# = let x = x in x + +-- | Read a vector from specified index of immutable array. + +indexWord64X2Array# :: ByteArray# -> Int# -> Word64X2# +indexWord64X2Array# = let x = x in x + +-- | Read a vector from specified index of immutable array. + +indexWord8X32Array# :: ByteArray# -> Int# -> Word8X32# +indexWord8X32Array# = let x = x in x + +-- | Read a vector from specified index of immutable array. + +indexWord16X16Array# :: ByteArray# -> Int# -> Word16X16# +indexWord16X16Array# = let x = x in x + +-- | Read a vector from specified index of immutable array. + +indexWord32X8Array# :: ByteArray# -> Int# -> Word32X8# +indexWord32X8Array# = let x = x in x + +-- | Read a vector from specified index of immutable array. + +indexWord64X4Array# :: ByteArray# -> Int# -> Word64X4# +indexWord64X4Array# = let x = x in x + +-- | Read a vector from specified index of immutable array. + +indexWord8X64Array# :: ByteArray# -> Int# -> Word8X64# +indexWord8X64Array# = let x = x in x + +-- | Read a vector from specified index of immutable array. + +indexWord16X32Array# :: ByteArray# -> Int# -> Word16X32# +indexWord16X32Array# = let x = x in x + +-- | Read a vector from specified index of immutable array. + +indexWord32X16Array# :: ByteArray# -> Int# -> Word32X16# +indexWord32X16Array# = let x = x in x + +-- | Read a vector from specified index of immutable array. + +indexWord64X8Array# :: ByteArray# -> Int# -> Word64X8# +indexWord64X8Array# = let x = x in x + +-- | Read a vector from specified index of immutable array. + +indexFloatX4Array# :: ByteArray# -> Int# -> FloatX4# +indexFloatX4Array# = let x = x in x + +-- | Read a vector from specified index of immutable array. + +indexDoubleX2Array# :: ByteArray# -> Int# -> DoubleX2# +indexDoubleX2Array# = let x = x in x + +-- | Read a vector from specified index of immutable array. + +indexFloatX8Array# :: ByteArray# -> Int# -> FloatX8# +indexFloatX8Array# = let x = x in x + +-- | Read a vector from specified index of immutable array. + +indexDoubleX4Array# :: ByteArray# -> Int# -> DoubleX4# +indexDoubleX4Array# = let x = x in x + +-- | Read a vector from specified index of immutable array. + +indexFloatX16Array# :: ByteArray# -> Int# -> FloatX16# +indexFloatX16Array# = let x = x in x + +-- | Read a vector from specified index of immutable array. + +indexDoubleX8Array# :: ByteArray# -> Int# -> DoubleX8# +indexDoubleX8Array# = let x = x in x + +-- | Read a vector from specified index of mutable array. + +readInt8X16Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int8X16# #) +readInt8X16Array# = let x = x in x + +-- | Read a vector from specified index of mutable array. + +readInt16X8Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int16X8# #) +readInt16X8Array# = let x = x in x + +-- | Read a vector from specified index of mutable array. + +readInt32X4Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int32X4# #) +readInt32X4Array# = let x = x in x + +-- | Read a vector from specified index of mutable array. + +readInt64X2Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int64X2# #) +readInt64X2Array# = let x = x in x + +-- | Read a vector from specified index of mutable array. + +readInt8X32Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int8X32# #) +readInt8X32Array# = let x = x in x + +-- | Read a vector from specified index of mutable array. + +readInt16X16Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int16X16# #) +readInt16X16Array# = let x = x in x + +-- | Read a vector from specified index of mutable array. + +readInt32X8Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int32X8# #) +readInt32X8Array# = let x = x in x + +-- | Read a vector from specified index of mutable array. + +readInt64X4Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int64X4# #) +readInt64X4Array# = let x = x in x + +-- | Read a vector from specified index of mutable array. + +readInt8X64Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int8X64# #) +readInt8X64Array# = let x = x in x + +-- | Read a vector from specified index of mutable array. + +readInt16X32Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int16X32# #) +readInt16X32Array# = let x = x in x + +-- | Read a vector from specified index of mutable array. + +readInt32X16Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int32X16# #) +readInt32X16Array# = let x = x in x + +-- | Read a vector from specified index of mutable array. + +readInt64X8Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int64X8# #) +readInt64X8Array# = let x = x in x + +-- | Read a vector from specified index of mutable array. + +readWord8X16Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word8X16# #) +readWord8X16Array# = let x = x in x + +-- | Read a vector from specified index of mutable array. + +readWord16X8Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word16X8# #) +readWord16X8Array# = let x = x in x + +-- | Read a vector from specified index of mutable array. + +readWord32X4Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word32X4# #) +readWord32X4Array# = let x = x in x + +-- | Read a vector from specified index of mutable array. + +readWord64X2Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word64X2# #) +readWord64X2Array# = let x = x in x + +-- | Read a vector from specified index of mutable array. + +readWord8X32Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word8X32# #) +readWord8X32Array# = let x = x in x + +-- | Read a vector from specified index of mutable array. + +readWord16X16Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word16X16# #) +readWord16X16Array# = let x = x in x + +-- | Read a vector from specified index of mutable array. + +readWord32X8Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word32X8# #) +readWord32X8Array# = let x = x in x + +-- | Read a vector from specified index of mutable array. + +readWord64X4Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word64X4# #) +readWord64X4Array# = let x = x in x + +-- | Read a vector from specified index of mutable array. + +readWord8X64Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word8X64# #) +readWord8X64Array# = let x = x in x + +-- | Read a vector from specified index of mutable array. + +readWord16X32Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word16X32# #) +readWord16X32Array# = let x = x in x + +-- | Read a vector from specified index of mutable array. + +readWord32X16Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word32X16# #) +readWord32X16Array# = let x = x in x + +-- | Read a vector from specified index of mutable array. + +readWord64X8Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word64X8# #) +readWord64X8Array# = let x = x in x + +-- | Read a vector from specified index of mutable array. + +readFloatX4Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,FloatX4# #) +readFloatX4Array# = let x = x in x + +-- | Read a vector from specified index of mutable array. + +readDoubleX2Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,DoubleX2# #) +readDoubleX2Array# = let x = x in x + +-- | Read a vector from specified index of mutable array. + +readFloatX8Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,FloatX8# #) +readFloatX8Array# = let x = x in x + +-- | Read a vector from specified index of mutable array. + +readDoubleX4Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,DoubleX4# #) +readDoubleX4Array# = let x = x in x + +-- | Read a vector from specified index of mutable array. + +readFloatX16Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,FloatX16# #) +readFloatX16Array# = let x = x in x + +-- | Read a vector from specified index of mutable array. + +readDoubleX8Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,DoubleX8# #) +readDoubleX8Array# = let x = x in x + +-- | Write a vector to specified index of mutable array. + +writeInt8X16Array# :: MutableByteArray# s -> Int# -> Int8X16# -> State# s -> State# s +writeInt8X16Array# = let x = x in x + +-- | Write a vector to specified index of mutable array. + +writeInt16X8Array# :: MutableByteArray# s -> Int# -> Int16X8# -> State# s -> State# s +writeInt16X8Array# = let x = x in x + +-- | Write a vector to specified index of mutable array. + +writeInt32X4Array# :: MutableByteArray# s -> Int# -> Int32X4# -> State# s -> State# s +writeInt32X4Array# = let x = x in x + +-- | Write a vector to specified index of mutable array. + +writeInt64X2Array# :: MutableByteArray# s -> Int# -> Int64X2# -> State# s -> State# s +writeInt64X2Array# = let x = x in x + +-- | Write a vector to specified index of mutable array. + +writeInt8X32Array# :: MutableByteArray# s -> Int# -> Int8X32# -> State# s -> State# s +writeInt8X32Array# = let x = x in x + +-- | Write a vector to specified index of mutable array. + +writeInt16X16Array# :: MutableByteArray# s -> Int# -> Int16X16# -> State# s -> State# s +writeInt16X16Array# = let x = x in x + +-- | Write a vector to specified index of mutable array. + +writeInt32X8Array# :: MutableByteArray# s -> Int# -> Int32X8# -> State# s -> State# s +writeInt32X8Array# = let x = x in x + +-- | Write a vector to specified index of mutable array. + +writeInt64X4Array# :: MutableByteArray# s -> Int# -> Int64X4# -> State# s -> State# s +writeInt64X4Array# = let x = x in x + +-- | Write a vector to specified index of mutable array. + +writeInt8X64Array# :: MutableByteArray# s -> Int# -> Int8X64# -> State# s -> State# s +writeInt8X64Array# = let x = x in x + +-- | Write a vector to specified index of mutable array. + +writeInt16X32Array# :: MutableByteArray# s -> Int# -> Int16X32# -> State# s -> State# s +writeInt16X32Array# = let x = x in x + +-- | Write a vector to specified index of mutable array. + +writeInt32X16Array# :: MutableByteArray# s -> Int# -> Int32X16# -> State# s -> State# s +writeInt32X16Array# = let x = x in x + +-- | Write a vector to specified index of mutable array. + +writeInt64X8Array# :: MutableByteArray# s -> Int# -> Int64X8# -> State# s -> State# s +writeInt64X8Array# = let x = x in x + +-- | Write a vector to specified index of mutable array. + +writeWord8X16Array# :: MutableByteArray# s -> Int# -> Word8X16# -> State# s -> State# s +writeWord8X16Array# = let x = x in x + +-- | Write a vector to specified index of mutable array. + +writeWord16X8Array# :: MutableByteArray# s -> Int# -> Word16X8# -> State# s -> State# s +writeWord16X8Array# = let x = x in x + +-- | Write a vector to specified index of mutable array. + +writeWord32X4Array# :: MutableByteArray# s -> Int# -> Word32X4# -> State# s -> State# s +writeWord32X4Array# = let x = x in x + +-- | Write a vector to specified index of mutable array. + +writeWord64X2Array# :: MutableByteArray# s -> Int# -> Word64X2# -> State# s -> State# s +writeWord64X2Array# = let x = x in x + +-- | Write a vector to specified index of mutable array. + +writeWord8X32Array# :: MutableByteArray# s -> Int# -> Word8X32# -> State# s -> State# s +writeWord8X32Array# = let x = x in x + +-- | Write a vector to specified index of mutable array. + +writeWord16X16Array# :: MutableByteArray# s -> Int# -> Word16X16# -> State# s -> State# s +writeWord16X16Array# = let x = x in x + +-- | Write a vector to specified index of mutable array. + +writeWord32X8Array# :: MutableByteArray# s -> Int# -> Word32X8# -> State# s -> State# s +writeWord32X8Array# = let x = x in x + +-- | Write a vector to specified index of mutable array. + +writeWord64X4Array# :: MutableByteArray# s -> Int# -> Word64X4# -> State# s -> State# s +writeWord64X4Array# = let x = x in x + +-- | Write a vector to specified index of mutable array. + +writeWord8X64Array# :: MutableByteArray# s -> Int# -> Word8X64# -> State# s -> State# s +writeWord8X64Array# = let x = x in x + +-- | Write a vector to specified index of mutable array. + +writeWord16X32Array# :: MutableByteArray# s -> Int# -> Word16X32# -> State# s -> State# s +writeWord16X32Array# = let x = x in x + +-- | Write a vector to specified index of mutable array. + +writeWord32X16Array# :: MutableByteArray# s -> Int# -> Word32X16# -> State# s -> State# s +writeWord32X16Array# = let x = x in x + +-- | Write a vector to specified index of mutable array. + +writeWord64X8Array# :: MutableByteArray# s -> Int# -> Word64X8# -> State# s -> State# s +writeWord64X8Array# = let x = x in x + +-- | Write a vector to specified index of mutable array. + +writeFloatX4Array# :: MutableByteArray# s -> Int# -> FloatX4# -> State# s -> State# s +writeFloatX4Array# = let x = x in x + +-- | Write a vector to specified index of mutable array. + +writeDoubleX2Array# :: MutableByteArray# s -> Int# -> DoubleX2# -> State# s -> State# s +writeDoubleX2Array# = let x = x in x + +-- | Write a vector to specified index of mutable array. + +writeFloatX8Array# :: MutableByteArray# s -> Int# -> FloatX8# -> State# s -> State# s +writeFloatX8Array# = let x = x in x + +-- | Write a vector to specified index of mutable array. + +writeDoubleX4Array# :: MutableByteArray# s -> Int# -> DoubleX4# -> State# s -> State# s +writeDoubleX4Array# = let x = x in x + +-- | Write a vector to specified index of mutable array. + +writeFloatX16Array# :: MutableByteArray# s -> Int# -> FloatX16# -> State# s -> State# s +writeFloatX16Array# = let x = x in x + +-- | Write a vector to specified index of mutable array. + +writeDoubleX8Array# :: MutableByteArray# s -> Int# -> DoubleX8# -> State# s -> State# s +writeDoubleX8Array# = let x = x in x + +-- | Reads vector; offset in bytes. + +indexInt8X16OffAddr# :: Addr# -> Int# -> Int8X16# +indexInt8X16OffAddr# = let x = x in x + +-- | Reads vector; offset in bytes. + +indexInt16X8OffAddr# :: Addr# -> Int# -> Int16X8# +indexInt16X8OffAddr# = let x = x in x + +-- | Reads vector; offset in bytes. + +indexInt32X4OffAddr# :: Addr# -> Int# -> Int32X4# +indexInt32X4OffAddr# = let x = x in x + +-- | Reads vector; offset in bytes. + +indexInt64X2OffAddr# :: Addr# -> Int# -> Int64X2# +indexInt64X2OffAddr# = let x = x in x + +-- | Reads vector; offset in bytes. + +indexInt8X32OffAddr# :: Addr# -> Int# -> Int8X32# +indexInt8X32OffAddr# = let x = x in x + +-- | Reads vector; offset in bytes. + +indexInt16X16OffAddr# :: Addr# -> Int# -> Int16X16# +indexInt16X16OffAddr# = let x = x in x + +-- | Reads vector; offset in bytes. + +indexInt32X8OffAddr# :: Addr# -> Int# -> Int32X8# +indexInt32X8OffAddr# = let x = x in x + +-- | Reads vector; offset in bytes. + +indexInt64X4OffAddr# :: Addr# -> Int# -> Int64X4# +indexInt64X4OffAddr# = let x = x in x + +-- | Reads vector; offset in bytes. + +indexInt8X64OffAddr# :: Addr# -> Int# -> Int8X64# +indexInt8X64OffAddr# = let x = x in x + +-- | Reads vector; offset in bytes. + +indexInt16X32OffAddr# :: Addr# -> Int# -> Int16X32# +indexInt16X32OffAddr# = let x = x in x + +-- | Reads vector; offset in bytes. + +indexInt32X16OffAddr# :: Addr# -> Int# -> Int32X16# +indexInt32X16OffAddr# = let x = x in x + +-- | Reads vector; offset in bytes. + +indexInt64X8OffAddr# :: Addr# -> Int# -> Int64X8# +indexInt64X8OffAddr# = let x = x in x + +-- | Reads vector; offset in bytes. + +indexWord8X16OffAddr# :: Addr# -> Int# -> Word8X16# +indexWord8X16OffAddr# = let x = x in x + +-- | Reads vector; offset in bytes. + +indexWord16X8OffAddr# :: Addr# -> Int# -> Word16X8# +indexWord16X8OffAddr# = let x = x in x + +-- | Reads vector; offset in bytes. + +indexWord32X4OffAddr# :: Addr# -> Int# -> Word32X4# +indexWord32X4OffAddr# = let x = x in x + +-- | Reads vector; offset in bytes. + +indexWord64X2OffAddr# :: Addr# -> Int# -> Word64X2# +indexWord64X2OffAddr# = let x = x in x + +-- | Reads vector; offset in bytes. + +indexWord8X32OffAddr# :: Addr# -> Int# -> Word8X32# +indexWord8X32OffAddr# = let x = x in x + +-- | Reads vector; offset in bytes. + +indexWord16X16OffAddr# :: Addr# -> Int# -> Word16X16# +indexWord16X16OffAddr# = let x = x in x + +-- | Reads vector; offset in bytes. + +indexWord32X8OffAddr# :: Addr# -> Int# -> Word32X8# +indexWord32X8OffAddr# = let x = x in x + +-- | Reads vector; offset in bytes. + +indexWord64X4OffAddr# :: Addr# -> Int# -> Word64X4# +indexWord64X4OffAddr# = let x = x in x + +-- | Reads vector; offset in bytes. + +indexWord8X64OffAddr# :: Addr# -> Int# -> Word8X64# +indexWord8X64OffAddr# = let x = x in x + +-- | Reads vector; offset in bytes. + +indexWord16X32OffAddr# :: Addr# -> Int# -> Word16X32# +indexWord16X32OffAddr# = let x = x in x + +-- | Reads vector; offset in bytes. + +indexWord32X16OffAddr# :: Addr# -> Int# -> Word32X16# +indexWord32X16OffAddr# = let x = x in x + +-- | Reads vector; offset in bytes. + +indexWord64X8OffAddr# :: Addr# -> Int# -> Word64X8# +indexWord64X8OffAddr# = let x = x in x + +-- | Reads vector; offset in bytes. + +indexFloatX4OffAddr# :: Addr# -> Int# -> FloatX4# +indexFloatX4OffAddr# = let x = x in x + +-- | Reads vector; offset in bytes. + +indexDoubleX2OffAddr# :: Addr# -> Int# -> DoubleX2# +indexDoubleX2OffAddr# = let x = x in x + +-- | Reads vector; offset in bytes. + +indexFloatX8OffAddr# :: Addr# -> Int# -> FloatX8# +indexFloatX8OffAddr# = let x = x in x + +-- | Reads vector; offset in bytes. + +indexDoubleX4OffAddr# :: Addr# -> Int# -> DoubleX4# +indexDoubleX4OffAddr# = let x = x in x + +-- | Reads vector; offset in bytes. + +indexFloatX16OffAddr# :: Addr# -> Int# -> FloatX16# +indexFloatX16OffAddr# = let x = x in x + +-- | Reads vector; offset in bytes. + +indexDoubleX8OffAddr# :: Addr# -> Int# -> DoubleX8# +indexDoubleX8OffAddr# = let x = x in x + +-- | Reads vector; offset in bytes. + +readInt8X16OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int8X16# #) +readInt8X16OffAddr# = let x = x in x + +-- | Reads vector; offset in bytes. + +readInt16X8OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int16X8# #) +readInt16X8OffAddr# = let x = x in x + +-- | Reads vector; offset in bytes. + +readInt32X4OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int32X4# #) +readInt32X4OffAddr# = let x = x in x + +-- | Reads vector; offset in bytes. + +readInt64X2OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int64X2# #) +readInt64X2OffAddr# = let x = x in x + +-- | Reads vector; offset in bytes. + +readInt8X32OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int8X32# #) +readInt8X32OffAddr# = let x = x in x + +-- | Reads vector; offset in bytes. + +readInt16X16OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int16X16# #) +readInt16X16OffAddr# = let x = x in x + +-- | Reads vector; offset in bytes. + +readInt32X8OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int32X8# #) +readInt32X8OffAddr# = let x = x in x + +-- | Reads vector; offset in bytes. + +readInt64X4OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int64X4# #) +readInt64X4OffAddr# = let x = x in x + +-- | Reads vector; offset in bytes. + +readInt8X64OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int8X64# #) +readInt8X64OffAddr# = let x = x in x + +-- | Reads vector; offset in bytes. + +readInt16X32OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int16X32# #) +readInt16X32OffAddr# = let x = x in x + +-- | Reads vector; offset in bytes. + +readInt32X16OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int32X16# #) +readInt32X16OffAddr# = let x = x in x + +-- | Reads vector; offset in bytes. + +readInt64X8OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int64X8# #) +readInt64X8OffAddr# = let x = x in x + +-- | Reads vector; offset in bytes. + +readWord8X16OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word8X16# #) +readWord8X16OffAddr# = let x = x in x + +-- | Reads vector; offset in bytes. + +readWord16X8OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word16X8# #) +readWord16X8OffAddr# = let x = x in x + +-- | Reads vector; offset in bytes. + +readWord32X4OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word32X4# #) +readWord32X4OffAddr# = let x = x in x + +-- | Reads vector; offset in bytes. + +readWord64X2OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word64X2# #) +readWord64X2OffAddr# = let x = x in x + +-- | Reads vector; offset in bytes. + +readWord8X32OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word8X32# #) +readWord8X32OffAddr# = let x = x in x + +-- | Reads vector; offset in bytes. + +readWord16X16OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word16X16# #) +readWord16X16OffAddr# = let x = x in x + +-- | Reads vector; offset in bytes. + +readWord32X8OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word32X8# #) +readWord32X8OffAddr# = let x = x in x + +-- | Reads vector; offset in bytes. + +readWord64X4OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word64X4# #) +readWord64X4OffAddr# = let x = x in x + +-- | Reads vector; offset in bytes. + +readWord8X64OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word8X64# #) +readWord8X64OffAddr# = let x = x in x + +-- | Reads vector; offset in bytes. + +readWord16X32OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word16X32# #) +readWord16X32OffAddr# = let x = x in x + +-- | Reads vector; offset in bytes. + +readWord32X16OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word32X16# #) +readWord32X16OffAddr# = let x = x in x + +-- | Reads vector; offset in bytes. + +readWord64X8OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word64X8# #) +readWord64X8OffAddr# = let x = x in x + +-- | Reads vector; offset in bytes. + +readFloatX4OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,FloatX4# #) +readFloatX4OffAddr# = let x = x in x + +-- | Reads vector; offset in bytes. + +readDoubleX2OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,DoubleX2# #) +readDoubleX2OffAddr# = let x = x in x + +-- | Reads vector; offset in bytes. + +readFloatX8OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,FloatX8# #) +readFloatX8OffAddr# = let x = x in x + +-- | Reads vector; offset in bytes. + +readDoubleX4OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,DoubleX4# #) +readDoubleX4OffAddr# = let x = x in x + +-- | Reads vector; offset in bytes. + +readFloatX16OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,FloatX16# #) +readFloatX16OffAddr# = let x = x in x + +-- | Reads vector; offset in bytes. + +readDoubleX8OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,DoubleX8# #) +readDoubleX8OffAddr# = let x = x in x + +-- | Write vector; offset in bytes. + +writeInt8X16OffAddr# :: Addr# -> Int# -> Int8X16# -> State# s -> State# s +writeInt8X16OffAddr# = let x = x in x + +-- | Write vector; offset in bytes. + +writeInt16X8OffAddr# :: Addr# -> Int# -> Int16X8# -> State# s -> State# s +writeInt16X8OffAddr# = let x = x in x + +-- | Write vector; offset in bytes. + +writeInt32X4OffAddr# :: Addr# -> Int# -> Int32X4# -> State# s -> State# s +writeInt32X4OffAddr# = let x = x in x + +-- | Write vector; offset in bytes. + +writeInt64X2OffAddr# :: Addr# -> Int# -> Int64X2# -> State# s -> State# s +writeInt64X2OffAddr# = let x = x in x + +-- | Write vector; offset in bytes. + +writeInt8X32OffAddr# :: Addr# -> Int# -> Int8X32# -> State# s -> State# s +writeInt8X32OffAddr# = let x = x in x + +-- | Write vector; offset in bytes. + +writeInt16X16OffAddr# :: Addr# -> Int# -> Int16X16# -> State# s -> State# s +writeInt16X16OffAddr# = let x = x in x + +-- | Write vector; offset in bytes. + +writeInt32X8OffAddr# :: Addr# -> Int# -> Int32X8# -> State# s -> State# s +writeInt32X8OffAddr# = let x = x in x + +-- | Write vector; offset in bytes. + +writeInt64X4OffAddr# :: Addr# -> Int# -> Int64X4# -> State# s -> State# s +writeInt64X4OffAddr# = let x = x in x + +-- | Write vector; offset in bytes. + +writeInt8X64OffAddr# :: Addr# -> Int# -> Int8X64# -> State# s -> State# s +writeInt8X64OffAddr# = let x = x in x + +-- | Write vector; offset in bytes. + +writeInt16X32OffAddr# :: Addr# -> Int# -> Int16X32# -> State# s -> State# s +writeInt16X32OffAddr# = let x = x in x + +-- | Write vector; offset in bytes. + +writeInt32X16OffAddr# :: Addr# -> Int# -> Int32X16# -> State# s -> State# s +writeInt32X16OffAddr# = let x = x in x + +-- | Write vector; offset in bytes. + +writeInt64X8OffAddr# :: Addr# -> Int# -> Int64X8# -> State# s -> State# s +writeInt64X8OffAddr# = let x = x in x + +-- | Write vector; offset in bytes. + +writeWord8X16OffAddr# :: Addr# -> Int# -> Word8X16# -> State# s -> State# s +writeWord8X16OffAddr# = let x = x in x + +-- | Write vector; offset in bytes. + +writeWord16X8OffAddr# :: Addr# -> Int# -> Word16X8# -> State# s -> State# s +writeWord16X8OffAddr# = let x = x in x + +-- | Write vector; offset in bytes. + +writeWord32X4OffAddr# :: Addr# -> Int# -> Word32X4# -> State# s -> State# s +writeWord32X4OffAddr# = let x = x in x + +-- | Write vector; offset in bytes. + +writeWord64X2OffAddr# :: Addr# -> Int# -> Word64X2# -> State# s -> State# s +writeWord64X2OffAddr# = let x = x in x + +-- | Write vector; offset in bytes. + +writeWord8X32OffAddr# :: Addr# -> Int# -> Word8X32# -> State# s -> State# s +writeWord8X32OffAddr# = let x = x in x + +-- | Write vector; offset in bytes. + +writeWord16X16OffAddr# :: Addr# -> Int# -> Word16X16# -> State# s -> State# s +writeWord16X16OffAddr# = let x = x in x + +-- | Write vector; offset in bytes. + +writeWord32X8OffAddr# :: Addr# -> Int# -> Word32X8# -> State# s -> State# s +writeWord32X8OffAddr# = let x = x in x + +-- | Write vector; offset in bytes. + +writeWord64X4OffAddr# :: Addr# -> Int# -> Word64X4# -> State# s -> State# s +writeWord64X4OffAddr# = let x = x in x + +-- | Write vector; offset in bytes. + +writeWord8X64OffAddr# :: Addr# -> Int# -> Word8X64# -> State# s -> State# s +writeWord8X64OffAddr# = let x = x in x + +-- | Write vector; offset in bytes. + +writeWord16X32OffAddr# :: Addr# -> Int# -> Word16X32# -> State# s -> State# s +writeWord16X32OffAddr# = let x = x in x + +-- | Write vector; offset in bytes. + +writeWord32X16OffAddr# :: Addr# -> Int# -> Word32X16# -> State# s -> State# s +writeWord32X16OffAddr# = let x = x in x + +-- | Write vector; offset in bytes. + +writeWord64X8OffAddr# :: Addr# -> Int# -> Word64X8# -> State# s -> State# s +writeWord64X8OffAddr# = let x = x in x + +-- | Write vector; offset in bytes. + +writeFloatX4OffAddr# :: Addr# -> Int# -> FloatX4# -> State# s -> State# s +writeFloatX4OffAddr# = let x = x in x + +-- | Write vector; offset in bytes. + +writeDoubleX2OffAddr# :: Addr# -> Int# -> DoubleX2# -> State# s -> State# s +writeDoubleX2OffAddr# = let x = x in x + +-- | Write vector; offset in bytes. + +writeFloatX8OffAddr# :: Addr# -> Int# -> FloatX8# -> State# s -> State# s +writeFloatX8OffAddr# = let x = x in x + +-- | Write vector; offset in bytes. + +writeDoubleX4OffAddr# :: Addr# -> Int# -> DoubleX4# -> State# s -> State# s +writeDoubleX4OffAddr# = let x = x in x + +-- | Write vector; offset in bytes. + +writeFloatX16OffAddr# :: Addr# -> Int# -> FloatX16# -> State# s -> State# s +writeFloatX16OffAddr# = let x = x in x + +-- | Write vector; offset in bytes. + +writeDoubleX8OffAddr# :: Addr# -> Int# -> DoubleX8# -> State# s -> State# s +writeDoubleX8OffAddr# = let x = x in x + +-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. + +indexInt8ArrayAsInt8X16# :: ByteArray# -> Int# -> Int8X16# +indexInt8ArrayAsInt8X16# = let x = x in x + +-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. + +indexInt16ArrayAsInt16X8# :: ByteArray# -> Int# -> Int16X8# +indexInt16ArrayAsInt16X8# = let x = x in x + +-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. + +indexInt32ArrayAsInt32X4# :: ByteArray# -> Int# -> Int32X4# +indexInt32ArrayAsInt32X4# = let x = x in x + +-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. + +indexInt64ArrayAsInt64X2# :: ByteArray# -> Int# -> Int64X2# +indexInt64ArrayAsInt64X2# = let x = x in x + +-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. + +indexInt8ArrayAsInt8X32# :: ByteArray# -> Int# -> Int8X32# +indexInt8ArrayAsInt8X32# = let x = x in x + +-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. + +indexInt16ArrayAsInt16X16# :: ByteArray# -> Int# -> Int16X16# +indexInt16ArrayAsInt16X16# = let x = x in x + +-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. + +indexInt32ArrayAsInt32X8# :: ByteArray# -> Int# -> Int32X8# +indexInt32ArrayAsInt32X8# = let x = x in x + +-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. + +indexInt64ArrayAsInt64X4# :: ByteArray# -> Int# -> Int64X4# +indexInt64ArrayAsInt64X4# = let x = x in x + +-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. + +indexInt8ArrayAsInt8X64# :: ByteArray# -> Int# -> Int8X64# +indexInt8ArrayAsInt8X64# = let x = x in x + +-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. + +indexInt16ArrayAsInt16X32# :: ByteArray# -> Int# -> Int16X32# +indexInt16ArrayAsInt16X32# = let x = x in x + +-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. + +indexInt32ArrayAsInt32X16# :: ByteArray# -> Int# -> Int32X16# +indexInt32ArrayAsInt32X16# = let x = x in x + +-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. + +indexInt64ArrayAsInt64X8# :: ByteArray# -> Int# -> Int64X8# +indexInt64ArrayAsInt64X8# = let x = x in x + +-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. + +indexWord8ArrayAsWord8X16# :: ByteArray# -> Int# -> Word8X16# +indexWord8ArrayAsWord8X16# = let x = x in x + +-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. + +indexWord16ArrayAsWord16X8# :: ByteArray# -> Int# -> Word16X8# +indexWord16ArrayAsWord16X8# = let x = x in x + +-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. + +indexWord32ArrayAsWord32X4# :: ByteArray# -> Int# -> Word32X4# +indexWord32ArrayAsWord32X4# = let x = x in x + +-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. + +indexWord64ArrayAsWord64X2# :: ByteArray# -> Int# -> Word64X2# +indexWord64ArrayAsWord64X2# = let x = x in x + +-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. + +indexWord8ArrayAsWord8X32# :: ByteArray# -> Int# -> Word8X32# +indexWord8ArrayAsWord8X32# = let x = x in x + +-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. + +indexWord16ArrayAsWord16X16# :: ByteArray# -> Int# -> Word16X16# +indexWord16ArrayAsWord16X16# = let x = x in x + +-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. + +indexWord32ArrayAsWord32X8# :: ByteArray# -> Int# -> Word32X8# +indexWord32ArrayAsWord32X8# = let x = x in x + +-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. + +indexWord64ArrayAsWord64X4# :: ByteArray# -> Int# -> Word64X4# +indexWord64ArrayAsWord64X4# = let x = x in x + +-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. + +indexWord8ArrayAsWord8X64# :: ByteArray# -> Int# -> Word8X64# +indexWord8ArrayAsWord8X64# = let x = x in x + +-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. + +indexWord16ArrayAsWord16X32# :: ByteArray# -> Int# -> Word16X32# +indexWord16ArrayAsWord16X32# = let x = x in x + +-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. + +indexWord32ArrayAsWord32X16# :: ByteArray# -> Int# -> Word32X16# +indexWord32ArrayAsWord32X16# = let x = x in x + +-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. + +indexWord64ArrayAsWord64X8# :: ByteArray# -> Int# -> Word64X8# +indexWord64ArrayAsWord64X8# = let x = x in x + +-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. + +indexFloatArrayAsFloatX4# :: ByteArray# -> Int# -> FloatX4# +indexFloatArrayAsFloatX4# = let x = x in x + +-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. + +indexDoubleArrayAsDoubleX2# :: ByteArray# -> Int# -> DoubleX2# +indexDoubleArrayAsDoubleX2# = let x = x in x + +-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. + +indexFloatArrayAsFloatX8# :: ByteArray# -> Int# -> FloatX8# +indexFloatArrayAsFloatX8# = let x = x in x + +-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. + +indexDoubleArrayAsDoubleX4# :: ByteArray# -> Int# -> DoubleX4# +indexDoubleArrayAsDoubleX4# = let x = x in x + +-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. + +indexFloatArrayAsFloatX16# :: ByteArray# -> Int# -> FloatX16# +indexFloatArrayAsFloatX16# = let x = x in x + +-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. + +indexDoubleArrayAsDoubleX8# :: ByteArray# -> Int# -> DoubleX8# +indexDoubleArrayAsDoubleX8# = let x = x in x + +-- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. + +readInt8ArrayAsInt8X16# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int8X16# #) +readInt8ArrayAsInt8X16# = let x = x in x + +-- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. + +readInt16ArrayAsInt16X8# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int16X8# #) +readInt16ArrayAsInt16X8# = let x = x in x + +-- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. + +readInt32ArrayAsInt32X4# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int32X4# #) +readInt32ArrayAsInt32X4# = let x = x in x + +-- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. + +readInt64ArrayAsInt64X2# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int64X2# #) +readInt64ArrayAsInt64X2# = let x = x in x + +-- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. + +readInt8ArrayAsInt8X32# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int8X32# #) +readInt8ArrayAsInt8X32# = let x = x in x + +-- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. + +readInt16ArrayAsInt16X16# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int16X16# #) +readInt16ArrayAsInt16X16# = let x = x in x + +-- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. + +readInt32ArrayAsInt32X8# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int32X8# #) +readInt32ArrayAsInt32X8# = let x = x in x + +-- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. + +readInt64ArrayAsInt64X4# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int64X4# #) +readInt64ArrayAsInt64X4# = let x = x in x + +-- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. + +readInt8ArrayAsInt8X64# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int8X64# #) +readInt8ArrayAsInt8X64# = let x = x in x + +-- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. + +readInt16ArrayAsInt16X32# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int16X32# #) +readInt16ArrayAsInt16X32# = let x = x in x + +-- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. + +readInt32ArrayAsInt32X16# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int32X16# #) +readInt32ArrayAsInt32X16# = let x = x in x + +-- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. + +readInt64ArrayAsInt64X8# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int64X8# #) +readInt64ArrayAsInt64X8# = let x = x in x + +-- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. + +readWord8ArrayAsWord8X16# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word8X16# #) +readWord8ArrayAsWord8X16# = let x = x in x + +-- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. + +readWord16ArrayAsWord16X8# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word16X8# #) +readWord16ArrayAsWord16X8# = let x = x in x + +-- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. + +readWord32ArrayAsWord32X4# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word32X4# #) +readWord32ArrayAsWord32X4# = let x = x in x + +-- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. + +readWord64ArrayAsWord64X2# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word64X2# #) +readWord64ArrayAsWord64X2# = let x = x in x + +-- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. + +readWord8ArrayAsWord8X32# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word8X32# #) +readWord8ArrayAsWord8X32# = let x = x in x + +-- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. + +readWord16ArrayAsWord16X16# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word16X16# #) +readWord16ArrayAsWord16X16# = let x = x in x + +-- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. + +readWord32ArrayAsWord32X8# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word32X8# #) +readWord32ArrayAsWord32X8# = let x = x in x + +-- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. + +readWord64ArrayAsWord64X4# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word64X4# #) +readWord64ArrayAsWord64X4# = let x = x in x + +-- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. + +readWord8ArrayAsWord8X64# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word8X64# #) +readWord8ArrayAsWord8X64# = let x = x in x + +-- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. + +readWord16ArrayAsWord16X32# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word16X32# #) +readWord16ArrayAsWord16X32# = let x = x in x + +-- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. + +readWord32ArrayAsWord32X16# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word32X16# #) +readWord32ArrayAsWord32X16# = let x = x in x + +-- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. + +readWord64ArrayAsWord64X8# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word64X8# #) +readWord64ArrayAsWord64X8# = let x = x in x + +-- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. + +readFloatArrayAsFloatX4# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,FloatX4# #) +readFloatArrayAsFloatX4# = let x = x in x + +-- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. + +readDoubleArrayAsDoubleX2# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,DoubleX2# #) +readDoubleArrayAsDoubleX2# = let x = x in x + +-- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. + +readFloatArrayAsFloatX8# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,FloatX8# #) +readFloatArrayAsFloatX8# = let x = x in x + +-- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. + +readDoubleArrayAsDoubleX4# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,DoubleX4# #) +readDoubleArrayAsDoubleX4# = let x = x in x + +-- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. + +readFloatArrayAsFloatX16# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,FloatX16# #) +readFloatArrayAsFloatX16# = let x = x in x + +-- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. + +readDoubleArrayAsDoubleX8# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,DoubleX8# #) +readDoubleArrayAsDoubleX8# = let x = x in x + +-- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. + +writeInt8ArrayAsInt8X16# :: MutableByteArray# s -> Int# -> Int8X16# -> State# s -> State# s +writeInt8ArrayAsInt8X16# = let x = x in x + +-- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. + +writeInt16ArrayAsInt16X8# :: MutableByteArray# s -> Int# -> Int16X8# -> State# s -> State# s +writeInt16ArrayAsInt16X8# = let x = x in x + +-- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. + +writeInt32ArrayAsInt32X4# :: MutableByteArray# s -> Int# -> Int32X4# -> State# s -> State# s +writeInt32ArrayAsInt32X4# = let x = x in x + +-- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. + +writeInt64ArrayAsInt64X2# :: MutableByteArray# s -> Int# -> Int64X2# -> State# s -> State# s +writeInt64ArrayAsInt64X2# = let x = x in x + +-- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. + +writeInt8ArrayAsInt8X32# :: MutableByteArray# s -> Int# -> Int8X32# -> State# s -> State# s +writeInt8ArrayAsInt8X32# = let x = x in x + +-- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. + +writeInt16ArrayAsInt16X16# :: MutableByteArray# s -> Int# -> Int16X16# -> State# s -> State# s +writeInt16ArrayAsInt16X16# = let x = x in x + +-- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. + +writeInt32ArrayAsInt32X8# :: MutableByteArray# s -> Int# -> Int32X8# -> State# s -> State# s +writeInt32ArrayAsInt32X8# = let x = x in x + +-- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. + +writeInt64ArrayAsInt64X4# :: MutableByteArray# s -> Int# -> Int64X4# -> State# s -> State# s +writeInt64ArrayAsInt64X4# = let x = x in x + +-- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. + +writeInt8ArrayAsInt8X64# :: MutableByteArray# s -> Int# -> Int8X64# -> State# s -> State# s +writeInt8ArrayAsInt8X64# = let x = x in x + +-- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. + +writeInt16ArrayAsInt16X32# :: MutableByteArray# s -> Int# -> Int16X32# -> State# s -> State# s +writeInt16ArrayAsInt16X32# = let x = x in x + +-- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. + +writeInt32ArrayAsInt32X16# :: MutableByteArray# s -> Int# -> Int32X16# -> State# s -> State# s +writeInt32ArrayAsInt32X16# = let x = x in x + +-- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. + +writeInt64ArrayAsInt64X8# :: MutableByteArray# s -> Int# -> Int64X8# -> State# s -> State# s +writeInt64ArrayAsInt64X8# = let x = x in x + +-- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. + +writeWord8ArrayAsWord8X16# :: MutableByteArray# s -> Int# -> Word8X16# -> State# s -> State# s +writeWord8ArrayAsWord8X16# = let x = x in x + +-- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. + +writeWord16ArrayAsWord16X8# :: MutableByteArray# s -> Int# -> Word16X8# -> State# s -> State# s +writeWord16ArrayAsWord16X8# = let x = x in x + +-- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. + +writeWord32ArrayAsWord32X4# :: MutableByteArray# s -> Int# -> Word32X4# -> State# s -> State# s +writeWord32ArrayAsWord32X4# = let x = x in x + +-- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. + +writeWord64ArrayAsWord64X2# :: MutableByteArray# s -> Int# -> Word64X2# -> State# s -> State# s +writeWord64ArrayAsWord64X2# = let x = x in x + +-- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. + +writeWord8ArrayAsWord8X32# :: MutableByteArray# s -> Int# -> Word8X32# -> State# s -> State# s +writeWord8ArrayAsWord8X32# = let x = x in x + +-- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. + +writeWord16ArrayAsWord16X16# :: MutableByteArray# s -> Int# -> Word16X16# -> State# s -> State# s +writeWord16ArrayAsWord16X16# = let x = x in x + +-- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. + +writeWord32ArrayAsWord32X8# :: MutableByteArray# s -> Int# -> Word32X8# -> State# s -> State# s +writeWord32ArrayAsWord32X8# = let x = x in x + +-- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. + +writeWord64ArrayAsWord64X4# :: MutableByteArray# s -> Int# -> Word64X4# -> State# s -> State# s +writeWord64ArrayAsWord64X4# = let x = x in x + +-- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. + +writeWord8ArrayAsWord8X64# :: MutableByteArray# s -> Int# -> Word8X64# -> State# s -> State# s +writeWord8ArrayAsWord8X64# = let x = x in x + +-- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. + +writeWord16ArrayAsWord16X32# :: MutableByteArray# s -> Int# -> Word16X32# -> State# s -> State# s +writeWord16ArrayAsWord16X32# = let x = x in x + +-- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. + +writeWord32ArrayAsWord32X16# :: MutableByteArray# s -> Int# -> Word32X16# -> State# s -> State# s +writeWord32ArrayAsWord32X16# = let x = x in x + +-- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. + +writeWord64ArrayAsWord64X8# :: MutableByteArray# s -> Int# -> Word64X8# -> State# s -> State# s +writeWord64ArrayAsWord64X8# = let x = x in x + +-- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. + +writeFloatArrayAsFloatX4# :: MutableByteArray# s -> Int# -> FloatX4# -> State# s -> State# s +writeFloatArrayAsFloatX4# = let x = x in x + +-- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. + +writeDoubleArrayAsDoubleX2# :: MutableByteArray# s -> Int# -> DoubleX2# -> State# s -> State# s +writeDoubleArrayAsDoubleX2# = let x = x in x + +-- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. + +writeFloatArrayAsFloatX8# :: MutableByteArray# s -> Int# -> FloatX8# -> State# s -> State# s +writeFloatArrayAsFloatX8# = let x = x in x + +-- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. + +writeDoubleArrayAsDoubleX4# :: MutableByteArray# s -> Int# -> DoubleX4# -> State# s -> State# s +writeDoubleArrayAsDoubleX4# = let x = x in x + +-- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. + +writeFloatArrayAsFloatX16# :: MutableByteArray# s -> Int# -> FloatX16# -> State# s -> State# s +writeFloatArrayAsFloatX16# = let x = x in x + +-- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. + +writeDoubleArrayAsDoubleX8# :: MutableByteArray# s -> Int# -> DoubleX8# -> State# s -> State# s +writeDoubleArrayAsDoubleX8# = let x = x in x + +-- | Reads vector; offset in scalar elements. + +indexInt8OffAddrAsInt8X16# :: Addr# -> Int# -> Int8X16# +indexInt8OffAddrAsInt8X16# = let x = x in x + +-- | Reads vector; offset in scalar elements. + +indexInt16OffAddrAsInt16X8# :: Addr# -> Int# -> Int16X8# +indexInt16OffAddrAsInt16X8# = let x = x in x + +-- | Reads vector; offset in scalar elements. + +indexInt32OffAddrAsInt32X4# :: Addr# -> Int# -> Int32X4# +indexInt32OffAddrAsInt32X4# = let x = x in x + +-- | Reads vector; offset in scalar elements. + +indexInt64OffAddrAsInt64X2# :: Addr# -> Int# -> Int64X2# +indexInt64OffAddrAsInt64X2# = let x = x in x + +-- | Reads vector; offset in scalar elements. + +indexInt8OffAddrAsInt8X32# :: Addr# -> Int# -> Int8X32# +indexInt8OffAddrAsInt8X32# = let x = x in x + +-- | Reads vector; offset in scalar elements. + +indexInt16OffAddrAsInt16X16# :: Addr# -> Int# -> Int16X16# +indexInt16OffAddrAsInt16X16# = let x = x in x + +-- | Reads vector; offset in scalar elements. + +indexInt32OffAddrAsInt32X8# :: Addr# -> Int# -> Int32X8# +indexInt32OffAddrAsInt32X8# = let x = x in x + +-- | Reads vector; offset in scalar elements. + +indexInt64OffAddrAsInt64X4# :: Addr# -> Int# -> Int64X4# +indexInt64OffAddrAsInt64X4# = let x = x in x + +-- | Reads vector; offset in scalar elements. + +indexInt8OffAddrAsInt8X64# :: Addr# -> Int# -> Int8X64# +indexInt8OffAddrAsInt8X64# = let x = x in x + +-- | Reads vector; offset in scalar elements. + +indexInt16OffAddrAsInt16X32# :: Addr# -> Int# -> Int16X32# +indexInt16OffAddrAsInt16X32# = let x = x in x + +-- | Reads vector; offset in scalar elements. + +indexInt32OffAddrAsInt32X16# :: Addr# -> Int# -> Int32X16# +indexInt32OffAddrAsInt32X16# = let x = x in x + +-- | Reads vector; offset in scalar elements. + +indexInt64OffAddrAsInt64X8# :: Addr# -> Int# -> Int64X8# +indexInt64OffAddrAsInt64X8# = let x = x in x + +-- | Reads vector; offset in scalar elements. + +indexWord8OffAddrAsWord8X16# :: Addr# -> Int# -> Word8X16# +indexWord8OffAddrAsWord8X16# = let x = x in x + +-- | Reads vector; offset in scalar elements. + +indexWord16OffAddrAsWord16X8# :: Addr# -> Int# -> Word16X8# +indexWord16OffAddrAsWord16X8# = let x = x in x + +-- | Reads vector; offset in scalar elements. + +indexWord32OffAddrAsWord32X4# :: Addr# -> Int# -> Word32X4# +indexWord32OffAddrAsWord32X4# = let x = x in x + +-- | Reads vector; offset in scalar elements. + +indexWord64OffAddrAsWord64X2# :: Addr# -> Int# -> Word64X2# +indexWord64OffAddrAsWord64X2# = let x = x in x + +-- | Reads vector; offset in scalar elements. + +indexWord8OffAddrAsWord8X32# :: Addr# -> Int# -> Word8X32# +indexWord8OffAddrAsWord8X32# = let x = x in x + +-- | Reads vector; offset in scalar elements. + +indexWord16OffAddrAsWord16X16# :: Addr# -> Int# -> Word16X16# +indexWord16OffAddrAsWord16X16# = let x = x in x + +-- | Reads vector; offset in scalar elements. + +indexWord32OffAddrAsWord32X8# :: Addr# -> Int# -> Word32X8# +indexWord32OffAddrAsWord32X8# = let x = x in x + +-- | Reads vector; offset in scalar elements. + +indexWord64OffAddrAsWord64X4# :: Addr# -> Int# -> Word64X4# +indexWord64OffAddrAsWord64X4# = let x = x in x + +-- | Reads vector; offset in scalar elements. + +indexWord8OffAddrAsWord8X64# :: Addr# -> Int# -> Word8X64# +indexWord8OffAddrAsWord8X64# = let x = x in x + +-- | Reads vector; offset in scalar elements. + +indexWord16OffAddrAsWord16X32# :: Addr# -> Int# -> Word16X32# +indexWord16OffAddrAsWord16X32# = let x = x in x + +-- | Reads vector; offset in scalar elements. + +indexWord32OffAddrAsWord32X16# :: Addr# -> Int# -> Word32X16# +indexWord32OffAddrAsWord32X16# = let x = x in x + +-- | Reads vector; offset in scalar elements. + +indexWord64OffAddrAsWord64X8# :: Addr# -> Int# -> Word64X8# +indexWord64OffAddrAsWord64X8# = let x = x in x + +-- | Reads vector; offset in scalar elements. + +indexFloatOffAddrAsFloatX4# :: Addr# -> Int# -> FloatX4# +indexFloatOffAddrAsFloatX4# = let x = x in x + +-- | Reads vector; offset in scalar elements. + +indexDoubleOffAddrAsDoubleX2# :: Addr# -> Int# -> DoubleX2# +indexDoubleOffAddrAsDoubleX2# = let x = x in x + +-- | Reads vector; offset in scalar elements. + +indexFloatOffAddrAsFloatX8# :: Addr# -> Int# -> FloatX8# +indexFloatOffAddrAsFloatX8# = let x = x in x + +-- | Reads vector; offset in scalar elements. + +indexDoubleOffAddrAsDoubleX4# :: Addr# -> Int# -> DoubleX4# +indexDoubleOffAddrAsDoubleX4# = let x = x in x + +-- | Reads vector; offset in scalar elements. + +indexFloatOffAddrAsFloatX16# :: Addr# -> Int# -> FloatX16# +indexFloatOffAddrAsFloatX16# = let x = x in x + +-- | Reads vector; offset in scalar elements. + +indexDoubleOffAddrAsDoubleX8# :: Addr# -> Int# -> DoubleX8# +indexDoubleOffAddrAsDoubleX8# = let x = x in x + +-- | Reads vector; offset in scalar elements. + +readInt8OffAddrAsInt8X16# :: Addr# -> Int# -> State# s -> (# State# s,Int8X16# #) +readInt8OffAddrAsInt8X16# = let x = x in x + +-- | Reads vector; offset in scalar elements. + +readInt16OffAddrAsInt16X8# :: Addr# -> Int# -> State# s -> (# State# s,Int16X8# #) +readInt16OffAddrAsInt16X8# = let x = x in x + +-- | Reads vector; offset in scalar elements. + +readInt32OffAddrAsInt32X4# :: Addr# -> Int# -> State# s -> (# State# s,Int32X4# #) +readInt32OffAddrAsInt32X4# = let x = x in x + +-- | Reads vector; offset in scalar elements. + +readInt64OffAddrAsInt64X2# :: Addr# -> Int# -> State# s -> (# State# s,Int64X2# #) +readInt64OffAddrAsInt64X2# = let x = x in x + +-- | Reads vector; offset in scalar elements. + +readInt8OffAddrAsInt8X32# :: Addr# -> Int# -> State# s -> (# State# s,Int8X32# #) +readInt8OffAddrAsInt8X32# = let x = x in x + +-- | Reads vector; offset in scalar elements. + +readInt16OffAddrAsInt16X16# :: Addr# -> Int# -> State# s -> (# State# s,Int16X16# #) +readInt16OffAddrAsInt16X16# = let x = x in x + +-- | Reads vector; offset in scalar elements. + +readInt32OffAddrAsInt32X8# :: Addr# -> Int# -> State# s -> (# State# s,Int32X8# #) +readInt32OffAddrAsInt32X8# = let x = x in x + +-- | Reads vector; offset in scalar elements. + +readInt64OffAddrAsInt64X4# :: Addr# -> Int# -> State# s -> (# State# s,Int64X4# #) +readInt64OffAddrAsInt64X4# = let x = x in x + +-- | Reads vector; offset in scalar elements. + +readInt8OffAddrAsInt8X64# :: Addr# -> Int# -> State# s -> (# State# s,Int8X64# #) +readInt8OffAddrAsInt8X64# = let x = x in x + +-- | Reads vector; offset in scalar elements. + +readInt16OffAddrAsInt16X32# :: Addr# -> Int# -> State# s -> (# State# s,Int16X32# #) +readInt16OffAddrAsInt16X32# = let x = x in x + +-- | Reads vector; offset in scalar elements. + +readInt32OffAddrAsInt32X16# :: Addr# -> Int# -> State# s -> (# State# s,Int32X16# #) +readInt32OffAddrAsInt32X16# = let x = x in x + +-- | Reads vector; offset in scalar elements. + +readInt64OffAddrAsInt64X8# :: Addr# -> Int# -> State# s -> (# State# s,Int64X8# #) +readInt64OffAddrAsInt64X8# = let x = x in x + +-- | Reads vector; offset in scalar elements. + +readWord8OffAddrAsWord8X16# :: Addr# -> Int# -> State# s -> (# State# s,Word8X16# #) +readWord8OffAddrAsWord8X16# = let x = x in x + +-- | Reads vector; offset in scalar elements. + +readWord16OffAddrAsWord16X8# :: Addr# -> Int# -> State# s -> (# State# s,Word16X8# #) +readWord16OffAddrAsWord16X8# = let x = x in x + +-- | Reads vector; offset in scalar elements. + +readWord32OffAddrAsWord32X4# :: Addr# -> Int# -> State# s -> (# State# s,Word32X4# #) +readWord32OffAddrAsWord32X4# = let x = x in x + +-- | Reads vector; offset in scalar elements. + +readWord64OffAddrAsWord64X2# :: Addr# -> Int# -> State# s -> (# State# s,Word64X2# #) +readWord64OffAddrAsWord64X2# = let x = x in x + +-- | Reads vector; offset in scalar elements. + +readWord8OffAddrAsWord8X32# :: Addr# -> Int# -> State# s -> (# State# s,Word8X32# #) +readWord8OffAddrAsWord8X32# = let x = x in x + +-- | Reads vector; offset in scalar elements. + +readWord16OffAddrAsWord16X16# :: Addr# -> Int# -> State# s -> (# State# s,Word16X16# #) +readWord16OffAddrAsWord16X16# = let x = x in x + +-- | Reads vector; offset in scalar elements. + +readWord32OffAddrAsWord32X8# :: Addr# -> Int# -> State# s -> (# State# s,Word32X8# #) +readWord32OffAddrAsWord32X8# = let x = x in x + +-- | Reads vector; offset in scalar elements. + +readWord64OffAddrAsWord64X4# :: Addr# -> Int# -> State# s -> (# State# s,Word64X4# #) +readWord64OffAddrAsWord64X4# = let x = x in x + +-- | Reads vector; offset in scalar elements. + +readWord8OffAddrAsWord8X64# :: Addr# -> Int# -> State# s -> (# State# s,Word8X64# #) +readWord8OffAddrAsWord8X64# = let x = x in x + +-- | Reads vector; offset in scalar elements. + +readWord16OffAddrAsWord16X32# :: Addr# -> Int# -> State# s -> (# State# s,Word16X32# #) +readWord16OffAddrAsWord16X32# = let x = x in x + +-- | Reads vector; offset in scalar elements. + +readWord32OffAddrAsWord32X16# :: Addr# -> Int# -> State# s -> (# State# s,Word32X16# #) +readWord32OffAddrAsWord32X16# = let x = x in x + +-- | Reads vector; offset in scalar elements. + +readWord64OffAddrAsWord64X8# :: Addr# -> Int# -> State# s -> (# State# s,Word64X8# #) +readWord64OffAddrAsWord64X8# = let x = x in x + +-- | Reads vector; offset in scalar elements. + +readFloatOffAddrAsFloatX4# :: Addr# -> Int# -> State# s -> (# State# s,FloatX4# #) +readFloatOffAddrAsFloatX4# = let x = x in x + +-- | Reads vector; offset in scalar elements. + +readDoubleOffAddrAsDoubleX2# :: Addr# -> Int# -> State# s -> (# State# s,DoubleX2# #) +readDoubleOffAddrAsDoubleX2# = let x = x in x + +-- | Reads vector; offset in scalar elements. + +readFloatOffAddrAsFloatX8# :: Addr# -> Int# -> State# s -> (# State# s,FloatX8# #) +readFloatOffAddrAsFloatX8# = let x = x in x + +-- | Reads vector; offset in scalar elements. + +readDoubleOffAddrAsDoubleX4# :: Addr# -> Int# -> State# s -> (# State# s,DoubleX4# #) +readDoubleOffAddrAsDoubleX4# = let x = x in x + +-- | Reads vector; offset in scalar elements. + +readFloatOffAddrAsFloatX16# :: Addr# -> Int# -> State# s -> (# State# s,FloatX16# #) +readFloatOffAddrAsFloatX16# = let x = x in x + +-- | Reads vector; offset in scalar elements. + +readDoubleOffAddrAsDoubleX8# :: Addr# -> Int# -> State# s -> (# State# s,DoubleX8# #) +readDoubleOffAddrAsDoubleX8# = let x = x in x + +-- | Write vector; offset in scalar elements. + +writeInt8OffAddrAsInt8X16# :: Addr# -> Int# -> Int8X16# -> State# s -> State# s +writeInt8OffAddrAsInt8X16# = let x = x in x + +-- | Write vector; offset in scalar elements. + +writeInt16OffAddrAsInt16X8# :: Addr# -> Int# -> Int16X8# -> State# s -> State# s +writeInt16OffAddrAsInt16X8# = let x = x in x + +-- | Write vector; offset in scalar elements. + +writeInt32OffAddrAsInt32X4# :: Addr# -> Int# -> Int32X4# -> State# s -> State# s +writeInt32OffAddrAsInt32X4# = let x = x in x + +-- | Write vector; offset in scalar elements. + +writeInt64OffAddrAsInt64X2# :: Addr# -> Int# -> Int64X2# -> State# s -> State# s +writeInt64OffAddrAsInt64X2# = let x = x in x + +-- | Write vector; offset in scalar elements. + +writeInt8OffAddrAsInt8X32# :: Addr# -> Int# -> Int8X32# -> State# s -> State# s +writeInt8OffAddrAsInt8X32# = let x = x in x + +-- | Write vector; offset in scalar elements. + +writeInt16OffAddrAsInt16X16# :: Addr# -> Int# -> Int16X16# -> State# s -> State# s +writeInt16OffAddrAsInt16X16# = let x = x in x + +-- | Write vector; offset in scalar elements. + +writeInt32OffAddrAsInt32X8# :: Addr# -> Int# -> Int32X8# -> State# s -> State# s +writeInt32OffAddrAsInt32X8# = let x = x in x + +-- | Write vector; offset in scalar elements. + +writeInt64OffAddrAsInt64X4# :: Addr# -> Int# -> Int64X4# -> State# s -> State# s +writeInt64OffAddrAsInt64X4# = let x = x in x + +-- | Write vector; offset in scalar elements. + +writeInt8OffAddrAsInt8X64# :: Addr# -> Int# -> Int8X64# -> State# s -> State# s +writeInt8OffAddrAsInt8X64# = let x = x in x + +-- | Write vector; offset in scalar elements. + +writeInt16OffAddrAsInt16X32# :: Addr# -> Int# -> Int16X32# -> State# s -> State# s +writeInt16OffAddrAsInt16X32# = let x = x in x + +-- | Write vector; offset in scalar elements. + +writeInt32OffAddrAsInt32X16# :: Addr# -> Int# -> Int32X16# -> State# s -> State# s +writeInt32OffAddrAsInt32X16# = let x = x in x + +-- | Write vector; offset in scalar elements. + +writeInt64OffAddrAsInt64X8# :: Addr# -> Int# -> Int64X8# -> State# s -> State# s +writeInt64OffAddrAsInt64X8# = let x = x in x + +-- | Write vector; offset in scalar elements. + +writeWord8OffAddrAsWord8X16# :: Addr# -> Int# -> Word8X16# -> State# s -> State# s +writeWord8OffAddrAsWord8X16# = let x = x in x + +-- | Write vector; offset in scalar elements. + +writeWord16OffAddrAsWord16X8# :: Addr# -> Int# -> Word16X8# -> State# s -> State# s +writeWord16OffAddrAsWord16X8# = let x = x in x + +-- | Write vector; offset in scalar elements. + +writeWord32OffAddrAsWord32X4# :: Addr# -> Int# -> Word32X4# -> State# s -> State# s +writeWord32OffAddrAsWord32X4# = let x = x in x + +-- | Write vector; offset in scalar elements. + +writeWord64OffAddrAsWord64X2# :: Addr# -> Int# -> Word64X2# -> State# s -> State# s +writeWord64OffAddrAsWord64X2# = let x = x in x + +-- | Write vector; offset in scalar elements. + +writeWord8OffAddrAsWord8X32# :: Addr# -> Int# -> Word8X32# -> State# s -> State# s +writeWord8OffAddrAsWord8X32# = let x = x in x + +-- | Write vector; offset in scalar elements. + +writeWord16OffAddrAsWord16X16# :: Addr# -> Int# -> Word16X16# -> State# s -> State# s +writeWord16OffAddrAsWord16X16# = let x = x in x + +-- | Write vector; offset in scalar elements. + +writeWord32OffAddrAsWord32X8# :: Addr# -> Int# -> Word32X8# -> State# s -> State# s +writeWord32OffAddrAsWord32X8# = let x = x in x + +-- | Write vector; offset in scalar elements. + +writeWord64OffAddrAsWord64X4# :: Addr# -> Int# -> Word64X4# -> State# s -> State# s +writeWord64OffAddrAsWord64X4# = let x = x in x + +-- | Write vector; offset in scalar elements. + +writeWord8OffAddrAsWord8X64# :: Addr# -> Int# -> Word8X64# -> State# s -> State# s +writeWord8OffAddrAsWord8X64# = let x = x in x + +-- | Write vector; offset in scalar elements. + +writeWord16OffAddrAsWord16X32# :: Addr# -> Int# -> Word16X32# -> State# s -> State# s +writeWord16OffAddrAsWord16X32# = let x = x in x + +-- | Write vector; offset in scalar elements. + +writeWord32OffAddrAsWord32X16# :: Addr# -> Int# -> Word32X16# -> State# s -> State# s +writeWord32OffAddrAsWord32X16# = let x = x in x + +-- | Write vector; offset in scalar elements. + +writeWord64OffAddrAsWord64X8# :: Addr# -> Int# -> Word64X8# -> State# s -> State# s +writeWord64OffAddrAsWord64X8# = let x = x in x + +-- | Write vector; offset in scalar elements. + +writeFloatOffAddrAsFloatX4# :: Addr# -> Int# -> FloatX4# -> State# s -> State# s +writeFloatOffAddrAsFloatX4# = let x = x in x + +-- | Write vector; offset in scalar elements. + +writeDoubleOffAddrAsDoubleX2# :: Addr# -> Int# -> DoubleX2# -> State# s -> State# s +writeDoubleOffAddrAsDoubleX2# = let x = x in x + +-- | Write vector; offset in scalar elements. + +writeFloatOffAddrAsFloatX8# :: Addr# -> Int# -> FloatX8# -> State# s -> State# s +writeFloatOffAddrAsFloatX8# = let x = x in x + +-- | Write vector; offset in scalar elements. + +writeDoubleOffAddrAsDoubleX4# :: Addr# -> Int# -> DoubleX4# -> State# s -> State# s +writeDoubleOffAddrAsDoubleX4# = let x = x in x + +-- | Write vector; offset in scalar elements. + +writeFloatOffAddrAsFloatX16# :: Addr# -> Int# -> FloatX16# -> State# s -> State# s +writeFloatOffAddrAsFloatX16# = let x = x in x + +-- | Write vector; offset in scalar elements. + +writeDoubleOffAddrAsDoubleX8# :: Addr# -> Int# -> DoubleX8# -> State# s -> State# s +writeDoubleOffAddrAsDoubleX8# = let x = x in x + +prefetchByteArray3# :: ByteArray# -> Int# -> ByteArray# +prefetchByteArray3# = let x = x in x + +prefetchMutableByteArray3# :: MutableByteArray# s -> Int# -> State# s -> State# s +prefetchMutableByteArray3# = let x = x in x + +prefetchAddr3# :: Addr# -> Int# -> Addr# +prefetchAddr3# = let x = x in x + +prefetchByteArray2# :: ByteArray# -> Int# -> ByteArray# +prefetchByteArray2# = let x = x in x + +prefetchMutableByteArray2# :: MutableByteArray# s -> Int# -> State# s -> State# s +prefetchMutableByteArray2# = let x = x in x + +prefetchAddr2# :: Addr# -> Int# -> Addr# +prefetchAddr2# = let x = x in x + +prefetchByteArray1# :: ByteArray# -> Int# -> ByteArray# +prefetchByteArray1# = let x = x in x + +prefetchMutableByteArray1# :: MutableByteArray# s -> Int# -> State# s -> State# s +prefetchMutableByteArray1# = let x = x in x + +prefetchAddr1# :: Addr# -> Int# -> Addr# +prefetchAddr1# = let x = x in x + +prefetchByteArray0# :: ByteArray# -> Int# -> ByteArray# +prefetchByteArray0# = let x = x in x + +prefetchMutableByteArray0# :: MutableByteArray# s -> Int# -> State# s -> State# s +prefetchMutableByteArray0# = let x = x in x + +prefetchAddr0# :: Addr# -> Int# -> Addr# +prefetchAddr0# = let x = x in x + + + diff --git a/GHC/PrimopWrappers.hs b/GHC/PrimopWrappers.hs new file mode 100644 --- /dev/null +++ b/GHC/PrimopWrappers.hs @@ -0,0 +1,1100 @@ +{-# LANGUAGE MagicHash, NoImplicitPrelude, UnboxedTuples #-} +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#) +{-# NOINLINE gtChar# #-} +gtChar# :: Char# -> Char# -> Int# +gtChar# a1 a2 = (GHC.Prim.gtChar#) a1 a2 +{-# NOINLINE geChar# #-} +geChar# :: Char# -> Char# -> Int# +geChar# a1 a2 = (GHC.Prim.geChar#) a1 a2 +{-# NOINLINE eqChar# #-} +eqChar# :: Char# -> Char# -> Int# +eqChar# a1 a2 = (GHC.Prim.eqChar#) a1 a2 +{-# NOINLINE neChar# #-} +neChar# :: Char# -> Char# -> Int# +neChar# a1 a2 = (GHC.Prim.neChar#) a1 a2 +{-# NOINLINE ltChar# #-} +ltChar# :: Char# -> Char# -> Int# +ltChar# a1 a2 = (GHC.Prim.ltChar#) a1 a2 +{-# NOINLINE leChar# #-} +leChar# :: Char# -> Char# -> Int# +leChar# a1 a2 = (GHC.Prim.leChar#) a1 a2 +{-# NOINLINE ord# #-} +ord# :: Char# -> Int# +ord# a1 = (GHC.Prim.ord#) a1 +{-# NOINLINE (+#) #-} +(+#) :: Int# -> Int# -> Int# +(+#) a1 a2 = (GHC.Prim.+#) a1 a2 +{-# NOINLINE (-#) #-} +(-#) :: Int# -> Int# -> Int# +(-#) a1 a2 = (GHC.Prim.-#) a1 a2 +{-# NOINLINE (*#) #-} +(*#) :: Int# -> Int# -> Int# +(*#) a1 a2 = (GHC.Prim.*#) a1 a2 +{-# NOINLINE mulIntMayOflo# #-} +mulIntMayOflo# :: Int# -> Int# -> Int# +mulIntMayOflo# a1 a2 = (GHC.Prim.mulIntMayOflo#) a1 a2 +{-# NOINLINE quotInt# #-} +quotInt# :: Int# -> Int# -> Int# +quotInt# a1 a2 = (GHC.Prim.quotInt#) a1 a2 +{-# NOINLINE remInt# #-} +remInt# :: Int# -> Int# -> Int# +remInt# a1 a2 = (GHC.Prim.remInt#) a1 a2 +{-# NOINLINE quotRemInt# #-} +quotRemInt# :: Int# -> Int# -> (# Int#,Int# #) +quotRemInt# a1 a2 = (GHC.Prim.quotRemInt#) a1 a2 +{-# NOINLINE andI# #-} +andI# :: Int# -> Int# -> Int# +andI# a1 a2 = (GHC.Prim.andI#) a1 a2 +{-# NOINLINE orI# #-} +orI# :: Int# -> Int# -> Int# +orI# a1 a2 = (GHC.Prim.orI#) a1 a2 +{-# NOINLINE xorI# #-} +xorI# :: Int# -> Int# -> Int# +xorI# a1 a2 = (GHC.Prim.xorI#) a1 a2 +{-# NOINLINE notI# #-} +notI# :: Int# -> Int# +notI# a1 = (GHC.Prim.notI#) a1 +{-# NOINLINE negateInt# #-} +negateInt# :: Int# -> Int# +negateInt# a1 = (GHC.Prim.negateInt#) a1 +{-# NOINLINE addIntC# #-} +addIntC# :: Int# -> Int# -> (# Int#,Int# #) +addIntC# a1 a2 = (GHC.Prim.addIntC#) a1 a2 +{-# NOINLINE subIntC# #-} +subIntC# :: Int# -> Int# -> (# Int#,Int# #) +subIntC# a1 a2 = (GHC.Prim.subIntC#) a1 a2 +{-# NOINLINE (>#) #-} +(>#) :: Int# -> Int# -> Int# +(>#) a1 a2 = (GHC.Prim.>#) a1 a2 +{-# NOINLINE (>=#) #-} +(>=#) :: Int# -> Int# -> Int# +(>=#) a1 a2 = (GHC.Prim.>=#) a1 a2 +{-# NOINLINE (==#) #-} +(==#) :: Int# -> Int# -> Int# +(==#) a1 a2 = (GHC.Prim.==#) a1 a2 +{-# NOINLINE (/=#) #-} +(/=#) :: Int# -> Int# -> Int# +(/=#) a1 a2 = (GHC.Prim./=#) a1 a2 +{-# NOINLINE (<#) #-} +(<#) :: Int# -> Int# -> Int# +(<#) a1 a2 = (GHC.Prim.<#) a1 a2 +{-# NOINLINE (<=#) #-} +(<=#) :: Int# -> Int# -> Int# +(<=#) a1 a2 = (GHC.Prim.<=#) a1 a2 +{-# NOINLINE chr# #-} +chr# :: Int# -> Char# +chr# a1 = (GHC.Prim.chr#) a1 +{-# NOINLINE int2Word# #-} +int2Word# :: Int# -> Word# +int2Word# a1 = (GHC.Prim.int2Word#) a1 +{-# NOINLINE int2Float# #-} +int2Float# :: Int# -> Float# +int2Float# a1 = (GHC.Prim.int2Float#) a1 +{-# NOINLINE int2Double# #-} +int2Double# :: Int# -> Double# +int2Double# a1 = (GHC.Prim.int2Double#) a1 +{-# NOINLINE word2Float# #-} +word2Float# :: Word# -> Float# +word2Float# a1 = (GHC.Prim.word2Float#) a1 +{-# NOINLINE word2Double# #-} +word2Double# :: Word# -> Double# +word2Double# a1 = (GHC.Prim.word2Double#) a1 +{-# NOINLINE uncheckedIShiftL# #-} +uncheckedIShiftL# :: Int# -> Int# -> Int# +uncheckedIShiftL# a1 a2 = (GHC.Prim.uncheckedIShiftL#) a1 a2 +{-# NOINLINE uncheckedIShiftRA# #-} +uncheckedIShiftRA# :: Int# -> Int# -> Int# +uncheckedIShiftRA# a1 a2 = (GHC.Prim.uncheckedIShiftRA#) a1 a2 +{-# NOINLINE uncheckedIShiftRL# #-} +uncheckedIShiftRL# :: Int# -> Int# -> Int# +uncheckedIShiftRL# a1 a2 = (GHC.Prim.uncheckedIShiftRL#) a1 a2 +{-# NOINLINE plusWord# #-} +plusWord# :: Word# -> Word# -> Word# +plusWord# a1 a2 = (GHC.Prim.plusWord#) a1 a2 +{-# NOINLINE plusWord2# #-} +plusWord2# :: Word# -> Word# -> (# Word#,Word# #) +plusWord2# a1 a2 = (GHC.Prim.plusWord2#) a1 a2 +{-# NOINLINE minusWord# #-} +minusWord# :: Word# -> Word# -> Word# +minusWord# a1 a2 = (GHC.Prim.minusWord#) a1 a2 +{-# NOINLINE timesWord# #-} +timesWord# :: Word# -> Word# -> Word# +timesWord# a1 a2 = (GHC.Prim.timesWord#) a1 a2 +{-# NOINLINE timesWord2# #-} +timesWord2# :: Word# -> Word# -> (# Word#,Word# #) +timesWord2# a1 a2 = (GHC.Prim.timesWord2#) a1 a2 +{-# NOINLINE quotWord# #-} +quotWord# :: Word# -> Word# -> Word# +quotWord# a1 a2 = (GHC.Prim.quotWord#) a1 a2 +{-# NOINLINE remWord# #-} +remWord# :: Word# -> Word# -> Word# +remWord# a1 a2 = (GHC.Prim.remWord#) a1 a2 +{-# NOINLINE quotRemWord# #-} +quotRemWord# :: Word# -> Word# -> (# Word#,Word# #) +quotRemWord# a1 a2 = (GHC.Prim.quotRemWord#) a1 a2 +{-# NOINLINE quotRemWord2# #-} +quotRemWord2# :: Word# -> Word# -> Word# -> (# Word#,Word# #) +quotRemWord2# a1 a2 a3 = (GHC.Prim.quotRemWord2#) a1 a2 a3 +{-# NOINLINE and# #-} +and# :: Word# -> Word# -> Word# +and# a1 a2 = (GHC.Prim.and#) a1 a2 +{-# NOINLINE or# #-} +or# :: Word# -> Word# -> Word# +or# a1 a2 = (GHC.Prim.or#) a1 a2 +{-# NOINLINE xor# #-} +xor# :: Word# -> Word# -> Word# +xor# a1 a2 = (GHC.Prim.xor#) a1 a2 +{-# NOINLINE not# #-} +not# :: Word# -> Word# +not# a1 = (GHC.Prim.not#) a1 +{-# NOINLINE uncheckedShiftL# #-} +uncheckedShiftL# :: Word# -> Int# -> Word# +uncheckedShiftL# a1 a2 = (GHC.Prim.uncheckedShiftL#) a1 a2 +{-# NOINLINE uncheckedShiftRL# #-} +uncheckedShiftRL# :: Word# -> Int# -> Word# +uncheckedShiftRL# a1 a2 = (GHC.Prim.uncheckedShiftRL#) a1 a2 +{-# NOINLINE word2Int# #-} +word2Int# :: Word# -> Int# +word2Int# a1 = (GHC.Prim.word2Int#) a1 +{-# NOINLINE gtWord# #-} +gtWord# :: Word# -> Word# -> Int# +gtWord# a1 a2 = (GHC.Prim.gtWord#) a1 a2 +{-# NOINLINE geWord# #-} +geWord# :: Word# -> Word# -> Int# +geWord# a1 a2 = (GHC.Prim.geWord#) a1 a2 +{-# NOINLINE eqWord# #-} +eqWord# :: Word# -> Word# -> Int# +eqWord# a1 a2 = (GHC.Prim.eqWord#) a1 a2 +{-# NOINLINE neWord# #-} +neWord# :: Word# -> Word# -> Int# +neWord# a1 a2 = (GHC.Prim.neWord#) a1 a2 +{-# NOINLINE ltWord# #-} +ltWord# :: Word# -> Word# -> Int# +ltWord# a1 a2 = (GHC.Prim.ltWord#) a1 a2 +{-# NOINLINE leWord# #-} +leWord# :: Word# -> Word# -> Int# +leWord# a1 a2 = (GHC.Prim.leWord#) a1 a2 +{-# NOINLINE popCnt8# #-} +popCnt8# :: Word# -> Word# +popCnt8# a1 = (GHC.Prim.popCnt8#) a1 +{-# NOINLINE popCnt16# #-} +popCnt16# :: Word# -> Word# +popCnt16# a1 = (GHC.Prim.popCnt16#) a1 +{-# NOINLINE popCnt32# #-} +popCnt32# :: Word# -> Word# +popCnt32# a1 = (GHC.Prim.popCnt32#) a1 +{-# NOINLINE popCnt64# #-} +popCnt64# :: Word# -> Word# +popCnt64# a1 = (GHC.Prim.popCnt64#) a1 +{-# NOINLINE popCnt# #-} +popCnt# :: Word# -> Word# +popCnt# a1 = (GHC.Prim.popCnt#) a1 +{-# NOINLINE byteSwap16# #-} +byteSwap16# :: Word# -> Word# +byteSwap16# a1 = (GHC.Prim.byteSwap16#) a1 +{-# NOINLINE byteSwap32# #-} +byteSwap32# :: Word# -> Word# +byteSwap32# a1 = (GHC.Prim.byteSwap32#) a1 +{-# NOINLINE byteSwap64# #-} +byteSwap64# :: Word# -> Word# +byteSwap64# a1 = (GHC.Prim.byteSwap64#) a1 +{-# NOINLINE byteSwap# #-} +byteSwap# :: Word# -> Word# +byteSwap# a1 = (GHC.Prim.byteSwap#) a1 +{-# NOINLINE narrow8Int# #-} +narrow8Int# :: Int# -> Int# +narrow8Int# a1 = (GHC.Prim.narrow8Int#) a1 +{-# NOINLINE narrow16Int# #-} +narrow16Int# :: Int# -> Int# +narrow16Int# a1 = (GHC.Prim.narrow16Int#) a1 +{-# NOINLINE narrow32Int# #-} +narrow32Int# :: Int# -> Int# +narrow32Int# a1 = (GHC.Prim.narrow32Int#) a1 +{-# NOINLINE narrow8Word# #-} +narrow8Word# :: Word# -> Word# +narrow8Word# a1 = (GHC.Prim.narrow8Word#) a1 +{-# NOINLINE narrow16Word# #-} +narrow16Word# :: Word# -> Word# +narrow16Word# a1 = (GHC.Prim.narrow16Word#) a1 +{-# NOINLINE narrow32Word# #-} +narrow32Word# :: Word# -> Word# +narrow32Word# a1 = (GHC.Prim.narrow32Word#) a1 +{-# NOINLINE (>##) #-} +(>##) :: Double# -> Double# -> Int# +(>##) a1 a2 = (GHC.Prim.>##) a1 a2 +{-# NOINLINE (>=##) #-} +(>=##) :: Double# -> Double# -> Int# +(>=##) a1 a2 = (GHC.Prim.>=##) a1 a2 +{-# NOINLINE (==##) #-} +(==##) :: Double# -> Double# -> Int# +(==##) a1 a2 = (GHC.Prim.==##) a1 a2 +{-# NOINLINE (/=##) #-} +(/=##) :: Double# -> Double# -> Int# +(/=##) a1 a2 = (GHC.Prim./=##) a1 a2 +{-# NOINLINE (<##) #-} +(<##) :: Double# -> Double# -> Int# +(<##) a1 a2 = (GHC.Prim.<##) a1 a2 +{-# NOINLINE (<=##) #-} +(<=##) :: Double# -> Double# -> Int# +(<=##) a1 a2 = (GHC.Prim.<=##) a1 a2 +{-# NOINLINE (+##) #-} +(+##) :: Double# -> Double# -> Double# +(+##) a1 a2 = (GHC.Prim.+##) a1 a2 +{-# NOINLINE (-##) #-} +(-##) :: Double# -> Double# -> Double# +(-##) a1 a2 = (GHC.Prim.-##) a1 a2 +{-# NOINLINE (*##) #-} +(*##) :: Double# -> Double# -> Double# +(*##) a1 a2 = (GHC.Prim.*##) a1 a2 +{-# NOINLINE (/##) #-} +(/##) :: Double# -> Double# -> Double# +(/##) a1 a2 = (GHC.Prim./##) a1 a2 +{-# NOINLINE negateDouble# #-} +negateDouble# :: Double# -> Double# +negateDouble# a1 = (GHC.Prim.negateDouble#) a1 +{-# NOINLINE double2Int# #-} +double2Int# :: Double# -> Int# +double2Int# a1 = (GHC.Prim.double2Int#) a1 +{-# NOINLINE double2Float# #-} +double2Float# :: Double# -> Float# +double2Float# a1 = (GHC.Prim.double2Float#) a1 +{-# NOINLINE expDouble# #-} +expDouble# :: Double# -> Double# +expDouble# a1 = (GHC.Prim.expDouble#) a1 +{-# NOINLINE logDouble# #-} +logDouble# :: Double# -> Double# +logDouble# a1 = (GHC.Prim.logDouble#) a1 +{-# NOINLINE sqrtDouble# #-} +sqrtDouble# :: Double# -> Double# +sqrtDouble# a1 = (GHC.Prim.sqrtDouble#) a1 +{-# NOINLINE sinDouble# #-} +sinDouble# :: Double# -> Double# +sinDouble# a1 = (GHC.Prim.sinDouble#) a1 +{-# NOINLINE cosDouble# #-} +cosDouble# :: Double# -> Double# +cosDouble# a1 = (GHC.Prim.cosDouble#) a1 +{-# NOINLINE tanDouble# #-} +tanDouble# :: Double# -> Double# +tanDouble# a1 = (GHC.Prim.tanDouble#) a1 +{-# NOINLINE asinDouble# #-} +asinDouble# :: Double# -> Double# +asinDouble# a1 = (GHC.Prim.asinDouble#) a1 +{-# NOINLINE acosDouble# #-} +acosDouble# :: Double# -> Double# +acosDouble# a1 = (GHC.Prim.acosDouble#) a1 +{-# NOINLINE atanDouble# #-} +atanDouble# :: Double# -> Double# +atanDouble# a1 = (GHC.Prim.atanDouble#) a1 +{-# NOINLINE sinhDouble# #-} +sinhDouble# :: Double# -> Double# +sinhDouble# a1 = (GHC.Prim.sinhDouble#) a1 +{-# NOINLINE coshDouble# #-} +coshDouble# :: Double# -> Double# +coshDouble# a1 = (GHC.Prim.coshDouble#) a1 +{-# NOINLINE tanhDouble# #-} +tanhDouble# :: Double# -> Double# +tanhDouble# a1 = (GHC.Prim.tanhDouble#) a1 +{-# NOINLINE (**##) #-} +(**##) :: Double# -> Double# -> Double# +(**##) a1 a2 = (GHC.Prim.**##) a1 a2 +{-# NOINLINE decodeDouble_2Int# #-} +decodeDouble_2Int# :: Double# -> (# Int#,Word#,Word#,Int# #) +decodeDouble_2Int# a1 = (GHC.Prim.decodeDouble_2Int#) a1 +{-# NOINLINE gtFloat# #-} +gtFloat# :: Float# -> Float# -> Int# +gtFloat# a1 a2 = (GHC.Prim.gtFloat#) a1 a2 +{-# NOINLINE geFloat# #-} +geFloat# :: Float# -> Float# -> Int# +geFloat# a1 a2 = (GHC.Prim.geFloat#) a1 a2 +{-# NOINLINE eqFloat# #-} +eqFloat# :: Float# -> Float# -> Int# +eqFloat# a1 a2 = (GHC.Prim.eqFloat#) a1 a2 +{-# NOINLINE neFloat# #-} +neFloat# :: Float# -> Float# -> Int# +neFloat# a1 a2 = (GHC.Prim.neFloat#) a1 a2 +{-# NOINLINE ltFloat# #-} +ltFloat# :: Float# -> Float# -> Int# +ltFloat# a1 a2 = (GHC.Prim.ltFloat#) a1 a2 +{-# NOINLINE leFloat# #-} +leFloat# :: Float# -> Float# -> Int# +leFloat# a1 a2 = (GHC.Prim.leFloat#) a1 a2 +{-# NOINLINE plusFloat# #-} +plusFloat# :: Float# -> Float# -> Float# +plusFloat# a1 a2 = (GHC.Prim.plusFloat#) a1 a2 +{-# NOINLINE minusFloat# #-} +minusFloat# :: Float# -> Float# -> Float# +minusFloat# a1 a2 = (GHC.Prim.minusFloat#) a1 a2 +{-# NOINLINE timesFloat# #-} +timesFloat# :: Float# -> Float# -> Float# +timesFloat# a1 a2 = (GHC.Prim.timesFloat#) a1 a2 +{-# NOINLINE divideFloat# #-} +divideFloat# :: Float# -> Float# -> Float# +divideFloat# a1 a2 = (GHC.Prim.divideFloat#) a1 a2 +{-# NOINLINE negateFloat# #-} +negateFloat# :: Float# -> Float# +negateFloat# a1 = (GHC.Prim.negateFloat#) a1 +{-# NOINLINE float2Int# #-} +float2Int# :: Float# -> Int# +float2Int# a1 = (GHC.Prim.float2Int#) a1 +{-# NOINLINE expFloat# #-} +expFloat# :: Float# -> Float# +expFloat# a1 = (GHC.Prim.expFloat#) a1 +{-# NOINLINE logFloat# #-} +logFloat# :: Float# -> Float# +logFloat# a1 = (GHC.Prim.logFloat#) a1 +{-# NOINLINE sqrtFloat# #-} +sqrtFloat# :: Float# -> Float# +sqrtFloat# a1 = (GHC.Prim.sqrtFloat#) a1 +{-# NOINLINE sinFloat# #-} +sinFloat# :: Float# -> Float# +sinFloat# a1 = (GHC.Prim.sinFloat#) a1 +{-# NOINLINE cosFloat# #-} +cosFloat# :: Float# -> Float# +cosFloat# a1 = (GHC.Prim.cosFloat#) a1 +{-# NOINLINE tanFloat# #-} +tanFloat# :: Float# -> Float# +tanFloat# a1 = (GHC.Prim.tanFloat#) a1 +{-# NOINLINE asinFloat# #-} +asinFloat# :: Float# -> Float# +asinFloat# a1 = (GHC.Prim.asinFloat#) a1 +{-# NOINLINE acosFloat# #-} +acosFloat# :: Float# -> Float# +acosFloat# a1 = (GHC.Prim.acosFloat#) a1 +{-# NOINLINE atanFloat# #-} +atanFloat# :: Float# -> Float# +atanFloat# a1 = (GHC.Prim.atanFloat#) a1 +{-# NOINLINE sinhFloat# #-} +sinhFloat# :: Float# -> Float# +sinhFloat# a1 = (GHC.Prim.sinhFloat#) a1 +{-# NOINLINE coshFloat# #-} +coshFloat# :: Float# -> Float# +coshFloat# a1 = (GHC.Prim.coshFloat#) a1 +{-# NOINLINE tanhFloat# #-} +tanhFloat# :: Float# -> Float# +tanhFloat# a1 = (GHC.Prim.tanhFloat#) a1 +{-# NOINLINE powerFloat# #-} +powerFloat# :: Float# -> Float# -> Float# +powerFloat# a1 a2 = (GHC.Prim.powerFloat#) a1 a2 +{-# NOINLINE float2Double# #-} +float2Double# :: Float# -> Double# +float2Double# a1 = (GHC.Prim.float2Double#) a1 +{-# NOINLINE decodeFloat_Int# #-} +decodeFloat_Int# :: Float# -> (# Int#,Int# #) +decodeFloat_Int# a1 = (GHC.Prim.decodeFloat_Int#) a1 +{-# NOINLINE newArray# #-} +newArray# :: Int# -> a -> State# s -> (# State# s,MutableArray# s a #) +newArray# a1 a2 a3 = (GHC.Prim.newArray#) a1 a2 a3 +{-# NOINLINE sameMutableArray# #-} +sameMutableArray# :: MutableArray# s a -> MutableArray# s a -> Int# +sameMutableArray# a1 a2 = (GHC.Prim.sameMutableArray#) a1 a2 +{-# NOINLINE readArray# #-} +readArray# :: MutableArray# s a -> Int# -> State# s -> (# State# s,a #) +readArray# a1 a2 a3 = (GHC.Prim.readArray#) a1 a2 a3 +{-# NOINLINE writeArray# #-} +writeArray# :: MutableArray# s a -> Int# -> a -> State# s -> State# s +writeArray# a1 a2 a3 a4 = (GHC.Prim.writeArray#) a1 a2 a3 a4 +{-# NOINLINE sizeofArray# #-} +sizeofArray# :: Array# a -> Int# +sizeofArray# a1 = (GHC.Prim.sizeofArray#) a1 +{-# NOINLINE sizeofMutableArray# #-} +sizeofMutableArray# :: MutableArray# s a -> Int# +sizeofMutableArray# a1 = (GHC.Prim.sizeofMutableArray#) a1 +{-# NOINLINE indexArray# #-} +indexArray# :: Array# a -> Int# -> (# a #) +indexArray# a1 a2 = (GHC.Prim.indexArray#) a1 a2 +{-# NOINLINE unsafeFreezeArray# #-} +unsafeFreezeArray# :: MutableArray# s a -> State# s -> (# State# s,Array# a #) +unsafeFreezeArray# a1 a2 = (GHC.Prim.unsafeFreezeArray#) a1 a2 +{-# NOINLINE unsafeThawArray# #-} +unsafeThawArray# :: Array# a -> State# s -> (# State# s,MutableArray# s a #) +unsafeThawArray# a1 a2 = (GHC.Prim.unsafeThawArray#) a1 a2 +{-# NOINLINE copyArray# #-} +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 +{-# NOINLINE copyMutableArray# #-} +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 +{-# NOINLINE cloneArray# #-} +cloneArray# :: Array# a -> Int# -> Int# -> Array# a +cloneArray# a1 a2 a3 = (GHC.Prim.cloneArray#) a1 a2 a3 +{-# NOINLINE cloneMutableArray# #-} +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 +{-# NOINLINE freezeArray# #-} +freezeArray# :: MutableArray# s a -> Int# -> Int# -> State# s -> (# State# s,Array# a #) +freezeArray# a1 a2 a3 a4 = (GHC.Prim.freezeArray#) a1 a2 a3 a4 +{-# NOINLINE thawArray# #-} +thawArray# :: Array# a -> Int# -> Int# -> State# s -> (# State# s,MutableArray# s a #) +thawArray# a1 a2 a3 a4 = (GHC.Prim.thawArray#) a1 a2 a3 a4 +{-# NOINLINE casArray# #-} +casArray# :: MutableArray# s a -> Int# -> a -> a -> State# s -> (# State# s,Int#,a #) +casArray# a1 a2 a3 a4 a5 = (GHC.Prim.casArray#) a1 a2 a3 a4 a5 +{-# NOINLINE newByteArray# #-} +newByteArray# :: Int# -> State# s -> (# State# s,MutableByteArray# s #) +newByteArray# a1 a2 = (GHC.Prim.newByteArray#) a1 a2 +{-# NOINLINE newPinnedByteArray# #-} +newPinnedByteArray# :: Int# -> State# s -> (# State# s,MutableByteArray# s #) +newPinnedByteArray# a1 a2 = (GHC.Prim.newPinnedByteArray#) a1 a2 +{-# NOINLINE newAlignedPinnedByteArray# #-} +newAlignedPinnedByteArray# :: Int# -> Int# -> State# s -> (# State# s,MutableByteArray# s #) +newAlignedPinnedByteArray# a1 a2 a3 = (GHC.Prim.newAlignedPinnedByteArray#) a1 a2 a3 +{-# NOINLINE byteArrayContents# #-} +byteArrayContents# :: ByteArray# -> Addr# +byteArrayContents# a1 = (GHC.Prim.byteArrayContents#) a1 +{-# NOINLINE sameMutableByteArray# #-} +sameMutableByteArray# :: MutableByteArray# s -> MutableByteArray# s -> Int# +sameMutableByteArray# a1 a2 = (GHC.Prim.sameMutableByteArray#) a1 a2 +{-# NOINLINE unsafeFreezeByteArray# #-} +unsafeFreezeByteArray# :: MutableByteArray# s -> State# s -> (# State# s,ByteArray# #) +unsafeFreezeByteArray# a1 a2 = (GHC.Prim.unsafeFreezeByteArray#) a1 a2 +{-# NOINLINE sizeofByteArray# #-} +sizeofByteArray# :: ByteArray# -> Int# +sizeofByteArray# a1 = (GHC.Prim.sizeofByteArray#) a1 +{-# NOINLINE sizeofMutableByteArray# #-} +sizeofMutableByteArray# :: MutableByteArray# s -> Int# +sizeofMutableByteArray# a1 = (GHC.Prim.sizeofMutableByteArray#) a1 +{-# NOINLINE indexCharArray# #-} +indexCharArray# :: ByteArray# -> Int# -> Char# +indexCharArray# a1 a2 = (GHC.Prim.indexCharArray#) a1 a2 +{-# NOINLINE indexWideCharArray# #-} +indexWideCharArray# :: ByteArray# -> Int# -> Char# +indexWideCharArray# a1 a2 = (GHC.Prim.indexWideCharArray#) a1 a2 +{-# NOINLINE indexIntArray# #-} +indexIntArray# :: ByteArray# -> Int# -> Int# +indexIntArray# a1 a2 = (GHC.Prim.indexIntArray#) a1 a2 +{-# NOINLINE indexWordArray# #-} +indexWordArray# :: ByteArray# -> Int# -> Word# +indexWordArray# a1 a2 = (GHC.Prim.indexWordArray#) a1 a2 +{-# NOINLINE indexAddrArray# #-} +indexAddrArray# :: ByteArray# -> Int# -> Addr# +indexAddrArray# a1 a2 = (GHC.Prim.indexAddrArray#) a1 a2 +{-# NOINLINE indexFloatArray# #-} +indexFloatArray# :: ByteArray# -> Int# -> Float# +indexFloatArray# a1 a2 = (GHC.Prim.indexFloatArray#) a1 a2 +{-# NOINLINE indexDoubleArray# #-} +indexDoubleArray# :: ByteArray# -> Int# -> Double# +indexDoubleArray# a1 a2 = (GHC.Prim.indexDoubleArray#) a1 a2 +{-# NOINLINE indexStablePtrArray# #-} +indexStablePtrArray# :: ByteArray# -> Int# -> StablePtr# a +indexStablePtrArray# a1 a2 = (GHC.Prim.indexStablePtrArray#) a1 a2 +{-# NOINLINE indexInt8Array# #-} +indexInt8Array# :: ByteArray# -> Int# -> Int# +indexInt8Array# a1 a2 = (GHC.Prim.indexInt8Array#) a1 a2 +{-# NOINLINE indexInt16Array# #-} +indexInt16Array# :: ByteArray# -> Int# -> Int# +indexInt16Array# a1 a2 = (GHC.Prim.indexInt16Array#) a1 a2 +{-# NOINLINE indexInt32Array# #-} +indexInt32Array# :: ByteArray# -> Int# -> Int# +indexInt32Array# a1 a2 = (GHC.Prim.indexInt32Array#) a1 a2 +{-# NOINLINE indexInt64Array# #-} +indexInt64Array# :: ByteArray# -> Int# -> Int# +indexInt64Array# a1 a2 = (GHC.Prim.indexInt64Array#) a1 a2 +{-# NOINLINE indexWord8Array# #-} +indexWord8Array# :: ByteArray# -> Int# -> Word# +indexWord8Array# a1 a2 = (GHC.Prim.indexWord8Array#) a1 a2 +{-# NOINLINE indexWord16Array# #-} +indexWord16Array# :: ByteArray# -> Int# -> Word# +indexWord16Array# a1 a2 = (GHC.Prim.indexWord16Array#) a1 a2 +{-# NOINLINE indexWord32Array# #-} +indexWord32Array# :: ByteArray# -> Int# -> Word# +indexWord32Array# a1 a2 = (GHC.Prim.indexWord32Array#) a1 a2 +{-# NOINLINE indexWord64Array# #-} +indexWord64Array# :: ByteArray# -> Int# -> Word# +indexWord64Array# a1 a2 = (GHC.Prim.indexWord64Array#) a1 a2 +{-# NOINLINE readCharArray# #-} +readCharArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Char# #) +readCharArray# a1 a2 a3 = (GHC.Prim.readCharArray#) a1 a2 a3 +{-# NOINLINE readWideCharArray# #-} +readWideCharArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Char# #) +readWideCharArray# a1 a2 a3 = (GHC.Prim.readWideCharArray#) a1 a2 a3 +{-# NOINLINE readIntArray# #-} +readIntArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int# #) +readIntArray# a1 a2 a3 = (GHC.Prim.readIntArray#) a1 a2 a3 +{-# NOINLINE readWordArray# #-} +readWordArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word# #) +readWordArray# a1 a2 a3 = (GHC.Prim.readWordArray#) a1 a2 a3 +{-# NOINLINE readAddrArray# #-} +readAddrArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Addr# #) +readAddrArray# a1 a2 a3 = (GHC.Prim.readAddrArray#) a1 a2 a3 +{-# NOINLINE readFloatArray# #-} +readFloatArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Float# #) +readFloatArray# a1 a2 a3 = (GHC.Prim.readFloatArray#) a1 a2 a3 +{-# NOINLINE readDoubleArray# #-} +readDoubleArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Double# #) +readDoubleArray# a1 a2 a3 = (GHC.Prim.readDoubleArray#) a1 a2 a3 +{-# NOINLINE readStablePtrArray# #-} +readStablePtrArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,StablePtr# a #) +readStablePtrArray# a1 a2 a3 = (GHC.Prim.readStablePtrArray#) a1 a2 a3 +{-# NOINLINE readInt8Array# #-} +readInt8Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int# #) +readInt8Array# a1 a2 a3 = (GHC.Prim.readInt8Array#) a1 a2 a3 +{-# NOINLINE readInt16Array# #-} +readInt16Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int# #) +readInt16Array# a1 a2 a3 = (GHC.Prim.readInt16Array#) a1 a2 a3 +{-# NOINLINE readInt32Array# #-} +readInt32Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int# #) +readInt32Array# a1 a2 a3 = (GHC.Prim.readInt32Array#) a1 a2 a3 +{-# NOINLINE readInt64Array# #-} +readInt64Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int# #) +readInt64Array# a1 a2 a3 = (GHC.Prim.readInt64Array#) a1 a2 a3 +{-# NOINLINE readWord8Array# #-} +readWord8Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word# #) +readWord8Array# a1 a2 a3 = (GHC.Prim.readWord8Array#) a1 a2 a3 +{-# NOINLINE readWord16Array# #-} +readWord16Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word# #) +readWord16Array# a1 a2 a3 = (GHC.Prim.readWord16Array#) a1 a2 a3 +{-# NOINLINE readWord32Array# #-} +readWord32Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word# #) +readWord32Array# a1 a2 a3 = (GHC.Prim.readWord32Array#) a1 a2 a3 +{-# NOINLINE readWord64Array# #-} +readWord64Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word# #) +readWord64Array# a1 a2 a3 = (GHC.Prim.readWord64Array#) a1 a2 a3 +{-# NOINLINE writeCharArray# #-} +writeCharArray# :: MutableByteArray# s -> Int# -> Char# -> State# s -> State# s +writeCharArray# a1 a2 a3 a4 = (GHC.Prim.writeCharArray#) a1 a2 a3 a4 +{-# NOINLINE writeWideCharArray# #-} +writeWideCharArray# :: MutableByteArray# s -> Int# -> Char# -> State# s -> State# s +writeWideCharArray# a1 a2 a3 a4 = (GHC.Prim.writeWideCharArray#) a1 a2 a3 a4 +{-# NOINLINE writeIntArray# #-} +writeIntArray# :: MutableByteArray# s -> Int# -> Int# -> State# s -> State# s +writeIntArray# a1 a2 a3 a4 = (GHC.Prim.writeIntArray#) a1 a2 a3 a4 +{-# NOINLINE writeWordArray# #-} +writeWordArray# :: MutableByteArray# s -> Int# -> Word# -> State# s -> State# s +writeWordArray# a1 a2 a3 a4 = (GHC.Prim.writeWordArray#) a1 a2 a3 a4 +{-# NOINLINE writeAddrArray# #-} +writeAddrArray# :: MutableByteArray# s -> Int# -> Addr# -> State# s -> State# s +writeAddrArray# a1 a2 a3 a4 = (GHC.Prim.writeAddrArray#) a1 a2 a3 a4 +{-# NOINLINE writeFloatArray# #-} +writeFloatArray# :: MutableByteArray# s -> Int# -> Float# -> State# s -> State# s +writeFloatArray# a1 a2 a3 a4 = (GHC.Prim.writeFloatArray#) a1 a2 a3 a4 +{-# NOINLINE writeDoubleArray# #-} +writeDoubleArray# :: MutableByteArray# s -> Int# -> Double# -> State# s -> State# s +writeDoubleArray# a1 a2 a3 a4 = (GHC.Prim.writeDoubleArray#) a1 a2 a3 a4 +{-# NOINLINE writeStablePtrArray# #-} +writeStablePtrArray# :: MutableByteArray# s -> Int# -> StablePtr# a -> State# s -> State# s +writeStablePtrArray# a1 a2 a3 a4 = (GHC.Prim.writeStablePtrArray#) a1 a2 a3 a4 +{-# NOINLINE writeInt8Array# #-} +writeInt8Array# :: MutableByteArray# s -> Int# -> Int# -> State# s -> State# s +writeInt8Array# a1 a2 a3 a4 = (GHC.Prim.writeInt8Array#) a1 a2 a3 a4 +{-# NOINLINE writeInt16Array# #-} +writeInt16Array# :: MutableByteArray# s -> Int# -> Int# -> State# s -> State# s +writeInt16Array# a1 a2 a3 a4 = (GHC.Prim.writeInt16Array#) a1 a2 a3 a4 +{-# NOINLINE writeInt32Array# #-} +writeInt32Array# :: MutableByteArray# s -> Int# -> Int# -> State# s -> State# s +writeInt32Array# a1 a2 a3 a4 = (GHC.Prim.writeInt32Array#) a1 a2 a3 a4 +{-# NOINLINE writeInt64Array# #-} +writeInt64Array# :: MutableByteArray# s -> Int# -> Int# -> State# s -> State# s +writeInt64Array# a1 a2 a3 a4 = (GHC.Prim.writeInt64Array#) a1 a2 a3 a4 +{-# NOINLINE writeWord8Array# #-} +writeWord8Array# :: MutableByteArray# s -> Int# -> Word# -> State# s -> State# s +writeWord8Array# a1 a2 a3 a4 = (GHC.Prim.writeWord8Array#) a1 a2 a3 a4 +{-# NOINLINE writeWord16Array# #-} +writeWord16Array# :: MutableByteArray# s -> Int# -> Word# -> State# s -> State# s +writeWord16Array# a1 a2 a3 a4 = (GHC.Prim.writeWord16Array#) a1 a2 a3 a4 +{-# NOINLINE writeWord32Array# #-} +writeWord32Array# :: MutableByteArray# s -> Int# -> Word# -> State# s -> State# s +writeWord32Array# a1 a2 a3 a4 = (GHC.Prim.writeWord32Array#) a1 a2 a3 a4 +{-# NOINLINE writeWord64Array# #-} +writeWord64Array# :: MutableByteArray# s -> Int# -> Word# -> State# s -> State# s +writeWord64Array# a1 a2 a3 a4 = (GHC.Prim.writeWord64Array#) a1 a2 a3 a4 +{-# NOINLINE copyByteArray# #-} +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 +{-# NOINLINE copyMutableByteArray# #-} +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 +{-# NOINLINE copyByteArrayToAddr# #-} +copyByteArrayToAddr# :: ByteArray# -> Int# -> Addr# -> Int# -> State# s -> State# s +copyByteArrayToAddr# a1 a2 a3 a4 a5 = (GHC.Prim.copyByteArrayToAddr#) a1 a2 a3 a4 a5 +{-# NOINLINE copyMutableByteArrayToAddr# #-} +copyMutableByteArrayToAddr# :: MutableByteArray# s -> Int# -> Addr# -> Int# -> State# s -> State# s +copyMutableByteArrayToAddr# a1 a2 a3 a4 a5 = (GHC.Prim.copyMutableByteArrayToAddr#) a1 a2 a3 a4 a5 +{-# NOINLINE copyAddrToByteArray# #-} +copyAddrToByteArray# :: Addr# -> MutableByteArray# s -> Int# -> Int# -> State# s -> State# s +copyAddrToByteArray# a1 a2 a3 a4 a5 = (GHC.Prim.copyAddrToByteArray#) a1 a2 a3 a4 a5 +{-# NOINLINE setByteArray# #-} +setByteArray# :: MutableByteArray# s -> Int# -> Int# -> Int# -> State# s -> State# s +setByteArray# a1 a2 a3 a4 a5 = (GHC.Prim.setByteArray#) a1 a2 a3 a4 a5 +{-# NOINLINE casIntArray# #-} +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 +{-# NOINLINE fetchAddIntArray# #-} +fetchAddIntArray# :: MutableByteArray# s -> Int# -> Int# -> State# s -> (# State# s,Int# #) +fetchAddIntArray# a1 a2 a3 a4 = (GHC.Prim.fetchAddIntArray#) a1 a2 a3 a4 +{-# NOINLINE newArrayArray# #-} +newArrayArray# :: Int# -> State# s -> (# State# s,MutableArrayArray# s #) +newArrayArray# a1 a2 = (GHC.Prim.newArrayArray#) a1 a2 +{-# NOINLINE sameMutableArrayArray# #-} +sameMutableArrayArray# :: MutableArrayArray# s -> MutableArrayArray# s -> Int# +sameMutableArrayArray# a1 a2 = (GHC.Prim.sameMutableArrayArray#) a1 a2 +{-# NOINLINE unsafeFreezeArrayArray# #-} +unsafeFreezeArrayArray# :: MutableArrayArray# s -> State# s -> (# State# s,ArrayArray# #) +unsafeFreezeArrayArray# a1 a2 = (GHC.Prim.unsafeFreezeArrayArray#) a1 a2 +{-# NOINLINE sizeofArrayArray# #-} +sizeofArrayArray# :: ArrayArray# -> Int# +sizeofArrayArray# a1 = (GHC.Prim.sizeofArrayArray#) a1 +{-# NOINLINE sizeofMutableArrayArray# #-} +sizeofMutableArrayArray# :: MutableArrayArray# s -> Int# +sizeofMutableArrayArray# a1 = (GHC.Prim.sizeofMutableArrayArray#) a1 +{-# NOINLINE indexByteArrayArray# #-} +indexByteArrayArray# :: ArrayArray# -> Int# -> ByteArray# +indexByteArrayArray# a1 a2 = (GHC.Prim.indexByteArrayArray#) a1 a2 +{-# NOINLINE indexArrayArrayArray# #-} +indexArrayArrayArray# :: ArrayArray# -> Int# -> ArrayArray# +indexArrayArrayArray# a1 a2 = (GHC.Prim.indexArrayArrayArray#) a1 a2 +{-# NOINLINE readByteArrayArray# #-} +readByteArrayArray# :: MutableArrayArray# s -> Int# -> State# s -> (# State# s,ByteArray# #) +readByteArrayArray# a1 a2 a3 = (GHC.Prim.readByteArrayArray#) a1 a2 a3 +{-# NOINLINE readMutableByteArrayArray# #-} +readMutableByteArrayArray# :: MutableArrayArray# s -> Int# -> State# s -> (# State# s,MutableByteArray# s #) +readMutableByteArrayArray# a1 a2 a3 = (GHC.Prim.readMutableByteArrayArray#) a1 a2 a3 +{-# NOINLINE readArrayArrayArray# #-} +readArrayArrayArray# :: MutableArrayArray# s -> Int# -> State# s -> (# State# s,ArrayArray# #) +readArrayArrayArray# a1 a2 a3 = (GHC.Prim.readArrayArrayArray#) a1 a2 a3 +{-# NOINLINE readMutableArrayArrayArray# #-} +readMutableArrayArrayArray# :: MutableArrayArray# s -> Int# -> State# s -> (# State# s,MutableArrayArray# s #) +readMutableArrayArrayArray# a1 a2 a3 = (GHC.Prim.readMutableArrayArrayArray#) a1 a2 a3 +{-# NOINLINE writeByteArrayArray# #-} +writeByteArrayArray# :: MutableArrayArray# s -> Int# -> ByteArray# -> State# s -> State# s +writeByteArrayArray# a1 a2 a3 a4 = (GHC.Prim.writeByteArrayArray#) a1 a2 a3 a4 +{-# NOINLINE writeMutableByteArrayArray# #-} +writeMutableByteArrayArray# :: MutableArrayArray# s -> Int# -> MutableByteArray# s -> State# s -> State# s +writeMutableByteArrayArray# a1 a2 a3 a4 = (GHC.Prim.writeMutableByteArrayArray#) a1 a2 a3 a4 +{-# NOINLINE writeArrayArrayArray# #-} +writeArrayArrayArray# :: MutableArrayArray# s -> Int# -> ArrayArray# -> State# s -> State# s +writeArrayArrayArray# a1 a2 a3 a4 = (GHC.Prim.writeArrayArrayArray#) a1 a2 a3 a4 +{-# NOINLINE writeMutableArrayArrayArray# #-} +writeMutableArrayArrayArray# :: MutableArrayArray# s -> Int# -> MutableArrayArray# s -> State# s -> State# s +writeMutableArrayArrayArray# a1 a2 a3 a4 = (GHC.Prim.writeMutableArrayArrayArray#) a1 a2 a3 a4 +{-# NOINLINE copyArrayArray# #-} +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 +{-# NOINLINE copyMutableArrayArray# #-} +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 +{-# NOINLINE plusAddr# #-} +plusAddr# :: Addr# -> Int# -> Addr# +plusAddr# a1 a2 = (GHC.Prim.plusAddr#) a1 a2 +{-# NOINLINE minusAddr# #-} +minusAddr# :: Addr# -> Addr# -> Int# +minusAddr# a1 a2 = (GHC.Prim.minusAddr#) a1 a2 +{-# NOINLINE remAddr# #-} +remAddr# :: Addr# -> Int# -> Int# +remAddr# a1 a2 = (GHC.Prim.remAddr#) a1 a2 +{-# NOINLINE addr2Int# #-} +addr2Int# :: Addr# -> Int# +addr2Int# a1 = (GHC.Prim.addr2Int#) a1 +{-# NOINLINE int2Addr# #-} +int2Addr# :: Int# -> Addr# +int2Addr# a1 = (GHC.Prim.int2Addr#) a1 +{-# NOINLINE gtAddr# #-} +gtAddr# :: Addr# -> Addr# -> Int# +gtAddr# a1 a2 = (GHC.Prim.gtAddr#) a1 a2 +{-# NOINLINE geAddr# #-} +geAddr# :: Addr# -> Addr# -> Int# +geAddr# a1 a2 = (GHC.Prim.geAddr#) a1 a2 +{-# NOINLINE eqAddr# #-} +eqAddr# :: Addr# -> Addr# -> Int# +eqAddr# a1 a2 = (GHC.Prim.eqAddr#) a1 a2 +{-# NOINLINE neAddr# #-} +neAddr# :: Addr# -> Addr# -> Int# +neAddr# a1 a2 = (GHC.Prim.neAddr#) a1 a2 +{-# NOINLINE ltAddr# #-} +ltAddr# :: Addr# -> Addr# -> Int# +ltAddr# a1 a2 = (GHC.Prim.ltAddr#) a1 a2 +{-# NOINLINE leAddr# #-} +leAddr# :: Addr# -> Addr# -> Int# +leAddr# a1 a2 = (GHC.Prim.leAddr#) a1 a2 +{-# NOINLINE indexCharOffAddr# #-} +indexCharOffAddr# :: Addr# -> Int# -> Char# +indexCharOffAddr# a1 a2 = (GHC.Prim.indexCharOffAddr#) a1 a2 +{-# NOINLINE indexWideCharOffAddr# #-} +indexWideCharOffAddr# :: Addr# -> Int# -> Char# +indexWideCharOffAddr# a1 a2 = (GHC.Prim.indexWideCharOffAddr#) a1 a2 +{-# NOINLINE indexIntOffAddr# #-} +indexIntOffAddr# :: Addr# -> Int# -> Int# +indexIntOffAddr# a1 a2 = (GHC.Prim.indexIntOffAddr#) a1 a2 +{-# NOINLINE indexWordOffAddr# #-} +indexWordOffAddr# :: Addr# -> Int# -> Word# +indexWordOffAddr# a1 a2 = (GHC.Prim.indexWordOffAddr#) a1 a2 +{-# NOINLINE indexAddrOffAddr# #-} +indexAddrOffAddr# :: Addr# -> Int# -> Addr# +indexAddrOffAddr# a1 a2 = (GHC.Prim.indexAddrOffAddr#) a1 a2 +{-# NOINLINE indexFloatOffAddr# #-} +indexFloatOffAddr# :: Addr# -> Int# -> Float# +indexFloatOffAddr# a1 a2 = (GHC.Prim.indexFloatOffAddr#) a1 a2 +{-# NOINLINE indexDoubleOffAddr# #-} +indexDoubleOffAddr# :: Addr# -> Int# -> Double# +indexDoubleOffAddr# a1 a2 = (GHC.Prim.indexDoubleOffAddr#) a1 a2 +{-# NOINLINE indexStablePtrOffAddr# #-} +indexStablePtrOffAddr# :: Addr# -> Int# -> StablePtr# a +indexStablePtrOffAddr# a1 a2 = (GHC.Prim.indexStablePtrOffAddr#) a1 a2 +{-# NOINLINE indexInt8OffAddr# #-} +indexInt8OffAddr# :: Addr# -> Int# -> Int# +indexInt8OffAddr# a1 a2 = (GHC.Prim.indexInt8OffAddr#) a1 a2 +{-# NOINLINE indexInt16OffAddr# #-} +indexInt16OffAddr# :: Addr# -> Int# -> Int# +indexInt16OffAddr# a1 a2 = (GHC.Prim.indexInt16OffAddr#) a1 a2 +{-# NOINLINE indexInt32OffAddr# #-} +indexInt32OffAddr# :: Addr# -> Int# -> Int# +indexInt32OffAddr# a1 a2 = (GHC.Prim.indexInt32OffAddr#) a1 a2 +{-# NOINLINE indexInt64OffAddr# #-} +indexInt64OffAddr# :: Addr# -> Int# -> Int# +indexInt64OffAddr# a1 a2 = (GHC.Prim.indexInt64OffAddr#) a1 a2 +{-# NOINLINE indexWord8OffAddr# #-} +indexWord8OffAddr# :: Addr# -> Int# -> Word# +indexWord8OffAddr# a1 a2 = (GHC.Prim.indexWord8OffAddr#) a1 a2 +{-# NOINLINE indexWord16OffAddr# #-} +indexWord16OffAddr# :: Addr# -> Int# -> Word# +indexWord16OffAddr# a1 a2 = (GHC.Prim.indexWord16OffAddr#) a1 a2 +{-# NOINLINE indexWord32OffAddr# #-} +indexWord32OffAddr# :: Addr# -> Int# -> Word# +indexWord32OffAddr# a1 a2 = (GHC.Prim.indexWord32OffAddr#) a1 a2 +{-# NOINLINE indexWord64OffAddr# #-} +indexWord64OffAddr# :: Addr# -> Int# -> Word# +indexWord64OffAddr# a1 a2 = (GHC.Prim.indexWord64OffAddr#) a1 a2 +{-# NOINLINE readCharOffAddr# #-} +readCharOffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Char# #) +readCharOffAddr# a1 a2 a3 = (GHC.Prim.readCharOffAddr#) a1 a2 a3 +{-# NOINLINE readWideCharOffAddr# #-} +readWideCharOffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Char# #) +readWideCharOffAddr# a1 a2 a3 = (GHC.Prim.readWideCharOffAddr#) a1 a2 a3 +{-# NOINLINE readIntOffAddr# #-} +readIntOffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int# #) +readIntOffAddr# a1 a2 a3 = (GHC.Prim.readIntOffAddr#) a1 a2 a3 +{-# NOINLINE readWordOffAddr# #-} +readWordOffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word# #) +readWordOffAddr# a1 a2 a3 = (GHC.Prim.readWordOffAddr#) a1 a2 a3 +{-# NOINLINE readAddrOffAddr# #-} +readAddrOffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Addr# #) +readAddrOffAddr# a1 a2 a3 = (GHC.Prim.readAddrOffAddr#) a1 a2 a3 +{-# NOINLINE readFloatOffAddr# #-} +readFloatOffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Float# #) +readFloatOffAddr# a1 a2 a3 = (GHC.Prim.readFloatOffAddr#) a1 a2 a3 +{-# NOINLINE readDoubleOffAddr# #-} +readDoubleOffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Double# #) +readDoubleOffAddr# a1 a2 a3 = (GHC.Prim.readDoubleOffAddr#) a1 a2 a3 +{-# NOINLINE readStablePtrOffAddr# #-} +readStablePtrOffAddr# :: Addr# -> Int# -> State# s -> (# State# s,StablePtr# a #) +readStablePtrOffAddr# a1 a2 a3 = (GHC.Prim.readStablePtrOffAddr#) a1 a2 a3 +{-# NOINLINE readInt8OffAddr# #-} +readInt8OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int# #) +readInt8OffAddr# a1 a2 a3 = (GHC.Prim.readInt8OffAddr#) a1 a2 a3 +{-# NOINLINE readInt16OffAddr# #-} +readInt16OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int# #) +readInt16OffAddr# a1 a2 a3 = (GHC.Prim.readInt16OffAddr#) a1 a2 a3 +{-# NOINLINE readInt32OffAddr# #-} +readInt32OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int# #) +readInt32OffAddr# a1 a2 a3 = (GHC.Prim.readInt32OffAddr#) a1 a2 a3 +{-# NOINLINE readInt64OffAddr# #-} +readInt64OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int# #) +readInt64OffAddr# a1 a2 a3 = (GHC.Prim.readInt64OffAddr#) a1 a2 a3 +{-# NOINLINE readWord8OffAddr# #-} +readWord8OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word# #) +readWord8OffAddr# a1 a2 a3 = (GHC.Prim.readWord8OffAddr#) a1 a2 a3 +{-# NOINLINE readWord16OffAddr# #-} +readWord16OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word# #) +readWord16OffAddr# a1 a2 a3 = (GHC.Prim.readWord16OffAddr#) a1 a2 a3 +{-# NOINLINE readWord32OffAddr# #-} +readWord32OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word# #) +readWord32OffAddr# a1 a2 a3 = (GHC.Prim.readWord32OffAddr#) a1 a2 a3 +{-# NOINLINE readWord64OffAddr# #-} +readWord64OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word# #) +readWord64OffAddr# a1 a2 a3 = (GHC.Prim.readWord64OffAddr#) a1 a2 a3 +{-# NOINLINE writeCharOffAddr# #-} +writeCharOffAddr# :: Addr# -> Int# -> Char# -> State# s -> State# s +writeCharOffAddr# a1 a2 a3 a4 = (GHC.Prim.writeCharOffAddr#) a1 a2 a3 a4 +{-# NOINLINE writeWideCharOffAddr# #-} +writeWideCharOffAddr# :: Addr# -> Int# -> Char# -> State# s -> State# s +writeWideCharOffAddr# a1 a2 a3 a4 = (GHC.Prim.writeWideCharOffAddr#) a1 a2 a3 a4 +{-# NOINLINE writeIntOffAddr# #-} +writeIntOffAddr# :: Addr# -> Int# -> Int# -> State# s -> State# s +writeIntOffAddr# a1 a2 a3 a4 = (GHC.Prim.writeIntOffAddr#) a1 a2 a3 a4 +{-# NOINLINE writeWordOffAddr# #-} +writeWordOffAddr# :: Addr# -> Int# -> Word# -> State# s -> State# s +writeWordOffAddr# a1 a2 a3 a4 = (GHC.Prim.writeWordOffAddr#) a1 a2 a3 a4 +{-# NOINLINE writeAddrOffAddr# #-} +writeAddrOffAddr# :: Addr# -> Int# -> Addr# -> State# s -> State# s +writeAddrOffAddr# a1 a2 a3 a4 = (GHC.Prim.writeAddrOffAddr#) a1 a2 a3 a4 +{-# NOINLINE writeFloatOffAddr# #-} +writeFloatOffAddr# :: Addr# -> Int# -> Float# -> State# s -> State# s +writeFloatOffAddr# a1 a2 a3 a4 = (GHC.Prim.writeFloatOffAddr#) a1 a2 a3 a4 +{-# NOINLINE writeDoubleOffAddr# #-} +writeDoubleOffAddr# :: Addr# -> Int# -> Double# -> State# s -> State# s +writeDoubleOffAddr# a1 a2 a3 a4 = (GHC.Prim.writeDoubleOffAddr#) a1 a2 a3 a4 +{-# NOINLINE writeStablePtrOffAddr# #-} +writeStablePtrOffAddr# :: Addr# -> Int# -> StablePtr# a -> State# s -> State# s +writeStablePtrOffAddr# a1 a2 a3 a4 = (GHC.Prim.writeStablePtrOffAddr#) a1 a2 a3 a4 +{-# NOINLINE writeInt8OffAddr# #-} +writeInt8OffAddr# :: Addr# -> Int# -> Int# -> State# s -> State# s +writeInt8OffAddr# a1 a2 a3 a4 = (GHC.Prim.writeInt8OffAddr#) a1 a2 a3 a4 +{-# NOINLINE writeInt16OffAddr# #-} +writeInt16OffAddr# :: Addr# -> Int# -> Int# -> State# s -> State# s +writeInt16OffAddr# a1 a2 a3 a4 = (GHC.Prim.writeInt16OffAddr#) a1 a2 a3 a4 +{-# NOINLINE writeInt32OffAddr# #-} +writeInt32OffAddr# :: Addr# -> Int# -> Int# -> State# s -> State# s +writeInt32OffAddr# a1 a2 a3 a4 = (GHC.Prim.writeInt32OffAddr#) a1 a2 a3 a4 +{-# NOINLINE writeInt64OffAddr# #-} +writeInt64OffAddr# :: Addr# -> Int# -> Int# -> State# s -> State# s +writeInt64OffAddr# a1 a2 a3 a4 = (GHC.Prim.writeInt64OffAddr#) a1 a2 a3 a4 +{-# NOINLINE writeWord8OffAddr# #-} +writeWord8OffAddr# :: Addr# -> Int# -> Word# -> State# s -> State# s +writeWord8OffAddr# a1 a2 a3 a4 = (GHC.Prim.writeWord8OffAddr#) a1 a2 a3 a4 +{-# NOINLINE writeWord16OffAddr# #-} +writeWord16OffAddr# :: Addr# -> Int# -> Word# -> State# s -> State# s +writeWord16OffAddr# a1 a2 a3 a4 = (GHC.Prim.writeWord16OffAddr#) a1 a2 a3 a4 +{-# NOINLINE writeWord32OffAddr# #-} +writeWord32OffAddr# :: Addr# -> Int# -> Word# -> State# s -> State# s +writeWord32OffAddr# a1 a2 a3 a4 = (GHC.Prim.writeWord32OffAddr#) a1 a2 a3 a4 +{-# NOINLINE writeWord64OffAddr# #-} +writeWord64OffAddr# :: Addr# -> Int# -> Word# -> State# s -> State# s +writeWord64OffAddr# a1 a2 a3 a4 = (GHC.Prim.writeWord64OffAddr#) a1 a2 a3 a4 +{-# NOINLINE newMutVar# #-} +newMutVar# :: a -> State# s -> (# State# s,MutVar# s a #) +newMutVar# a1 a2 = (GHC.Prim.newMutVar#) a1 a2 +{-# NOINLINE readMutVar# #-} +readMutVar# :: MutVar# s a -> State# s -> (# State# s,a #) +readMutVar# a1 a2 = (GHC.Prim.readMutVar#) a1 a2 +{-# NOINLINE writeMutVar# #-} +writeMutVar# :: MutVar# s a -> a -> State# s -> State# s +writeMutVar# a1 a2 a3 = (GHC.Prim.writeMutVar#) a1 a2 a3 +{-# NOINLINE sameMutVar# #-} +sameMutVar# :: MutVar# s a -> MutVar# s a -> Int# +sameMutVar# a1 a2 = (GHC.Prim.sameMutVar#) a1 a2 +{-# NOINLINE atomicModifyMutVar# #-} +atomicModifyMutVar# :: MutVar# s a -> (a -> b) -> State# s -> (# State# s,c #) +atomicModifyMutVar# a1 a2 a3 = (GHC.Prim.atomicModifyMutVar#) a1 a2 a3 +{-# NOINLINE casMutVar# #-} +casMutVar# :: MutVar# s a -> a -> a -> State# s -> (# State# s,Int#,a #) +casMutVar# a1 a2 a3 a4 = (GHC.Prim.casMutVar#) a1 a2 a3 a4 +{-# NOINLINE catch# #-} +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 +{-# NOINLINE raise# #-} +raise# :: a -> b +raise# a1 = (GHC.Prim.raise#) a1 +{-# NOINLINE raiseIO# #-} +raiseIO# :: a -> State# (RealWorld) -> (# State# (RealWorld),b #) +raiseIO# a1 a2 = (GHC.Prim.raiseIO#) a1 a2 +{-# NOINLINE maskAsyncExceptions# #-} +maskAsyncExceptions# :: (State# (RealWorld) -> (# State# (RealWorld),a #)) -> State# (RealWorld) -> (# State# (RealWorld),a #) +maskAsyncExceptions# a1 a2 = (GHC.Prim.maskAsyncExceptions#) a1 a2 +{-# NOINLINE maskUninterruptible# #-} +maskUninterruptible# :: (State# (RealWorld) -> (# State# (RealWorld),a #)) -> State# (RealWorld) -> (# State# (RealWorld),a #) +maskUninterruptible# a1 a2 = (GHC.Prim.maskUninterruptible#) a1 a2 +{-# NOINLINE unmaskAsyncExceptions# #-} +unmaskAsyncExceptions# :: (State# (RealWorld) -> (# State# (RealWorld),a #)) -> State# (RealWorld) -> (# State# (RealWorld),a #) +unmaskAsyncExceptions# a1 a2 = (GHC.Prim.unmaskAsyncExceptions#) a1 a2 +{-# NOINLINE getMaskingState# #-} +getMaskingState# :: State# (RealWorld) -> (# State# (RealWorld),Int# #) +getMaskingState# a1 = (GHC.Prim.getMaskingState#) a1 +{-# NOINLINE atomically# #-} +atomically# :: (State# (RealWorld) -> (# State# (RealWorld),a #)) -> State# (RealWorld) -> (# State# (RealWorld),a #) +atomically# a1 a2 = (GHC.Prim.atomically#) a1 a2 +{-# NOINLINE retry# #-} +retry# :: State# (RealWorld) -> (# State# (RealWorld),a #) +retry# a1 = (GHC.Prim.retry#) a1 +{-# NOINLINE catchRetry# #-} +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 +{-# NOINLINE catchSTM# #-} +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 +{-# NOINLINE check# #-} +check# :: (State# (RealWorld) -> (# State# (RealWorld),a #)) -> State# (RealWorld) -> (# State# (RealWorld),() #) +check# a1 a2 = (GHC.Prim.check#) a1 a2 +{-# NOINLINE newTVar# #-} +newTVar# :: a -> State# s -> (# State# s,TVar# s a #) +newTVar# a1 a2 = (GHC.Prim.newTVar#) a1 a2 +{-# NOINLINE readTVar# #-} +readTVar# :: TVar# s a -> State# s -> (# State# s,a #) +readTVar# a1 a2 = (GHC.Prim.readTVar#) a1 a2 +{-# NOINLINE readTVarIO# #-} +readTVarIO# :: TVar# s a -> State# s -> (# State# s,a #) +readTVarIO# a1 a2 = (GHC.Prim.readTVarIO#) a1 a2 +{-# NOINLINE writeTVar# #-} +writeTVar# :: TVar# s a -> a -> State# s -> State# s +writeTVar# a1 a2 a3 = (GHC.Prim.writeTVar#) a1 a2 a3 +{-# NOINLINE sameTVar# #-} +sameTVar# :: TVar# s a -> TVar# s a -> Int# +sameTVar# a1 a2 = (GHC.Prim.sameTVar#) a1 a2 +{-# NOINLINE newMVar# #-} +newMVar# :: State# s -> (# State# s,MVar# s a #) +newMVar# a1 = (GHC.Prim.newMVar#) a1 +{-# NOINLINE takeMVar# #-} +takeMVar# :: MVar# s a -> State# s -> (# State# s,a #) +takeMVar# a1 a2 = (GHC.Prim.takeMVar#) a1 a2 +{-# NOINLINE tryTakeMVar# #-} +tryTakeMVar# :: MVar# s a -> State# s -> (# State# s,Int#,a #) +tryTakeMVar# a1 a2 = (GHC.Prim.tryTakeMVar#) a1 a2 +{-# NOINLINE putMVar# #-} +putMVar# :: MVar# s a -> a -> State# s -> State# s +putMVar# a1 a2 a3 = (GHC.Prim.putMVar#) a1 a2 a3 +{-# NOINLINE tryPutMVar# #-} +tryPutMVar# :: MVar# s a -> a -> State# s -> (# State# s,Int# #) +tryPutMVar# a1 a2 a3 = (GHC.Prim.tryPutMVar#) a1 a2 a3 +{-# NOINLINE readMVar# #-} +readMVar# :: MVar# s a -> State# s -> (# State# s,a #) +readMVar# a1 a2 = (GHC.Prim.readMVar#) a1 a2 +{-# NOINLINE tryReadMVar# #-} +tryReadMVar# :: MVar# s a -> State# s -> (# State# s,Int#,a #) +tryReadMVar# a1 a2 = (GHC.Prim.tryReadMVar#) a1 a2 +{-# NOINLINE sameMVar# #-} +sameMVar# :: MVar# s a -> MVar# s a -> Int# +sameMVar# a1 a2 = (GHC.Prim.sameMVar#) a1 a2 +{-# NOINLINE isEmptyMVar# #-} +isEmptyMVar# :: MVar# s a -> State# s -> (# State# s,Int# #) +isEmptyMVar# a1 a2 = (GHC.Prim.isEmptyMVar#) a1 a2 +{-# NOINLINE delay# #-} +delay# :: Int# -> State# s -> State# s +delay# a1 a2 = (GHC.Prim.delay#) a1 a2 +{-# NOINLINE waitRead# #-} +waitRead# :: Int# -> State# s -> State# s +waitRead# a1 a2 = (GHC.Prim.waitRead#) a1 a2 +{-# NOINLINE waitWrite# #-} +waitWrite# :: Int# -> State# s -> State# s +waitWrite# a1 a2 = (GHC.Prim.waitWrite#) a1 a2 +{-# NOINLINE fork# #-} +fork# :: a -> State# (RealWorld) -> (# State# (RealWorld),ThreadId# #) +fork# a1 a2 = (GHC.Prim.fork#) a1 a2 +{-# NOINLINE forkOn# #-} +forkOn# :: Int# -> a -> State# (RealWorld) -> (# State# (RealWorld),ThreadId# #) +forkOn# a1 a2 a3 = (GHC.Prim.forkOn#) a1 a2 a3 +{-# NOINLINE killThread# #-} +killThread# :: ThreadId# -> a -> State# (RealWorld) -> State# (RealWorld) +killThread# a1 a2 a3 = (GHC.Prim.killThread#) a1 a2 a3 +{-# NOINLINE yield# #-} +yield# :: State# (RealWorld) -> State# (RealWorld) +yield# a1 = (GHC.Prim.yield#) a1 +{-# NOINLINE myThreadId# #-} +myThreadId# :: State# (RealWorld) -> (# State# (RealWorld),ThreadId# #) +myThreadId# a1 = (GHC.Prim.myThreadId#) a1 +{-# NOINLINE labelThread# #-} +labelThread# :: ThreadId# -> Addr# -> State# (RealWorld) -> State# (RealWorld) +labelThread# a1 a2 a3 = (GHC.Prim.labelThread#) a1 a2 a3 +{-# NOINLINE isCurrentThreadBound# #-} +isCurrentThreadBound# :: State# (RealWorld) -> (# State# (RealWorld),Int# #) +isCurrentThreadBound# a1 = (GHC.Prim.isCurrentThreadBound#) a1 +{-# NOINLINE noDuplicate# #-} +noDuplicate# :: State# (RealWorld) -> State# (RealWorld) +noDuplicate# a1 = (GHC.Prim.noDuplicate#) a1 +{-# NOINLINE threadStatus# #-} +threadStatus# :: ThreadId# -> State# (RealWorld) -> (# State# (RealWorld),Int#,Int#,Int# #) +threadStatus# a1 a2 = (GHC.Prim.threadStatus#) a1 a2 +{-# NOINLINE mkWeak# #-} +mkWeak# :: o -> b -> c -> State# (RealWorld) -> (# State# (RealWorld),Weak# b #) +mkWeak# a1 a2 a3 a4 = (GHC.Prim.mkWeak#) a1 a2 a3 a4 +{-# NOINLINE mkWeakNoFinalizer# #-} +mkWeakNoFinalizer# :: o -> b -> State# (RealWorld) -> (# State# (RealWorld),Weak# b #) +mkWeakNoFinalizer# a1 a2 a3 = (GHC.Prim.mkWeakNoFinalizer#) a1 a2 a3 +{-# NOINLINE addCFinalizerToWeak# #-} +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 +{-# NOINLINE deRefWeak# #-} +deRefWeak# :: Weak# a -> State# (RealWorld) -> (# State# (RealWorld),Int#,a #) +deRefWeak# a1 a2 = (GHC.Prim.deRefWeak#) a1 a2 +{-# NOINLINE finalizeWeak# #-} +finalizeWeak# :: Weak# a -> State# (RealWorld) -> (# State# (RealWorld),Int#,State# (RealWorld) -> (# State# (RealWorld),() #) #) +finalizeWeak# a1 a2 = (GHC.Prim.finalizeWeak#) a1 a2 +{-# NOINLINE touch# #-} +touch# :: o -> State# (RealWorld) -> State# (RealWorld) +touch# a1 a2 = (GHC.Prim.touch#) a1 a2 +{-# NOINLINE makeStablePtr# #-} +makeStablePtr# :: a -> State# (RealWorld) -> (# State# (RealWorld),StablePtr# a #) +makeStablePtr# a1 a2 = (GHC.Prim.makeStablePtr#) a1 a2 +{-# NOINLINE deRefStablePtr# #-} +deRefStablePtr# :: StablePtr# a -> State# (RealWorld) -> (# State# (RealWorld),a #) +deRefStablePtr# a1 a2 = (GHC.Prim.deRefStablePtr#) a1 a2 +{-# NOINLINE eqStablePtr# #-} +eqStablePtr# :: StablePtr# a -> StablePtr# a -> Int# +eqStablePtr# a1 a2 = (GHC.Prim.eqStablePtr#) a1 a2 +{-# NOINLINE makeStableName# #-} +makeStableName# :: a -> State# (RealWorld) -> (# State# (RealWorld),StableName# a #) +makeStableName# a1 a2 = (GHC.Prim.makeStableName#) a1 a2 +{-# NOINLINE eqStableName# #-} +eqStableName# :: StableName# a -> StableName# b -> Int# +eqStableName# a1 a2 = (GHC.Prim.eqStableName#) a1 a2 +{-# NOINLINE stableNameToInt# #-} +stableNameToInt# :: StableName# a -> Int# +stableNameToInt# a1 = (GHC.Prim.stableNameToInt#) a1 +{-# NOINLINE reallyUnsafePtrEquality# #-} +reallyUnsafePtrEquality# :: a -> a -> Int# +reallyUnsafePtrEquality# a1 a2 = (GHC.Prim.reallyUnsafePtrEquality#) a1 a2 +{-# NOINLINE spark# #-} +spark# :: a -> State# s -> (# State# s,a #) +spark# a1 a2 = (GHC.Prim.spark#) a1 a2 +{-# NOINLINE getSpark# #-} +getSpark# :: State# s -> (# State# s,Int#,a #) +getSpark# a1 = (GHC.Prim.getSpark#) a1 +{-# NOINLINE numSparks# #-} +numSparks# :: State# s -> (# State# s,Int# #) +numSparks# a1 = (GHC.Prim.numSparks#) a1 +{-# NOINLINE dataToTag# #-} +dataToTag# :: a -> Int# +dataToTag# a1 = (GHC.Prim.dataToTag#) a1 +{-# NOINLINE addrToAny# #-} +addrToAny# :: Addr# -> (# a #) +addrToAny# a1 = (GHC.Prim.addrToAny#) a1 +{-# NOINLINE mkApUpd0# #-} +mkApUpd0# :: BCO# -> (# a #) +mkApUpd0# a1 = (GHC.Prim.mkApUpd0#) a1 +{-# NOINLINE newBCO# #-} +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 +{-# NOINLINE unpackClosure# #-} +unpackClosure# :: a -> (# Addr#,Array# b,ByteArray# #) +unpackClosure# a1 = (GHC.Prim.unpackClosure#) a1 +{-# NOINLINE getApStackVal# #-} +getApStackVal# :: a -> Int# -> (# Int#,b #) +getApStackVal# a1 a2 = (GHC.Prim.getApStackVal#) a1 a2 +{-# NOINLINE getCCSOf# #-} +getCCSOf# :: a -> State# s -> (# State# s,Addr# #) +getCCSOf# a1 a2 = (GHC.Prim.getCCSOf#) a1 a2 +{-# NOINLINE getCurrentCCS# #-} +getCurrentCCS# :: a -> State# s -> (# State# s,Addr# #) +getCurrentCCS# a1 a2 = (GHC.Prim.getCurrentCCS#) a1 a2 +{-# NOINLINE traceEvent# #-} +traceEvent# :: Addr# -> State# s -> State# s +traceEvent# a1 a2 = (GHC.Prim.traceEvent#) a1 a2 +{-# NOINLINE traceMarker# #-} +traceMarker# :: Addr# -> State# s -> State# s +traceMarker# a1 a2 = (GHC.Prim.traceMarker#) a1 a2 +{-# NOINLINE prefetchByteArray3# #-} +prefetchByteArray3# :: ByteArray# -> Int# -> ByteArray# +prefetchByteArray3# a1 a2 = (GHC.Prim.prefetchByteArray3#) a1 a2 +{-# NOINLINE prefetchMutableByteArray3# #-} +prefetchMutableByteArray3# :: MutableByteArray# s -> Int# -> State# s -> State# s +prefetchMutableByteArray3# a1 a2 a3 = (GHC.Prim.prefetchMutableByteArray3#) a1 a2 a3 +{-# NOINLINE prefetchAddr3# #-} +prefetchAddr3# :: Addr# -> Int# -> Addr# +prefetchAddr3# a1 a2 = (GHC.Prim.prefetchAddr3#) a1 a2 +{-# NOINLINE prefetchByteArray2# #-} +prefetchByteArray2# :: ByteArray# -> Int# -> ByteArray# +prefetchByteArray2# a1 a2 = (GHC.Prim.prefetchByteArray2#) a1 a2 +{-# NOINLINE prefetchMutableByteArray2# #-} +prefetchMutableByteArray2# :: MutableByteArray# s -> Int# -> State# s -> State# s +prefetchMutableByteArray2# a1 a2 a3 = (GHC.Prim.prefetchMutableByteArray2#) a1 a2 a3 +{-# NOINLINE prefetchAddr2# #-} +prefetchAddr2# :: Addr# -> Int# -> Addr# +prefetchAddr2# a1 a2 = (GHC.Prim.prefetchAddr2#) a1 a2 +{-# NOINLINE prefetchByteArray1# #-} +prefetchByteArray1# :: ByteArray# -> Int# -> ByteArray# +prefetchByteArray1# a1 a2 = (GHC.Prim.prefetchByteArray1#) a1 a2 +{-# NOINLINE prefetchMutableByteArray1# #-} +prefetchMutableByteArray1# :: MutableByteArray# s -> Int# -> State# s -> State# s +prefetchMutableByteArray1# a1 a2 a3 = (GHC.Prim.prefetchMutableByteArray1#) a1 a2 a3 +{-# NOINLINE prefetchAddr1# #-} +prefetchAddr1# :: Addr# -> Int# -> Addr# +prefetchAddr1# a1 a2 = (GHC.Prim.prefetchAddr1#) a1 a2 +{-# NOINLINE prefetchByteArray0# #-} +prefetchByteArray0# :: ByteArray# -> Int# -> ByteArray# +prefetchByteArray0# a1 a2 = (GHC.Prim.prefetchByteArray0#) a1 a2 +{-# NOINLINE prefetchMutableByteArray0# #-} +prefetchMutableByteArray0# :: MutableByteArray# s -> Int# -> State# s -> State# s +prefetchMutableByteArray0# a1 a2 a3 = (GHC.Prim.prefetchMutableByteArray0#) a1 a2 a3 +{-# NOINLINE prefetchAddr0# #-} +prefetchAddr0# :: Addr# -> Int# -> Addr# +prefetchAddr0# a1 a2 = (GHC.Prim.prefetchAddr0#) a1 a2 diff --git a/GHC/Tuple.hs b/GHC/Tuple.hs new file mode 100644 --- /dev/null +++ b/GHC/Tuple.hs @@ -0,0 +1,211 @@ +{-# LANGUAGE Trustworthy #-} +{-# LANGUAGE NoImplicitPrelude, DeriveGeneric #-} +----------------------------------------------------------------------------- +-- | +-- Module : GHC.Tuple +-- Copyright : (c) The University of Glasgow 2001 +-- License : BSD-style (see the file libraries/ghc-prim/LICENSE) +-- +-- Maintainer : libraries@haskell.org +-- Stability : experimental +-- Portability : non-portable (GHC extensions) +-- +-- The tuple data types +-- +----------------------------------------------------------------------------- + +module GHC.Tuple where + + +default () -- Double and Integer aren't available yet + +-- | The unit datatype @()@ has one non-undefined member, the nullary +-- constructor @()@. +data () = () + +data (,) a b = (,) a b +data (,,) a b c = (,,) a b c +data (,,,) a b c d = (,,,) a b c d +data (,,,,) a b c d e = (,,,,) a b c d e +data (,,,,,) a b c d e f = (,,,,,) a b c d e f +data (,,,,,,) a b c d e f g = (,,,,,,) a b c d e f g +data (,,,,,,,) a b c d e f g h = (,,,,,,,) a b c d e f g h +data (,,,,,,,,) a b c d e f g h i = (,,,,,,,,) a b c d e f g h i +data (,,,,,,,,,) a b c d e f g h i j = (,,,,,,,,,) a b c d e f g h i j +data (,,,,,,,,,,) a b c d e f g h i j k = (,,,,,,,,,,) a b c d e f g h i j k +data (,,,,,,,,,,,) a b c d e f g h i j k l = (,,,,,,,,,,,) a b c d e f g h i j k l +data (,,,,,,,,,,,,) a b c d e f g h i j k l m = (,,,,,,,,,,,,) a b c d e f g h i j k l m +data (,,,,,,,,,,,,,) a b c d e f g h i j k l m n = (,,,,,,,,,,,,,) a b c d e f g h i j k l m n +data (,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o = (,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o +data (,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p = (,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p +data (,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q + = (,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q +data (,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r + = (,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r +data (,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s + = (,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s +data (,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t + = (,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t +data (,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u + = (,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u +data (,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v + = (,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v +data (,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w + = (,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w +data (,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x + = (,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x +data (,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y + = (,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y +data (,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z + = (,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z +data (,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ + = (,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ +data (,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ + = (,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ +data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ + = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ +data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ + = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ +data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ + = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ +data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ + = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ +data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ + = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ +data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ + = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ +data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ + = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ +data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ + = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ +data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ + = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ +data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ + = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ +data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ + = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ +data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ + = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ +data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ + = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ +data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ + = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ +data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ + = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ +data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ + = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ +data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ + = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ +data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ + = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ +data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ + = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ +data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ + = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ +data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ + = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ +data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ + = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ +data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ + = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ +data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ + = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ +data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ + = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ +data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ + = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ +data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ + = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ +data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ + = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ +data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ + = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ +data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ + = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ +data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ + = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ +data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ + = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ +data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ + = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ +data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ + = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ + +{- Manuel says: Including one more declaration gives a segmentation fault. +data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ + = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ +data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ + = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ +data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ + = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ +data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ + = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ +data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ + = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ +data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ + = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ +data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ + = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ +data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ + = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ +data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ + = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ +data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ t__ + = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ t__ +data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ t__ u__ + = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ t__ u__ +data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ t__ u__ v__ + = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ t__ u__ v__ +data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ t__ u__ v__ w__ + = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ t__ u__ v__ w__ +data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ t__ u__ v__ w__ x__ + = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ t__ u__ v__ w__ x__ +data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ t__ u__ v__ w__ x__ y__ + = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ t__ u__ v__ w__ x__ y__ +data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ t__ u__ v__ w__ x__ y__ z__ + = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ t__ u__ v__ w__ x__ y__ z__ +data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ t__ u__ v__ w__ x__ y__ z__ a___ + = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ t__ u__ v__ w__ x__ y__ z__ a___ +data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ t__ u__ v__ w__ x__ y__ z__ a___ b___ + = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ t__ u__ v__ w__ x__ y__ z__ a___ b___ +data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ t__ u__ v__ w__ x__ y__ z__ a___ b___ c___ + = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ t__ u__ v__ w__ x__ y__ z__ a___ b___ c___ +data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ t__ u__ v__ w__ x__ y__ z__ a___ b___ c___ d___ + = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ t__ u__ v__ w__ x__ y__ z__ a___ b___ c___ d___ +data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ t__ u__ v__ w__ x__ y__ z__ a___ b___ c___ d___ e___ + = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ t__ u__ v__ w__ x__ y__ z__ a___ b___ c___ d___ e___ +data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ t__ u__ v__ w__ x__ y__ z__ a___ b___ c___ d___ e___ f___ + = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ t__ u__ v__ w__ x__ y__ z__ a___ b___ c___ d___ e___ f___ +data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ t__ u__ v__ w__ x__ y__ z__ a___ b___ c___ d___ e___ f___ g___ + = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ t__ u__ v__ w__ x__ y__ z__ a___ b___ c___ d___ e___ f___ g___ +data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ t__ u__ v__ w__ x__ y__ z__ a___ b___ c___ d___ e___ f___ g___ h___ + = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ t__ u__ v__ w__ x__ y__ z__ a___ b___ c___ d___ e___ f___ g___ h___ +data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ t__ u__ v__ w__ x__ y__ z__ a___ b___ c___ d___ e___ f___ g___ h___ i___ + = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ t__ u__ v__ w__ x__ y__ z__ a___ b___ c___ d___ e___ f___ g___ h___ i___ +data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ t__ u__ v__ w__ x__ y__ z__ a___ b___ c___ d___ e___ f___ g___ h___ i___ j___ + = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ t__ u__ v__ w__ x__ y__ z__ a___ b___ c___ d___ e___ f___ g___ h___ i___ j___ +data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ t__ u__ v__ w__ x__ y__ z__ a___ b___ c___ d___ e___ f___ g___ h___ i___ j___ k___ + = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ t__ u__ v__ w__ x__ y__ z__ a___ b___ c___ d___ e___ f___ g___ h___ i___ j___ k___ +data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ t__ u__ v__ w__ x__ y__ z__ a___ b___ c___ d___ e___ f___ g___ h___ i___ j___ k___ l___ + = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ t__ u__ v__ w__ x__ y__ z__ a___ b___ c___ d___ e___ f___ g___ h___ i___ j___ k___ l___ +data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ t__ u__ v__ w__ x__ y__ z__ a___ b___ c___ d___ e___ f___ g___ h___ i___ j___ k___ l___ m___ + = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ t__ u__ v__ w__ x__ y__ z__ a___ b___ c___ d___ e___ f___ g___ h___ i___ j___ k___ l___ m___ +data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ t__ u__ v__ w__ x__ y__ z__ a___ b___ c___ d___ e___ f___ g___ h___ i___ j___ k___ l___ m___ n___ + = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ t__ u__ v__ w__ x__ y__ z__ a___ b___ c___ d___ e___ f___ g___ h___ i___ j___ k___ l___ m___ n___ +data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ t__ u__ v__ w__ x__ y__ z__ a___ b___ c___ d___ e___ f___ g___ h___ i___ j___ k___ l___ m___ n___ o___ + = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ t__ u__ v__ w__ x__ y__ z__ a___ b___ c___ d___ e___ f___ g___ h___ i___ j___ k___ l___ m___ n___ o___ +data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ t__ u__ v__ w__ x__ y__ z__ a___ b___ c___ d___ e___ f___ g___ h___ i___ j___ k___ l___ m___ n___ o___ p___ + = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ t__ u__ v__ w__ x__ y__ z__ a___ b___ c___ d___ e___ f___ g___ h___ i___ j___ k___ l___ m___ n___ o___ p___ +data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ t__ u__ v__ w__ x__ y__ z__ a___ b___ c___ d___ e___ f___ g___ h___ i___ j___ k___ l___ m___ n___ o___ p___ q___ + = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ t__ u__ v__ w__ x__ y__ z__ a___ b___ c___ d___ e___ f___ g___ h___ i___ j___ k___ l___ m___ n___ o___ p___ q___ +data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ t__ u__ v__ w__ x__ y__ z__ a___ b___ c___ d___ e___ f___ g___ h___ i___ j___ k___ l___ m___ n___ o___ p___ q___ r___ + = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ t__ u__ v__ w__ x__ y__ z__ a___ b___ c___ d___ e___ f___ g___ h___ i___ j___ k___ l___ m___ n___ o___ p___ q___ r___ +data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ t__ u__ v__ w__ x__ y__ z__ a___ b___ c___ d___ e___ f___ g___ h___ i___ j___ k___ l___ m___ n___ o___ p___ q___ r___ s___ + = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ t__ u__ v__ w__ x__ y__ z__ a___ b___ c___ d___ e___ f___ g___ h___ i___ j___ k___ l___ m___ n___ o___ p___ q___ r___ s___ +data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ t__ u__ v__ w__ x__ y__ z__ a___ b___ c___ d___ e___ f___ g___ h___ i___ j___ k___ l___ m___ n___ o___ p___ q___ r___ s___ t___ + = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ t__ u__ v__ w__ x__ y__ z__ a___ b___ c___ d___ e___ f___ g___ h___ i___ j___ k___ l___ m___ n___ o___ p___ q___ r___ s___ t___ +data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ t__ u__ v__ w__ x__ y__ z__ a___ b___ c___ d___ e___ f___ g___ h___ i___ j___ k___ l___ m___ n___ o___ p___ q___ r___ s___ t___ u___ + = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ t__ u__ v__ w__ x__ y__ z__ a___ b___ c___ d___ e___ f___ g___ h___ i___ j___ k___ l___ m___ n___ o___ p___ q___ r___ s___ t___ u___ +data (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ t__ u__ v__ w__ x__ y__ z__ a___ b___ c___ d___ e___ f___ g___ h___ i___ j___ k___ l___ m___ n___ o___ p___ q___ r___ s___ t___ u___ v___ + = (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__ k__ l__ m__ n__ o__ p__ q__ r__ s__ t__ u__ v__ w__ x__ y__ z__ a___ b___ c___ d___ e___ f___ g___ h___ i___ j___ k___ l___ m___ n___ o___ p___ q___ r___ s___ t___ u___ v___ +-} diff --git a/GHC/Types.hs b/GHC/Types.hs new file mode 100644 --- /dev/null +++ b/GHC/Types.hs @@ -0,0 +1,212 @@ +{-# LANGUAGE MagicHash, NoImplicitPrelude, TypeFamilies, UnboxedTuples #-} +----------------------------------------------------------------------------- +-- | +-- Module : GHC.Types +-- Copyright : (c) The University of Glasgow 2009 +-- License : see libraries/ghc-prim/LICENSE +-- +-- Maintainer : cvs-ghc@haskell.org +-- Stability : internal +-- Portability : non-portable (GHC Extensions) +-- +-- GHC type definitions. +-- Use GHC.Exts from the base package instead of importing this +-- module directly. +-- +----------------------------------------------------------------------------- + +module GHC.Types ( + Bool(..), Char(..), Int(..), Word(..), + Float(..), Double(..), + Ordering(..), IO(..), + isTrue#, + SPEC(..) + ) where + +import GHC.Prim + + +infixr 5 : + +data [] a = [] | a : [a] + +data {-# CTYPE "HsBool" #-} Bool = False | True + +{- | The character type 'Char' is an enumeration whose values represent +Unicode (or equivalently ISO\/IEC 10646) characters (see + for details). This set extends the ISO 8859-1 +(Latin-1) character set (the first 256 characters), which is itself an extension +of the ASCII character set (the first 128 characters). A character literal in +Haskell has type 'Char'. + +To convert a 'Char' to or from the corresponding 'Int' value defined +by Unicode, use 'Prelude.toEnum' and 'Prelude.fromEnum' from the +'Prelude.Enum' class respectively (or equivalently 'ord' and 'chr'). +-} +data {-# CTYPE "HsChar" #-} Char = C# Char# + +-- | A fixed-precision integer type with at least the range @[-2^29 .. 2^29-1]@. +-- The exact range for a given implementation can be determined by using +-- 'Prelude.minBound' and 'Prelude.maxBound' from the 'Prelude.Bounded' class. +data {-# CTYPE "HsInt" #-} Int = I# Int# + +-- |A 'Word' is an unsigned integral type, with the same size as 'Int'. +data {-# CTYPE "HsWord" #-} Word = W# Word# + +-- | Single-precision floating point numbers. +-- It is desirable that this type be at least equal in range and precision +-- to the IEEE single-precision type. +data {-# CTYPE "HsFloat" #-} Float = F# Float# + +-- | Double-precision floating point numbers. +-- It is desirable that this type be at least equal in range and precision +-- to the IEEE double-precision type. +data {-# CTYPE "HsDouble" #-} Double = D# Double# + +data Ordering = LT | EQ | GT + +{- | +A value of type @'IO' a@ is a computation which, when performed, +does some I\/O before returning a value of type @a@. + +There is really only one way to \"perform\" an I\/O action: bind it to +@Main.main@ in your program. When your program is run, the I\/O will +be performed. It isn't possible to perform I\/O from an arbitrary +function, unless that function is itself in the 'IO' monad and called +at some point, directly or indirectly, from @Main.main@. + +'IO' is a monad, so 'IO' actions can be combined using either the do-notation +or the '>>' and '>>=' operations from the 'Monad' class. +-} +newtype IO a = IO (State# RealWorld -> (# State# RealWorld, a #)) + + +-- | A data constructor used to box up all unlifted equalities +-- +-- The type constructor is special in that GHC pretends that it +-- has kind (? -> ? -> Fact) rather than (* -> * -> *) +data (~) a b = Eq# ((~#) a b) + + +-- Despite this not being exported here, the documentation will +-- be used by haddock, hence the user-facing blurb here, and not in primops.txt.pp: + +-- | This two-parameter class has instances for types @a@ and @b@ if +-- the compiler can infer that they have the same representation. This class +-- does not have regular instances; instead they are created on-the-fly during +-- type-checking. Trying to manually declare an instance of @Coercible@ +-- is an error. +-- +-- Nevertheless one can pretend that the following three kinds of instances +-- exist. First, as a trivial base-case: +-- +-- @instance a a@ +-- +-- Furthermore, for every type constructor there is +-- an instance that allows to coerce under the type constructor. For +-- example, let @D@ be a prototypical type constructor (@data@ or +-- @newtype@) with three type arguments, which have roles @nominal@, +-- @representational@ resp. @phantom@. Then there is an instance of +-- the form +-- +-- @instance Coercible b b\' => Coercible (D a b c) (D a b\' c\')@ +-- +-- Note that the @nominal@ type arguments are equal, the +-- @representational@ type arguments can differ, but need to have a +-- @Coercible@ instance themself, and the @phantom@ type arguments can be +-- changed arbitrarily. +-- +-- The third kind of instance exists for every @newtype NT = MkNT T@ and +-- comes in two variants, namely +-- +-- @instance Coercible a T => Coercible a NT@ +-- +-- @instance Coercible T b => Coercible NT b@ +-- +-- This instance is only usable if the constructor @MkNT@ is in scope. +-- +-- If, as a library author of a type constructor like @Set a@, you +-- want to prevent a user of your module to write +-- @coerce :: Set T -> Set NT@, +-- you need to set the role of @Set@\'s type parameter to @nominal@, +-- by writing +-- +-- @type role Set nominal@ +-- +-- For more details about this feature, please refer to +-- +-- by Joachim Breitner, Richard A. Eisenberg, Simon Peyton Jones and Stephanie Weirich. +-- +-- /Since: 4.7.0.0/ +data Coercible a b = MkCoercible ((~#) a b) + +-- | Alias for tagToEnum#. Returns True of its parameter is 1# and False +-- if it is 0#. + +{-# INLINE isTrue# #-} +isTrue# :: Int# -> Bool -- See Note [Optimizing isTrue#] +isTrue# x = tagToEnum# x + +-- Note [Optimizing isTrue#] +-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +-- +-- Current definition of isTrue# is a temporary workaround. We would like to +-- have functions isTrue# and isFalse# defined like this: +-- +-- isTrue# :: Int# -> Bool +-- isTrue# 1# = True +-- isTrue# _ = False +-- +-- isFalse# :: Int# -> Bool +-- isFalse# 0# = True +-- isFalse# _ = False +-- +-- These functions would allow us to safely check if a tag can represent True +-- or False. Using isTrue# and isFalse# as defined above will not introduce +-- additional case into the code. When we scrutinize return value of isTrue# +-- or isFalse#, either explicitly in a case expression or implicitly in a guard, +-- the result will always be a single case expression (given that optimizations +-- are turned on). This results from case-of-case transformation. Consider this +-- code (this is both valid Haskell and Core): +-- +-- case isTrue# (a ># b) of +-- True -> e1 +-- False -> e2 +-- +-- Inlining isTrue# gives: +-- +-- case (case (a ># b) of { 1# -> True; _ -> False } ) of +-- True -> e1 +-- False -> e2 +-- +-- Case-of-case transforms that to: +-- +-- case (a ># b) of +-- 1# -> case True of +-- True -> e1 +-- False -> e2 +-- _ -> case False of +-- True -> e1 +-- False -> e2 +-- +-- Which is then simplified by case-of-known-constructor: +-- +-- case (a ># b) of +-- 1# -> e1 +-- _ -> e2 +-- +-- While we get good Core here, the code generator will generate very bad Cmm +-- if e1 or e2 do allocation. It will push heap checks into case alternatives +-- which results in about 2.5% increase in code size. Until this is improved we +-- just make isTrue# an alias to tagToEnum#. This is a temporary solution (if +-- you're reading this in 2023 then things went wrong). See #8326. +-- + +-- | SPEC is used by GHC in the @SpecConstr@ pass in order to inform +-- the compiler when to be particularly aggressive. In particular, it +-- tells GHC to specialize regardless of size or the number of +-- specializations. However, not all loops fall into this category. +-- +-- Libraries can specify this by using 'SPEC' data type to inform which +-- loops should be aggressively specialized. +data SPEC = SPEC | SPEC2 diff --git a/LICENSE b/LICENSE new file mode 100644 --- /dev/null +++ b/LICENSE @@ -0,0 +1,62 @@ +This library (libraries/ghc-prim) is derived from code from several +sources: + + * Code from the GHC project which is largely (c) The University of + Glasgow, and distributable under a BSD-style license (see below), + + * Code from the Haskell 98 Report which is (c) Simon Peyton Jones + and freely redistributable (but see the full license for + restrictions). + +The full text of these licenses is reproduced below. All of the +licenses are BSD-style or compatible. + +----------------------------------------------------------------------------- + +The Glasgow Haskell Compiler License + +Copyright 2004, The University Court of the University of Glasgow. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + +- Redistributions of source code must retain the above copyright notice, +this list of conditions and the following disclaimer. + +- Redistributions in binary form must reproduce the above copyright notice, +this list of conditions and the following disclaimer in the documentation +and/or other materials provided with the distribution. + +- Neither name of the University nor the names of its contributors may be +used to endorse or promote products derived from this software without +specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE UNIVERSITY COURT OF THE UNIVERSITY OF +GLASGOW AND THE CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, +INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND +FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE +UNIVERSITY COURT OF THE UNIVERSITY OF GLASGOW OR THE CONTRIBUTORS BE LIABLE +FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY +OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH +DAMAGE. + +----------------------------------------------------------------------------- + +Code derived from the document "Report on the Programming Language +Haskell 98", is distributed under the following license: + + Copyright (c) 2002 Simon Peyton Jones + + The authors intend this Report to belong to the entire Haskell + community, and so we grant permission to copy and distribute it for + any purpose, provided that it is reproduced in its entirety, + including this Notice. Modified versions of this Report may also be + copied and distributed for any purpose, provided that the modified + version is clearly presented as such, and that it does not claim to + be a definition of the Haskell 98 Language. + diff --git a/Setup.hs b/Setup.hs new file mode 100644 --- /dev/null +++ b/Setup.hs @@ -0,0 +1,2 @@ +import Distribution.Simple +main = defaultMain diff --git a/cbits/bswap.c b/cbits/bswap.c new file mode 100644 --- /dev/null +++ b/cbits/bswap.c @@ -0,0 +1,27 @@ +#include "Rts.h" + +extern StgWord16 hs_bswap16(StgWord16 x); +StgWord16 +hs_bswap16(StgWord16 x) +{ + return ((x >> 8) | (x << 8)); +} + +extern StgWord32 hs_bswap32(StgWord32 x); +StgWord32 +hs_bswap32(StgWord32 x) +{ + return ((x >> 24) | ((x >> 8) & 0xff00) | + (x << 24) | ((x & 0xff00) << 8)); +} + +extern StgWord64 hs_bswap64(StgWord64 x); +StgWord64 +hs_bswap64(StgWord64 x) +{ + return ( (x >> 56) | (x << 56) + | ((x >> 40) & 0xff00) | ((x & 0xff00) << 40) + | ((x >> 24) & 0xff0000) | ((x & 0xff0000) << 24) + | ((x >> 8) & 0xff000000) | ((x & 0xff000000) << 8) + ); +} diff --git a/cbits/debug.c b/cbits/debug.c new file mode 100644 --- /dev/null +++ b/cbits/debug.c @@ -0,0 +1,10 @@ + +#include + +void debugLn(char *s) { + printf("%s\n", s); +} + +void debugErrLn(char *s) { + fprintf(stderr, "%s\n", s); +} diff --git a/cbits/longlong.c b/cbits/longlong.c new file mode 100644 --- /dev/null +++ b/cbits/longlong.c @@ -0,0 +1,89 @@ +/* ----------------------------------------------------------------------------- + * $Id: longlong.c,v 1.4 2002/12/13 14:23:42 simonmar Exp $ + * + * (c) The GHC Team, 1998-1999 + * + * Primitive operations over (64-bit) long longs + * (only used on 32-bit platforms.) + * + * ---------------------------------------------------------------------------*/ + + +/* +Miscellaneous primitive operations on HsInt64 and HsWord64s. +N.B. These are not primops! + +Instead of going the normal (boring) route of making the list +of primitive operations even longer to cope with operations +over 64-bit entities, we implement them instead 'out-of-line'. + +The primitive ops get their own routine (in C) that implements +the operation, requiring the caller to _ccall_ out. This has +performance implications of course, but we currently don't +expect intensive use of either Int64 or Word64 types. + +The exceptions to the rule are primops that cast to and from +64-bit entities (these are defined in PrimOps.h) +*/ + +#include "Rts.h" + +#if WORD_SIZE_IN_BITS < 64 + +/* Relational operators */ + +HsInt hs_gtWord64 (HsWord64 a, HsWord64 b) {return a > b;} +HsInt hs_geWord64 (HsWord64 a, HsWord64 b) {return a >= b;} +HsInt hs_eqWord64 (HsWord64 a, HsWord64 b) {return a == b;} +HsInt hs_neWord64 (HsWord64 a, HsWord64 b) {return a != b;} +HsInt hs_ltWord64 (HsWord64 a, HsWord64 b) {return a < b;} +HsInt hs_leWord64 (HsWord64 a, HsWord64 b) {return a <= b;} + +HsInt hs_gtInt64 (HsInt64 a, HsInt64 b) {return a > b;} +HsInt hs_geInt64 (HsInt64 a, HsInt64 b) {return a >= b;} +HsInt hs_eqInt64 (HsInt64 a, HsInt64 b) {return a == b;} +HsInt hs_neInt64 (HsInt64 a, HsInt64 b) {return a != b;} +HsInt hs_ltInt64 (HsInt64 a, HsInt64 b) {return a < b;} +HsInt hs_leInt64 (HsInt64 a, HsInt64 b) {return a <= b;} + +/* Arithmetic operators */ + +HsWord64 hs_remWord64 (HsWord64 a, HsWord64 b) {return a % b;} +HsWord64 hs_quotWord64 (HsWord64 a, HsWord64 b) {return a / b;} + +HsInt64 hs_remInt64 (HsInt64 a, HsInt64 b) {return a % b;} +HsInt64 hs_quotInt64 (HsInt64 a, HsInt64 b) {return a / b;} +HsInt64 hs_negateInt64 (HsInt64 a) {return -a;} +HsInt64 hs_plusInt64 (HsInt64 a, HsInt64 b) {return a + b;} +HsInt64 hs_minusInt64 (HsInt64 a, HsInt64 b) {return a - b;} +HsInt64 hs_timesInt64 (HsInt64 a, HsInt64 b) {return a * b;} + +/* Logical operators: */ + +HsWord64 hs_and64 (HsWord64 a, HsWord64 b) {return a & b;} +HsWord64 hs_or64 (HsWord64 a, HsWord64 b) {return a | b;} +HsWord64 hs_xor64 (HsWord64 a, HsWord64 b) {return a ^ b;} +HsWord64 hs_not64 (HsWord64 a) {return ~a;} + +HsWord64 hs_uncheckedShiftL64 (HsWord64 a, HsInt b) {return a << b;} +HsWord64 hs_uncheckedShiftRL64 (HsWord64 a, HsInt b) {return a >> b;} +/* Right shifting of signed quantities is not portable in C, so + the behaviour you'll get from using these primops depends + on the whatever your C compiler is doing. ToDo: fix. -- sof 8/98 +*/ +HsInt64 hs_uncheckedIShiftL64 (HsInt64 a, HsInt b) {return a << b;} +HsInt64 hs_uncheckedIShiftRA64 (HsInt64 a, HsInt b) {return a >> b;} +HsInt64 hs_uncheckedIShiftRL64 (HsInt64 a, HsInt b) + {return (HsInt64) ((HsWord64) a >> b);} + +/* Casting between longs and longer longs. +*/ + +HsInt64 hs_intToInt64 (HsInt i) {return (HsInt64) i;} +HsInt hs_int64ToInt (HsInt64 i) {return (HsInt) i;} +HsWord64 hs_int64ToWord64 (HsInt64 i) {return (HsWord64) i;} +HsWord64 hs_wordToWord64 (HsWord w) {return (HsWord64) w;} +HsWord hs_word64ToWord (HsWord64 w) {return (HsWord) w;} +HsInt64 hs_word64ToInt64 (HsWord64 w) {return (HsInt64) w;} + +#endif /* SUPPORT_LONG_LONGS */ diff --git a/cbits/popcnt.c b/cbits/popcnt.c new file mode 100644 --- /dev/null +++ b/cbits/popcnt.c @@ -0,0 +1,82 @@ +#include "Rts.h" + +static const unsigned char popcount_tab[] = +{ + 0,1,1,2,1,2,2,3,1,2,2,3,2,3,3,4,1,2,2,3,2,3,3,4,2,3,3,4,3,4,4,5, + 1,2,2,3,2,3,3,4,2,3,3,4,3,4,4,5,2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6, + 1,2,2,3,2,3,3,4,2,3,3,4,3,4,4,5,2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6, + 2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,3,4,4,5,4,5,5,6,4,5,5,6,5,6,6,7, + 1,2,2,3,2,3,3,4,2,3,3,4,3,4,4,5,2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6, + 2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,3,4,4,5,4,5,5,6,4,5,5,6,5,6,6,7, + 2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,3,4,4,5,4,5,5,6,4,5,5,6,5,6,6,7, + 3,4,4,5,4,5,5,6,4,5,5,6,5,6,6,7,4,5,5,6,5,6,6,7,5,6,6,7,6,7,7,8, +}; + +extern StgWord hs_popcnt8(StgWord x); +StgWord +hs_popcnt8(StgWord x) +{ + return popcount_tab[(unsigned char)x]; +} + +extern StgWord hs_popcnt16(StgWord x); +StgWord +hs_popcnt16(StgWord x) +{ + return popcount_tab[(unsigned char)x] + + popcount_tab[(unsigned char)(x >> 8)]; +} + +extern StgWord hs_popcnt32(StgWord x); +StgWord +hs_popcnt32(StgWord x) +{ + return popcount_tab[(unsigned char)x] + + popcount_tab[(unsigned char)(x >> 8)] + + popcount_tab[(unsigned char)(x >> 16)] + + popcount_tab[(unsigned char)(x >> 24)]; +} + +extern StgWord hs_popcnt64(StgWord64 x); +StgWord +hs_popcnt64(StgWord64 x) +{ + return popcount_tab[(unsigned char)x] + + popcount_tab[(unsigned char)(x >> 8)] + + popcount_tab[(unsigned char)(x >> 16)] + + popcount_tab[(unsigned char)(x >> 24)] + + popcount_tab[(unsigned char)(x >> 32)] + + popcount_tab[(unsigned char)(x >> 40)] + + popcount_tab[(unsigned char)(x >> 48)] + + popcount_tab[(unsigned char)(x >> 56)]; +} + +#ifdef i386_HOST_ARCH + +extern StgWord hs_popcnt(StgWord x); +StgWord +hs_popcnt(StgWord x) +{ + return popcount_tab[(unsigned char)x] + + popcount_tab[(unsigned char)(x >> 8)] + + popcount_tab[(unsigned char)(x >> 16)] + + popcount_tab[(unsigned char)(x >> 24)]; +} + +#else + +extern StgWord hs_popcnt(StgWord x); +StgWord +hs_popcnt(StgWord x) +{ + return popcount_tab[(unsigned char)x] + + popcount_tab[(unsigned char)(x >> 8)] + + popcount_tab[(unsigned char)(x >> 16)] + + popcount_tab[(unsigned char)(x >> 24)] + + popcount_tab[(unsigned char)(x >> 32)] + + popcount_tab[(unsigned char)(x >> 40)] + + popcount_tab[(unsigned char)(x >> 48)] + + popcount_tab[(unsigned char)(x >> 56)]; +} + +#endif diff --git a/cbits/word2float.c b/cbits/word2float.c new file mode 100644 --- /dev/null +++ b/cbits/word2float.c @@ -0,0 +1,15 @@ +#include "Rts.h" + +extern StgFloat hs_word2float32(StgWord x); +StgFloat +hs_word2float32(StgWord x) +{ + return x; +} + +extern StgDouble hs_word2float64(StgWord x); +StgDouble +hs_word2float64(StgWord x) +{ + return x; +} diff --git a/ghc-prim.cabal b/ghc-prim.cabal new file mode 100644 --- /dev/null +++ b/ghc-prim.cabal @@ -0,0 +1,67 @@ +name: ghc-prim +version: 0.3.1.0 +-- GHC 7.6.1 released with 0.3.0.0 +license: BSD3 +license-file: LICENSE +category: GHC +maintainer: libraries@haskell.org +bug-reports: http://ghc.haskell.org/trac/ghc/newticket?component=libraries%20%28other%29&keywords=ghc-prim +synopsis: GHC primitives +cabal-version: >=1.10 +build-type: Custom +description: + GHC primitives. + +source-repository head + type: git + location: http://git.haskell.org/packages/ghc-prim.git + +source-repository this + type: git + location: http://git.haskell.org/packages/ghc-prim.git + tag: ghc-prim-0.3.1.0-release + +flag include-ghc-prim + Description: Include GHC.Prim in exposed-modules + default: False + +Library + default-language: Haskell2010 + other-extensions: + BangPatterns + CPP + DeriveGeneric + MagicHash + MultiParamTypeClasses + NoImplicitPrelude + StandaloneDeriving + Trustworthy + TypeFamilies + UnboxedTuples + UnliftedFFITypes + + build-depends: rts == 1.0.* + + exposed-modules: + GHC.CString + GHC.Classes + GHC.Debug + GHC.IntWord64 + GHC.Magic + GHC.PrimopWrappers + GHC.Tuple + GHC.Types + + if flag(include-ghc-prim) + exposed-modules: GHC.Prim + + c-sources: + cbits/bswap.c + cbits/debug.c + cbits/longlong.c + cbits/popcnt.c + cbits/word2float.c + + -- We need to set the package name to ghc-prim (without a version number) + -- as it's magic. + ghc-options: -package-name ghc-prim