ghc-prim 0.4.0.0 → 0.5.0.0

raw patch · 13 files changed

+7804/−6925 lines, 13 filessetup-changedPVP ok

version bump matches the API change (PVP)

API changes (from Hackage documentation)

Files

• GHC/CString.hs +33/−5
• GHC/Classes.hs +503/−17
• GHC/IntWord64.hs +3/−0
• GHC/Magic.hs +27/−1
• GHC/Prim.hs +6623/−6592
• GHC/PrimopWrappers.hs +19/−4
• GHC/Tuple.hs +143/−107
• GHC/Types.hs +276/−80
• Setup.hs +4/−0
• cbits/atomic.c +112/−112
• cbits/ctz.c +1/−1
• changelog.md +38/−0
• ghc-prim.cabal +22/−6

@@ -24,7 +24,7 @@ import GHC.Prim  -------------------------------------------------------------------------------- Unpacking C strings}+-- Unpacking C strings -----------------------------------------------------------------------------  -- This code is needed for virtually all programs, since it's used for@@ -34,11 +34,33 @@ -- stuff uses Strings in the representation, so to give representations for -- ghc-prim types we need unpackCString# +{-+Note [Inlining unpackCString#]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+There's really no point in ever inlining things like unpackCString# as the loop+doesn't specialise in an interesting way and we can't deforest the list+constructors (we'd want to use unpackFoldrCString# for this). Moreover, it's+pretty small, so there's a danger that it'll be inlined at every literal, which+is a waste.++Moreover, inlining early may interfere with a variety of rules that are supposed+to match unpackCString#,++ * BuiltInRules in PrelRules.hs; e.g.+       eqString (unpackCString# (Lit s1)) (unpackCString# (Lit s2)+          = s1 == s2++ * unpacking rules; e.g. in GHC.Base,+       unpackCString# a+          = build (unpackFoldrCString# a)++ * stream fusion rules; e.g. in the `text` library,+       unstream (S.map safe (S.streamList (GHC.unpackCString# a)))+          = unpackCString# a+-}+ 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@@ -64,7 +86,7 @@  -- Usually the unpack-list rule turns unpackFoldrCString# into unpackCString# --- It also has a BuiltInRule in PrelRules.lhs:+-- It also has a BuiltInRule in PrelRules.hs: --      unpackFoldrCString# "foo" c (unpackFoldrCString# "baz" c n) --        =  unpackFoldrCString# "foobaz" c n @@ -85,7 +107,10 @@       where         !ch = indexCharOffAddr# addr nh +-- There's really no point in inlining this for the same reasons as+-- unpackCString. See Note [Inlining unpackCString#] above for details. unpackCStringUtf8# :: Addr# -> [Char]+{-# NOINLINE unpackCStringUtf8# #-} unpackCStringUtf8# addr   = unpack 0#   where@@ -110,7 +135,10 @@       where         !ch = indexCharOffAddr# addr nh +-- There's really no point in inlining this for the same reasons as+-- unpackCString. See Note [Inlining unpackCString#] above for details. unpackNBytes# :: Addr# -> Int# -> [Char]+{-# NOINLINE unpackNBytes# #-} unpackNBytes# _addr 0#   = [] unpackNBytes#  addr len# = unpack [] (len# -# 1#)     where

@@ -1,7 +1,19 @@-{-# 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.+{-# LANGUAGE CPP, Trustworthy #-}+{-# LANGUAGE NoImplicitPrelude, MagicHash, StandaloneDeriving, BangPatterns,+             KindSignatures, DataKinds, ConstraintKinds,+              MultiParamTypeClasses, FunctionalDependencies #-}+{-# LANGUAGE AllowAmbiguousTypes #-}+  -- ip :: IP x a => a  is strictly speaking ambiguous, but IP is magic+{-# LANGUAGE UndecidableSuperClasses #-}+  -- Because of the type-variable superclasses for tuples++{-# OPTIONS_GHC -Wno-unused-imports #-}+-- -Wno-unused-imports needed for the GHC.Tuple import below. Sigh.++{-# OPTIONS_GHC -Wno-unused-top-binds #-}+-- -Wno-unused-top-binds is there (I hope) to stop Haddock complaining+-- about the constraint tuples being defined but not used+ {-# OPTIONS_HADDOCK hide #-} ----------------------------------------------------------------------------- -- |@@ -17,14 +29,38 @@ -- ----------------------------------------------------------------------------- -module GHC.Classes where+module GHC.Classes(+    -- * Implicit paramaters+    IP(..), +    -- * Equality and ordering+    Eq(..),+    Ord(..),+    -- ** Monomorphic equality operators+    -- | See GHC.Classes#matching_overloaded_methods_in_rules+    eqInt, neInt,+    eqWord, neWord,+    eqChar, neChar,+    eqFloat, eqDouble,+    -- ** Monomorphic comparison operators+    gtInt, geInt, leInt, ltInt, compareInt, compareInt#,+    gtWord, geWord, leWord, ltWord, compareWord, compareWord#,++    -- * Functions over Bool+    (&&), (||), not,++    -- * Integer arithmetic+    divInt#, modInt#+ ) where+ -- GHC.Magic is used in some derived instances import GHC.Magic ()+import GHC.IntWord64 import GHC.Prim import GHC.Tuple import GHC.Types +#include "MachDeps.h"  infix  4  ==, /=, <, <=, >=, > infixr 3  &&@@ -32,6 +68,51 @@  default ()              -- Double isn't available yet +-- | The syntax @?x :: a@ is desugared into @IP "x" a@+-- IP is declared very early, so that libraries can take+-- advantage of the implicit-call-stack feature+class IP (x :: Symbol) a | x -> a where+  ip :: a++{- $matching_overloaded_methods_in_rules++Matching on class methods (e.g. @(==)@) in rewrite rules tends to be a bit+fragile. For instance, consider this motivating example from the @bytestring@+library,++> break :: (Word8 -> Bool) -> ByteString -> (ByteString, ByteString)+> breakByte :: Word8 -> ByteString -> (ByteString, ByteString)+> {-# RULES "break -> breakByte" forall a. break (== x) = breakByte x #-}++Here we have two functions, with @breakByte@ providing an optimized+implementation of @break@ where the predicate is merely testing for equality+with a known @Word8@. As written, however, this rule will be quite fragile as+the @(==)@ class operation rule may rewrite the predicate before our @break@+rule has a chance to fire.++For this reason, most of the primitive types in @base@ have 'Eq' and 'Ord'+instances defined in terms of helper functions with inlinings delayed to phase+1. For instance, @Word8@\'s @Eq@ instance looks like,++> instance Eq Word8 where+>     (==) = eqWord8+>     (/=) = neWord8+>+> eqWord8, neWord8 :: Word8 -> Word8 -> Bool+> eqWord8 (W8# x) (W8# y) = ...+> neWord8 (W8# x) (W8# y) = ...+> {-# INLINE [1] eqWord8 #-}+> {-# INLINE [1] neWord8 #-}++This allows us to save our @break@ rule above by rewriting it to instead match+against @eqWord8@,++> {-# RULES "break -> breakByte" forall a. break (`eqWord8` x) = breakByte x #-}++Currently this is only done for '(==)', '(/=)', '(<)', '(<=)', '(>)', and '(>=)'+for the types in "GHC.Word" and "GHC.Int".+-}+ -- | 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@@ -92,28 +173,82 @@  deriving instance Eq Bool deriving instance Eq Ordering-deriving instance Eq Word +instance Eq Word where+    (==) = eqWord+    (/=) = neWord++-- See GHC.Classes#matching_overloaded_methods_in_rules+{-# INLINE [1] eqWord #-}+{-# INLINE [1] neWord #-}+eqWord, neWord :: Word -> Word -> Bool+(W# x) `eqWord` (W# y) = isTrue# (x `eqWord#` y)+(W# x) `neWord` (W# y) = isTrue# (x `neWord#` y)++-- See GHC.Classes#matching_overloaded_methods_in_rules instance Eq Char where-    (C# c1) == (C# c2) = isTrue# (c1 `eqChar#` c2)-    (C# c1) /= (C# c2) = isTrue# (c1 `neChar#` c2)+    (==) = eqChar+    (/=) = neChar +-- See GHC.Classes#matching_overloaded_methods_in_rules+{-# INLINE [1] eqChar #-}+{-# INLINE [1] neChar #-}+eqChar, neChar :: Char -> Char -> Bool+(C# x) `eqChar` (C# y) = isTrue# (x `eqChar#` y)+(C# x) `neChar` (C# y) = isTrue# (x `neChar#` y)+ instance Eq Float where-    (F# x) == (F# y) = isTrue# (x `eqFloat#` y)+    (==) = eqFloat +-- See GHC.Classes#matching_overloaded_methods_in_rules+{-# INLINE [1] eqFloat #-}+eqFloat :: Float -> Float -> Bool+(F# x) `eqFloat` (F# y) = isTrue# (x `eqFloat#` y)+ instance Eq Double where-    (D# x) == (D# y) = isTrue# (x ==## y)+    (==) = eqDouble +-- See GHC.Classes#matching_overloaded_methods_in_rules+{-# INLINE [1] eqDouble #-}+eqDouble :: Double -> Double -> Bool+(D# x) `eqDouble` (D# y) = isTrue# (x ==## y)+ instance Eq Int where     (==) = eqInt     (/=) = neInt -{-# INLINE eqInt #-}-{-# INLINE neInt #-}+-- See GHC.Classes#matching_overloaded_methods_in_rules+{-# INLINE [1] eqInt #-}+{-# INLINE [1] neInt #-} eqInt, neInt :: Int -> Int -> Bool (I# x) `eqInt` (I# y) = isTrue# (x ==# y) (I# x) `neInt` (I# y) = isTrue# (x /=# y) +#if WORD_SIZE_IN_BITS < 64+instance Eq TyCon where+  (==) (TyCon hi1 lo1 _ _) (TyCon hi2 lo2 _ _)+       = isTrue# (hi1 `eqWord64#` hi2) && isTrue# (lo1 `eqWord64#` lo2)+instance Ord TyCon where+  compare (TyCon hi1 lo1 _ _) (TyCon hi2 lo2 _ _)+    | isTrue# (hi1 `gtWord64#` hi2) = GT+    | isTrue# (hi1 `ltWord64#` hi2) = LT+    | isTrue# (lo1 `gtWord64#` lo2) = GT+    | isTrue# (lo1 `ltWord64#` lo2) = LT+    | True                = EQ+#else+instance Eq TyCon where+  (==) (TyCon hi1 lo1 _ _) (TyCon hi2 lo2 _ _)+       = isTrue# (hi1 `eqWord#` hi2) && isTrue# (lo1 `eqWord#` lo2)+instance Ord TyCon where+  compare (TyCon hi1 lo1 _ _) (TyCon hi2 lo2 _ _)+    | isTrue# (hi1 `gtWord#` hi2) = GT+    | isTrue# (hi1 `ltWord#` hi2) = LT+    | isTrue# (lo1 `gtWord#` lo2) = GT+    | isTrue# (lo1 `ltWord#` lo2) = LT+    | True              = EQ+#endif++ -- | The 'Ord' class is used for totally ordered datatypes. -- -- Instances of 'Ord' can be derived for any user-defined@@ -195,7 +330,6 @@  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@@ -235,10 +369,11 @@     (>=)    = geInt     (>)     = gtInt -{-# INLINE gtInt #-}-{-# INLINE geInt #-}-{-# INLINE ltInt #-}-{-# INLINE leInt #-}+-- See GHC.Classes#matching_overloaded_methods_in_rules+{-# INLINE [1] gtInt #-}+{-# INLINE [1] geInt #-}+{-# INLINE [1] ltInt #-}+{-# INLINE [1] leInt #-} gtInt, geInt, ltInt, leInt :: Int -> Int -> Bool (I# x) `gtInt` (I# y) = isTrue# (x >#  y) (I# x) `geInt` (I# y) = isTrue# (x >=# y)@@ -254,6 +389,33 @@     | isTrue# (x# ==# y#) = EQ     | True                = GT +instance Ord Word where+    compare = compareWord+    (<)     = ltWord+    (<=)    = leWord+    (>=)    = geWord+    (>)     = gtWord++-- See GHC.Classes#matching_overloaded_methods_in_rules+{-# INLINE [1] gtWord #-}+{-# INLINE [1] geWord #-}+{-# INLINE [1] ltWord #-}+{-# INLINE [1] leWord #-}+gtWord, geWord, ltWord, leWord :: Word -> Word -> Bool+(W# x) `gtWord` (W# y) = isTrue# (x `gtWord#` y)+(W# x) `geWord` (W# y) = isTrue# (x `geWord#` y)+(W# x) `ltWord` (W# y) = isTrue# (x `ltWord#` y)+(W# x) `leWord` (W# y) = isTrue# (x `leWord#` y)++compareWord :: Word -> Word -> Ordering+(W# x#) `compareWord` (W# y#) = compareWord# x# y#++compareWord# :: Word# -> Word# -> Ordering+compareWord# x# y#+    | isTrue# (x# `ltWord#` y#) = LT+    | isTrue# (x# `eqWord#` y#) = EQ+    | True                      = GT+ -- OK, so they're technically not part of a class...:  -- Boolean functions@@ -297,3 +459,327 @@       else r#     where     !r# = x# `remInt#` y#+++{- *************************************************************+*                                                              *+*               Constraint tuples                              *+*                                                              *+************************************************************* -}++class ()+class (c1, c2)     => (c1, c2)+class (c1, c2, c3) => (c1, c2, c3)+class (c1, c2, c3, c4) => (c1, c2, c3, c4)+class (c1, c2, c3, c4, c5) => (c1, c2, c3, c4, c5)+class (c1, c2, c3, c4, c5, c6) => (c1, c2, c3, c4, c5, c6)+class (c1, c2, c3, c4, c5, c6, c7) => (c1, c2, c3, c4, c5, c6, c7)+class (c1, c2, c3, c4, c5, c6, c7, c8) => (c1, c2, c3, c4, c5, c6, c7, c8)+class (c1, c2, c3, c4, c5, c6, c7, c8, c9)+   => (c1, c2, c3, c4, c5, c6, c7, c8, c9)+class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10)+   => (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10)+class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11)+   => (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11)+class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12)+   => (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12)+class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13)+   => (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13)+class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14)+   => (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14)+class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15)+   => (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15)+class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16)+   => (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16)+class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16,+       c17)+   => (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16,+       c17)+class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16,+       c17,c18)+   => (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16,+       c17, c18)+class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16,+       c17, c18, c19)+   => (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16,+       c17, c18, c19)+class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16,+       c17, c18, c19, c20)+   => (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16,+       c17, c18, c19, c20)+class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16,+       c17, c18, c19, c20, c21)+   => (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16,+       c17, c18, c19, c20, c21)+class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16,+       c17, c18, c19, c20, c21, c22)+   => (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16,+       c17, c18, c19, c20, c21, c22)+class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16,+       c17, c18, c19, c20, c21, c22, c23)+   => (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16,+       c17, c18, c19, c20, c21, c22, c23)+class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16,+       c17, c18, c19, c20, c21, c22, c23, c24)+   => (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16,+       c17, c18, c19, c20, c21, c22, c23, c24)+class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16,+       c17, c18, c19, c20, c21, c22, c23, c24, c25)+   => (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16,+       c17, c18, c19, c20, c21, c22, c23, c24, c25)+class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16,+       c17, c18, c19, c20, c21, c22, c23, c24, c25, c26)+   => (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16,+       c17, c18, c19, c20, c21, c22, c23, c24, c25, c26)+class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16,+       c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27)+   => (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16,+       c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27)+class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16,+       c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28)+   => (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16,+       c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28)+class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16,+       c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29)+   => (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16,+       c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29)+class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16,+       c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30)+   => (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16,+       c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30)+class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16,+       c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30,+       c31)+   => (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16,+       c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30,+       c31)+class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16,+       c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30,+       c31, c32)+   => (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16,+       c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30,+       c31, c32)+class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16,+       c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30,+       c31, c32, c33)+   => (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16,+       c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30,+       c31, c32, c33)+class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16,+       c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30,+       c31, c32, c33, c34)+   => (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16,+       c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30,+       c31, c32, c33, c34)+class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16,+       c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30,+       c31, c32, c33, c34, c35)+   => (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16,+       c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30,+       c31, c32, c33, c34, c35)+class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16,+       c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30,+       c31, c32, c33, c34, c35, c36)+   => (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16,+       c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30,+       c31, c32, c33, c34, c35, c36)+class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16,+       c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30,+       c31, c32, c33, c34, c35, c36, c37)+   => (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16,+       c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30,+       c31, c32, c33, c34, c35, c36, c37)+class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16,+       c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30,+       c31, c32, c33, c34, c35, c36, c37, c38)+   => (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16,+       c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30,+       c31, c32, c33, c34, c35, c36, c37, c38)+class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16,+       c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30,+       c31, c32, c33, c34, c35, c36, c37, c38, c39)+   => (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16,+       c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30,+       c31, c32, c33, c34, c35, c36, c37, c38, c39)+class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16,+       c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30,+       c31, c32, c33, c34, c35, c36, c37, c38, c39, c40)+   => (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16,+       c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30,+       c31, c32, c33, c34, c35, c36, c37, c38, c39, c40)+class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16,+       c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30,+       c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41)+   => (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16,+       c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30,+       c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41)+class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16,+       c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30,+       c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42)+   => (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16,+       c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30,+       c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42)+class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16,+       c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30,+       c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43)+   => (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16,+       c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30,+       c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43)+class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16,+       c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30,+       c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43, c44)+   => (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16,+       c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30,+       c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43, c44)+class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16,+       c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30,+       c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43, c44,+       c45)+   => (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16,+       c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30,+       c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43, c44,+       c45)+class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16,+       c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30,+       c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43, c44,+       c45, c46)+   => (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16,+       c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30,+       c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43, c44,+       c45, c46)+class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16,+       c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30,+       c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43, c44,+       c45, c46, c47)+   => (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16,+       c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30,+       c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43, c44,+       c45, c46, c47)+class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16,+       c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30,+       c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43, c44,+       c45, c46, c47, c48)+   => (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16,+       c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30,+       c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43, c44,+       c45, c46, c47, c48)+class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16,+       c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30,+       c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43, c44,+       c45, c46, c47, c48, c49)+   => (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16,+       c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30,+       c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43, c44,+       c45, c46, c47, c48, c49)+class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16,+       c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30,+       c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43, c44,+       c45, c46, c47, c48, c49, c50)+   => (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16,+       c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30,+       c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43, c44,+       c45, c46, c47, c48, c49, c50)+class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16,+       c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30,+       c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43, c44,+       c45, c46, c47, c48, c49, c50, c51)+   => (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16,+       c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30,+       c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43, c44,+       c45, c46, c47, c48, c49, c50, c51)+class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16,+       c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30,+       c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43, c44,+       c45, c46, c47, c48, c49, c50, c51, c52)+   => (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16,+       c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30,+       c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43, c44,+       c45, c46, c47, c48, c49, c50, c51, c52)+class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16,+       c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30,+       c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43, c44,+       c45, c46, c47, c48, c49, c50, c51, c52, c53)+   => (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16,+       c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30,+       c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43, c44,+       c45, c46, c47, c48, c49, c50, c51, c52, c53)+class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16,+       c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30,+       c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43, c44,+       c45, c46, c47, c48, c49, c50, c51, c52, c53, c54)+   => (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16,+       c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30,+       c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43, c44,+       c45, c46, c47, c48, c49, c50, c51, c52, c53, c54)+class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16,+       c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30,+       c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43, c44,+       c45, c46, c47, c48, c49, c50, c51, c52, c53, c54, c55)+   => (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16,+       c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30,+       c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43, c44,+       c45, c46, c47, c48, c49, c50, c51, c52, c53, c54, c55)+class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16,+       c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30,+       c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43, c44,+       c45, c46, c47, c48, c49, c50, c51, c52, c53, c54, c55, c56)+   => (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16,+       c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30,+       c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43, c44,+       c45, c46, c47, c48, c49, c50, c51, c52, c53, c54, c55, c56)+class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16,+       c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30,+       c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43, c44,+       c45, c46, c47, c48, c49, c50, c51, c52, c53, c54, c55, c56, c57)+   => (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16,+       c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30,+       c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43, c44,+       c45, c46, c47, c48, c49, c50, c51, c52, c53, c54, c55, c56, c57)+class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16,+       c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30,+       c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43, c44,+       c45, c46, c47, c48, c49, c50, c51, c52, c53, c54, c55, c56, c57, c58)+   => (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16,+       c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30,+       c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43, c44,+       c45, c46, c47, c48, c49, c50, c51, c52, c53, c54, c55, c56, c57, c58)+class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16,+       c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30,+       c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43, c44,+       c45, c46, c47, c48, c49, c50, c51, c52, c53, c54, c55, c56, c57, c58,+       c59)+   => (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16,+       c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30,+       c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43, c44,+       c45, c46, c47, c48, c49, c50, c51, c52, c53, c54, c55, c56, c57, c58,+       c59)+class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16,+       c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30,+       c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43, c44,+       c45, c46, c47, c48, c49, c50, c51, c52, c53, c54, c55, c56, c57, c58,+       c59, c60)+   => (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16,+       c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30,+       c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43, c44,+       c45, c46, c47, c48, c49, c50, c51, c52, c53, c54, c55, c56, c57, c58,+       c59, c60)+class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16,+       c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30,+       c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43, c44,+       c45, c46, c47, c48, c49, c50, c51, c52, c53, c54, c55, c56, c57, c58,+       c59, c60, c61)+   => (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16,+       c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30,+       c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43, c44,+       c45, c46, c47, c48, c49, c50, c51, c52, c53, c54, c55, c56, c57, c58,+       c59, c60, c61)+class (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16,+       c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30,+       c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43, c44,+       c45, c46, c47, c48, c49, c50, c51, c52, c53, c54, c55, c56, c57, c58,+       c59, c60, c61, c62)+   => (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16,+       c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30,+       c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43, c44,+       c45, c46, c47, c48, c49, c50, c51, c52, c53, c54, c55, c56, c57, c58,+       c59, c60, c61, c62)

@@ -23,7 +23,10 @@ #endif     ) where +import GHC.Types () -- Make implicit dependency known to build system+ #if WORD_SIZE_IN_BITS < 64+ import GHC.Prim  foreign import ccall unsafe "hs_eqWord64"    eqWord64#     :: Word64# -> Word64# -> Int#

@@ -1,5 +1,9 @@+{-# LANGUAGE CPP #-} {-# LANGUAGE Trustworthy #-} {-# LANGUAGE NoImplicitPrelude #-}+{-# LANGUAGE MagicHash #-}+{-# LANGUAGE UnboxedTuples #-}+ ----------------------------------------------------------------------------- -- | -- Module      :  GHC.Magic@@ -17,8 +21,11 @@ -- ----------------------------------------------------------------------------- -module GHC.Magic ( inline, lazy, oneShot ) where+module GHC.Magic ( inline, lazy, oneShot, runRW# ) where +import GHC.Prim+import GHC.CString ()+ -- | 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@@ -69,7 +76,26 @@ -- argument will be called at most once, which may (or may not) enable certain -- optimizations. It can be useful to improve the performance of code in continuation -- passing style.+--+-- If 'oneShot' is used wrongly, then it may be that computations whose result+-- that would otherwise be shared are re-evaluated every time they are used. Otherwise,+-- the use of `oneShot` is safe.+--+-- 'oneShot' is open kinded, i.e. the type variables can refer to unlifted+-- types as well. oneShot :: (a -> b) -> (a -> b) oneShot f = f -- Implementation note: This is wired in in MkId.lhs, so the code here is -- mostly there to have a place for the documentation.++-- | Apply a function to a 'RealWorld' token.+runRW# :: (State# RealWorld -> (# State# RealWorld, o #))+       -> (# State# RealWorld, o #)+-- See Note [runRW magic] in MkId+#if !defined(__HADDOCK_VERSION__)+runRW# m = m realWorld#+#else+runRW# = runRW#   -- The realWorld# is too much for haddock+#endif+{-# NOINLINE runRW# #-}+-- This is inlined manually in CorePrep

@@ -22,6598 +22,6629 @@ {-# LANGUAGE MultiParamTypeClasses #-} {-# LANGUAGE NoImplicitPrelude #-} {-# LANGUAGE 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#,-        clz8#,-        clz16#,-        clz32#,-        clz64#,-        clz#,-        ctz8#,-        ctz16#,-        ctz32#,-        ctz64#,-        ctz#,-        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#,-        decodeDouble_Int64#,-        --- * 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#,-        --- * Small Arrays--- |Operations on @SmallArray\#@. A @SmallArray\#@ works---          just like an @Array\#@, but with different space use and---          performance characteristics (that are often useful with small---          arrays). The @SmallArray\#@ and @SmallMutableArray#@---          lack a \`card table\'. The purpose of a card table is to avoid---          having to scan every element of the array on each GC by---          keeping track of which elements have changed since the last GC---          and only scanning those that have changed. So the consequence---          of there being no card table is that the representation is---          somewhat smaller and the writes are somewhat faster (because---          the card table does not need to be updated). The disadvantage---          of course is that for a @SmallMutableArray#@ the whole---          array has to be scanned on each GC. Thus it is best suited for---          use cases where the mutable array is not long lived, e.g.---          where a mutable array is initialised quickly and then frozen---          to become an immutable @SmallArray\#@.---         ---        SmallArray#,-        SmallMutableArray#,-        newSmallArray#,-        sameSmallMutableArray#,-        readSmallArray#,-        writeSmallArray#,-        sizeofSmallArray#,-        sizeofSmallMutableArray#,-        indexSmallArray#,-        unsafeFreezeSmallArray#,-        unsafeThawSmallArray#,-        copySmallArray#,-        copySmallMutableArray#,-        cloneSmallArray#,-        cloneSmallMutableArray#,-        freezeSmallArray#,-        thawSmallArray#,-        casSmallArray#,-        --- * 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#,-        shrinkMutableByteArray#,-        resizeMutableByteArray#,-        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#,-        atomicReadIntArray#,-        atomicWriteIntArray#,-        casIntArray#,-        fetchAddIntArray#,-        fetchSubIntArray#,-        fetchAndIntArray#,-        fetchNandIntArray#,-        fetchOrIntArray#,-        fetchXorIntArray#,-        --- * 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,-        --- * 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 @prefetch*@ family of operations has the order of operations---   determined by passing around the @State#@ token.--- ---   To get a \"pure\" version of these operations, use @inlinePerformIO@ which is quite safe in this context.--- ---   It is important to note that while the prefetch operations will never change the---   answer to a pure computation, They CAN change the memory locations resident---   in a CPU cache and that may change the performance and timing characteristics---   of an application. The prefetch operations are marked has_side_effects=True---   to reflect that these operations have side effects with respect to the runtime---   performance characteristics of the resulting code. Additionally, if the prefetchValue---   operations did not have this attribute, GHC does a float out transformation that---   results in a let\/app violation, at least with the current design.---   ---        prefetchByteArray3#,-        prefetchMutableByteArray3#,-        prefetchAddr3#,-        prefetchValue3#,-        prefetchByteArray2#,-        prefetchMutableByteArray2#,-        prefetchAddr2#,-        prefetchValue2#,-        prefetchByteArray1#,-        prefetchMutableByteArray1#,-        prefetchAddr1#,-        prefetchValue1#,-        prefetchByteArray0#,-        prefetchMutableByteArray0#,-        prefetchAddr0#,-        prefetchValue0#,-) 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---}-import GHC.Types (Coercible)--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 signed integers reporting overflow.---           First member of result is the sum truncated to an @Int#@;---           second member is zero if the true sum fits in an @Int#@,---           nonzero if overflow occurred (the sum is either too large---           or too small to fit in an @Int#@).--addIntC# :: Int# -> Int# -> (# Int#,Int# #)-addIntC# = let x = x in x---- |Subtract signed integers reporting overflow.---           First member of result is the difference truncated to an @Int#@;---           second member is zero if the true difference fits in an @Int#@,---           nonzero if overflow occurred (the difference is either too large---           or too small to fit in an @Int#@).--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---- |Count leading zeros in the lower 8 bits of a word.--clz8# :: Word# -> Word#-clz8# = let x = x in x---- |Count leading zeros in the lower 16 bits of a word.--clz16# :: Word# -> Word#-clz16# = let x = x in x---- |Count leading zeros in the lower 32 bits of a word.--clz32# :: Word# -> Word#-clz32# = let x = x in x---- |Count leading zeros in a 64-bit word.--clz64# :: Word# -> Word#-clz64# = let x = x in x---- |Count leading zeros in a word.--clz# :: Word# -> Word#-clz# = let x = x in x---- |Count trailing zeros in the lower 8 bits of a word.--ctz8# :: Word# -> Word#-ctz8# = let x = x in x---- |Count trailing zeros in the lower 16 bits of a word.--ctz16# :: Word# -> Word#-ctz16# = let x = x in x---- |Count trailing zeros in the lower 32 bits of a word.--ctz32# :: Word# -> Word#-ctz32# = let x = x in x---- |Count trailing zeros in a 64-bit word.--ctz64# :: Word# -> Word#-ctz64# = let x = x in x---- |Count trailing zeros in a word.--ctz# :: Word# -> Word#-ctz# = 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---- |Decode @Double\#@ into mantissa and base-2 exponent.--decodeDouble_Int64# :: Double# -> (# Int#,Int# #)-decodeDouble_Int64# = 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---- |Given a source array, an offset into the source array, a---    destination array, an offset into the destination array, and a---    number of elements to copy, copy the elements from the source array---    to the destination array. 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---- |Given a source array, an offset into the source array, a---    destination array, an offset into the destination array, and a---    number of elements to copy, copy the elements from the source array---    to the destination array. The source and destination arrays can---    refer to the same array. 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---- |Given a source array, an offset into the source array, and a number---    of elements to copy, create a new array with the elements from the---    source array. The provided array must fully contain the specified---    range, but this is not checked.--cloneArray# :: Array# a -> Int# -> Int# -> Array# a-cloneArray# = let x = x in x---- |Given a source array, an offset into the source array, and a number---    of elements to copy, create a new array with the elements from the---    source array. The provided array must fully contain the specified---    range, but this is not checked.--cloneMutableArray# :: MutableArray# s a -> Int# -> Int# -> State# s -> (# State# s,MutableArray# s a #)-cloneMutableArray# = let x = x in x---- |Given a source array, an offset into the source array, and a number---    of elements to copy, create a new array with the elements from the---    source array. The provided array must fully contain the specified---    range, but this is not checked.--freezeArray# :: MutableArray# s a -> Int# -> Int# -> State# s -> (# State# s,Array# a #)-freezeArray# = let x = x in x---- |Given a source array, an offset into the source array, and a number---    of elements to copy, create a new array with the elements from the---    source array. The provided array must fully contain the specified---    range, 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 SmallArray# a--data SmallMutableArray# 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.--newSmallArray# :: Int# -> a -> State# s -> (# State# s,SmallMutableArray# s a #)-newSmallArray# = let x = x in x--sameSmallMutableArray# :: SmallMutableArray# s a -> SmallMutableArray# s a -> Int#-sameSmallMutableArray# = let x = x in x---- |Read from specified index of mutable array. Result is not yet evaluated.--readSmallArray# :: SmallMutableArray# s a -> Int# -> State# s -> (# State# s,a #)-readSmallArray# = let x = x in x---- |Write to specified index of mutable array.--writeSmallArray# :: SmallMutableArray# s a -> Int# -> a -> State# s -> State# s-writeSmallArray# = let x = x in x---- |Return the number of elements in the array.--sizeofSmallArray# :: SmallArray# a -> Int#-sizeofSmallArray# = let x = x in x---- |Return the number of elements in the array.--sizeofSmallMutableArray# :: SmallMutableArray# s a -> Int#-sizeofSmallMutableArray# = 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.--indexSmallArray# :: SmallArray# a -> Int# -> (# a #)-indexSmallArray# = let x = x in x---- |Make a mutable array immutable, without copying.--unsafeFreezeSmallArray# :: SmallMutableArray# s a -> State# s -> (# State# s,SmallArray# a #)-unsafeFreezeSmallArray# = let x = x in x---- |Make an immutable array mutable, without copying.--unsafeThawSmallArray# :: SmallArray# a -> State# s -> (# State# s,SmallMutableArray# s a #)-unsafeThawSmallArray# = let x = x in x---- |Given a source array, an offset into the source array, a---    destination array, an offset into the destination array, and a---    number of elements to copy, copy the elements from the source array---    to the destination array. 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.--copySmallArray# :: SmallArray# a -> Int# -> SmallMutableArray# s a -> Int# -> Int# -> State# s -> State# s-copySmallArray# = let x = x in x---- |Given a source array, an offset into the source array, a---    destination array, an offset into the destination array, and a---    number of elements to copy, copy the elements from the source array---    to the destination array. The source and destination arrays can---    refer to the same array. Both arrays must fully contain the---    specified ranges, but this is not checked.--copySmallMutableArray# :: SmallMutableArray# s a -> Int# -> SmallMutableArray# s a -> Int# -> Int# -> State# s -> State# s-copySmallMutableArray# = let x = x in x---- |Given a source array, an offset into the source array, and a number---    of elements to copy, create a new array with the elements from the---    source array. The provided array must fully contain the specified---    range, but this is not checked.--cloneSmallArray# :: SmallArray# a -> Int# -> Int# -> SmallArray# a-cloneSmallArray# = let x = x in x---- |Given a source array, an offset into the source array, and a number---    of elements to copy, create a new array with the elements from the---    source array. The provided array must fully contain the specified---    range, but this is not checked.--cloneSmallMutableArray# :: SmallMutableArray# s a -> Int# -> Int# -> State# s -> (# State# s,SmallMutableArray# s a #)-cloneSmallMutableArray# = let x = x in x---- |Given a source array, an offset into the source array, and a number---    of elements to copy, create a new array with the elements from the---    source array. The provided array must fully contain the specified---    range, but this is not checked.--freezeSmallArray# :: SmallMutableArray# s a -> Int# -> Int# -> State# s -> (# State# s,SmallArray# a #)-freezeSmallArray# = let x = x in x---- |Given a source array, an offset into the source array, and a number---    of elements to copy, create a new array with the elements from the---    source array. The provided array must fully contain the specified---    range, but this is not checked.--thawSmallArray# :: SmallArray# a -> Int# -> Int# -> State# s -> (# State# s,SmallMutableArray# s a #)-thawSmallArray# = let x = x in x---- |Unsafe, machine-level atomic compare and swap on an element within an array.--casSmallArray# :: SmallMutableArray# s a -> Int# -> a -> a -> State# s -> (# State# s,Int#,a #)-casSmallArray# = 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---- |Shrink mutable byte array to new specified size (in bytes), in---     the specified state thread. The new size argument must be less than or---     equal to the current size as reported by @sizeofMutableArray\#@.--shrinkMutableByteArray# :: MutableByteArray# s -> Int# -> State# s -> State# s-shrinkMutableByteArray# = let x = x in x---- |Resize (unpinned) mutable byte array to new specified size (in bytes).---     The returned @MutableByteArray\#@ is either the original---     @MutableByteArray\#@ resized in-place or, if not possible, a newly---     allocated (unpinned) @MutableByteArray\#@ (with the original content---     copied over).--- ---     To avoid undefined behaviour, the original @MutableByteArray\#@ shall---     not be accessed anymore after a @resizeMutableByteArray\#@ has been---     performed.  Moreover, no reference to the old one should be kept in order---     to allow garbage collection of the original @MutableByteArray\#@ in---     case a new @MutableByteArray\#@ had to be allocated.--resizeMutableByteArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,MutableByteArray# s #)-resizeMutableByteArray# = 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---- |Read 8-bit integer; offset in bytes.--indexInt8Array# :: ByteArray# -> Int# -> Int#-indexInt8Array# = let x = x in x---- |Read 16-bit integer; offset in 16-bit words.--indexInt16Array# :: ByteArray# -> Int# -> Int#-indexInt16Array# = let x = x in x---- |Read 32-bit integer; offset in 32-bit words.--indexInt32Array# :: ByteArray# -> Int# -> Int#-indexInt32Array# = let x = x in x---- |Read 64-bit integer; offset in 64-bit words.--indexInt64Array# :: ByteArray# -> Int# -> Int#-indexInt64Array# = let x = x in x---- |Read 8-bit word; offset in bytes.--indexWord8Array# :: ByteArray# -> Int# -> Word#-indexWord8Array# = let x = x in x---- |Read 16-bit word; offset in 16-bit words.--indexWord16Array# :: ByteArray# -> Int# -> Word#-indexWord16Array# = let x = x in x---- |Read 32-bit word; offset in 32-bit words.--indexWord32Array# :: ByteArray# -> Int# -> Word#-indexWord32Array# = let x = x in x---- |Read 64-bit word; offset in 64-bit words.--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---- |Read intger; offset in words.--readIntArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int# #)-readIntArray# = let x = x in x---- |Read word; offset in words.--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---- |Given an array and an offset in Int units, read an element. The---     index is assumed to be in bounds. Implies a full memory barrier.--atomicReadIntArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int# #)-atomicReadIntArray# = let x = x in x---- |Given an array and an offset in Int units, write an element. The---     index is assumed to be in bounds. Implies a full memory barrier.--atomicWriteIntArray# :: MutableByteArray# s -> Int# -> Int# -> State# s -> State# s-atomicWriteIntArray# = let x = x in x---- |Given an array, an offset in Int units, the expected old value, and---     the new value, perform an atomic compare and swap i.e. write the new---     value if the current value matches the provided old value. Returns---     the value of the element before the operation. Implies a full memory---     barrier.--casIntArray# :: MutableByteArray# s -> Int# -> Int# -> Int# -> State# s -> (# State# s,Int# #)-casIntArray# = let x = x in x---- |Given an array, and offset in Int units, and a value to add,---     atomically add the value to the element. Returns the value of the---     element before the operation. Implies a full memory barrier.--fetchAddIntArray# :: MutableByteArray# s -> Int# -> Int# -> State# s -> (# State# s,Int# #)-fetchAddIntArray# = let x = x in x---- |Given an array, and offset in Int units, and a value to subtract,---     atomically substract the value to the element. Returns the value of---     the element before the operation. Implies a full memory barrier.--fetchSubIntArray# :: MutableByteArray# s -> Int# -> Int# -> State# s -> (# State# s,Int# #)-fetchSubIntArray# = let x = x in x---- |Given an array, and offset in Int units, and a value to AND,---     atomically AND the value to the element. Returns the value of the---     element before the operation. Implies a full memory barrier.--fetchAndIntArray# :: MutableByteArray# s -> Int# -> Int# -> State# s -> (# State# s,Int# #)-fetchAndIntArray# = let x = x in x---- |Given an array, and offset in Int units, and a value to NAND,---     atomically NAND the value to the element. Returns the value of the---     element before the operation. Implies a full memory barrier.--fetchNandIntArray# :: MutableByteArray# s -> Int# -> Int# -> State# s -> (# State# s,Int# #)-fetchNandIntArray# = let x = x in x---- |Given an array, and offset in Int units, and a value to OR,---     atomically OR the value to the element. Returns the value of the---     element before the operation. Implies a full memory barrier.--fetchOrIntArray# :: MutableByteArray# s -> Int# -> Int# -> State# s -> (# State# s,Int# #)-fetchOrIntArray# = let x = x in x---- |Given an array, and offset in Int units, and a value to XOR,---     atomically XOR the value to the element. Returns the value of the---     element before the operation. Implies a full memory barrier.--fetchXorIntArray# :: MutableByteArray# s -> Int# -> Int# -> State# s -> (# State# s,Int# #)-fetchXorIntArray# = 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---- | The value of @seq a b@ is bottom if @a@ is bottom, and---      otherwise equal to @b@. @seq@ is usually introduced to---      improve performance by avoiding unneeded laziness.--- ---      A note on evaluation order: the expression @seq a b@ does---      /not/ guarantee that @a@ will be evaluated before @b@.---      The only guarantee given by @seq@ is that the both @a@---      and @b@ will be evaluated before @seq@ returns a value.---      In particular, this means that @b@ may be evaluated before---      @a@. If you need to guarantee a specific order of evaluation,---      you must use the function @pseq@ from the \"parallel\" package. --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 *))@--- ---         Above, we print kinds explicitly, as if with---         @-fprint-explicit-kinds@.--- ---         Note that @Any@ is kind polymorphic; its kind is thus---         @forall k. k@.--data Any---- | 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--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# -> State# s -> State# s-prefetchByteArray3# = let x = x in x--prefetchMutableByteArray3# :: MutableByteArray# s -> Int# -> State# s -> State# s-prefetchMutableByteArray3# = let x = x in x--prefetchAddr3# :: Addr# -> Int# -> State# s -> State# s-prefetchAddr3# = let x = x in x--prefetchValue3# :: a -> State# s -> State# s-prefetchValue3# = let x = x in x--prefetchByteArray2# :: ByteArray# -> Int# -> State# s -> State# s-prefetchByteArray2# = let x = x in x--prefetchMutableByteArray2# :: MutableByteArray# s -> Int# -> State# s -> State# s-prefetchMutableByteArray2# = let x = x in x--prefetchAddr2# :: Addr# -> Int# -> State# s -> State# s-prefetchAddr2# = let x = x in x--prefetchValue2# :: a -> State# s -> State# s-prefetchValue2# = let x = x in x--prefetchByteArray1# :: ByteArray# -> Int# -> State# s -> State# s-prefetchByteArray1# = let x = x in x--prefetchMutableByteArray1# :: MutableByteArray# s -> Int# -> State# s -> State# s-prefetchMutableByteArray1# = let x = x in x--prefetchAddr1# :: Addr# -> Int# -> State# s -> State# s-prefetchAddr1# = let x = x in x--prefetchValue1# :: a -> State# s -> State# s-prefetchValue1# = let x = x in x--prefetchByteArray0# :: ByteArray# -> Int# -> State# s -> State# s-prefetchByteArray0# = let x = x in x--prefetchMutableByteArray0# :: MutableByteArray# s -> Int# -> State# s -> State# s-prefetchMutableByteArray0# = let x = x in x--prefetchAddr0# :: Addr# -> Int# -> State# s -> State# s-prefetchAddr0# = let x = x in x--prefetchValue0# :: a -> State# s -> State# s-prefetchValue0# = let x = x in x+{-# OPTIONS_GHC -fno-warn-redundant-constraints #-}+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#,+        subWordC#,+        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#,+        clz8#,+        clz16#,+        clz32#,+        clz64#,+        clz#,+        ctz8#,+        ctz16#,+        ctz32#,+        ctz64#,+        ctz#,+        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#,+        decodeDouble_Int64#,+        +-- * 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#,+        +-- * Small Arrays+-- |Operations on @SmallArray\#@. A @SmallArray\#@ works+--          just like an @Array\#@, but with different space use and+--          performance characteristics (that are often useful with small+--          arrays). The @SmallArray\#@ and @SmallMutableArray#@+--          lack a \`card table\'. The purpose of a card table is to avoid+--          having to scan every element of the array on each GC by+--          keeping track of which elements have changed since the last GC+--          and only scanning those that have changed. So the consequence+--          of there being no card table is that the representation is+--          somewhat smaller and the writes are somewhat faster (because+--          the card table does not need to be updated). The disadvantage+--          of course is that for a @SmallMutableArray#@ the whole+--          array has to be scanned on each GC. Thus it is best suited for+--          use cases where the mutable array is not long lived, e.g.+--          where a mutable array is initialised quickly and then frozen+--          to become an immutable @SmallArray\#@.+--         +++        SmallArray#,+        SmallMutableArray#,+        newSmallArray#,+        sameSmallMutableArray#,+        readSmallArray#,+        writeSmallArray#,+        sizeofSmallArray#,+        sizeofSmallMutableArray#,+        indexSmallArray#,+        unsafeFreezeSmallArray#,+        unsafeThawSmallArray#,+        copySmallArray#,+        copySmallMutableArray#,+        cloneSmallArray#,+        cloneSmallMutableArray#,+        freezeSmallArray#,+        thawSmallArray#,+        casSmallArray#,+        +-- * 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#,+        shrinkMutableByteArray#,+        resizeMutableByteArray#,+        unsafeFreezeByteArray#,+        sizeofByteArray#,+        sizeofMutableByteArray#,+        getSizeofMutableByteArray#,+        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#,+        atomicReadIntArray#,+        atomicWriteIntArray#,+        casIntArray#,+        fetchAddIntArray#,+        fetchSubIntArray#,+        fetchAndIntArray#,+        fetchNandIntArray#,+        fetchOrIntArray#,+        fetchXorIntArray#,+        +-- * 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+-- |- Note [Strictness for mask\/unmask\/catch]+-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+-- Consider this example, which comes from GHC.IO.Handle.Internals:+--    wantReadableHandle3 f ma b st+--      = case ... of+--          DEFAULT -> case ma of MVar a -> ...+--          0#      -> maskAsynchExceptions# (\st -> case ma of MVar a -> ...)+-- The outer case just decides whether to mask exceptions, but we don\'t want+-- thereby to hide the strictness in \'ma\'!  Hence the use of strictApply1Dmd.+-- +-- For catch, we must be extra careful; see+-- Note [Exceptions and strictness] in Demand+-- -+++        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#,+        +-- * Tag to enum stuff+-- |Convert back and forth between values of enumerated types+--         and small integers.+++        dataToTag#,+        tagToEnum#,+        +-- * Bytecode operations+-- |Support for manipulating bytecode objects used by the interpreter and+--         linker.+-- +--         Bytecode objects are heap objects which represent top-level bindings and+--         contain a list of instructions and data needed by these instructions.+++        BCO#,+        addrToAny#,+        mkApUpd0#,+        newBCO#,+        unpackClosure#,+        getApStackVal#,+        +-- * Misc+-- |These aren\'t nearly as wired in as Etc...+++        getCCSOf#,+        getCurrentCCS#,+        clearCCS#,+        +-- * Etc+-- |Miscellaneous built-ins+++        Proxy#,+        proxy#,+        seq,+        Any,+        AnyK,+        unsafeCoerce#,+        traceEvent#,+        traceMarker#,+        +-- * Safe coercions+-- |+++        coerce,+        +-- * 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 @prefetch*@ family of operations has the order of operations+--   determined by passing around the @State#@ token.+-- +--   To get a \"pure\" version of these operations, use @inlinePerformIO@ which is quite safe in this context.+-- +--   It is important to note that while the prefetch operations will never change the+--   answer to a pure computation, They CAN change the memory locations resident+--   in a CPU cache and that may change the performance and timing characteristics+--   of an application. The prefetch operations are marked has_side_effects=True+--   to reflect that these operations have side effects with respect to the runtime+--   performance characteristics of the resulting code. Additionally, if the prefetchValue+--   operations did not have this attribute, GHC does a float out transformation that+--   results in a let\/app violation, at least with the current design.+--   +++        prefetchByteArray3#,+        prefetchMutableByteArray3#,+        prefetchAddr3#,+        prefetchValue3#,+        prefetchByteArray2#,+        prefetchMutableByteArray2#,+        prefetchAddr2#,+        prefetchValue2#,+        prefetchByteArray1#,+        prefetchMutableByteArray1#,+        prefetchAddr1#,+        prefetchValue1#,+        prefetchByteArray0#,+        prefetchMutableByteArray0#,+        prefetchAddr0#,+        prefetchValue0#,+) 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++-}+import GHC.Types (Coercible)+default ()+data Char#++gtChar# :: Char# -> Char# -> Int#+gtChar# = gtChar#++geChar# :: Char# -> Char# -> Int#+geChar# = geChar#++eqChar# :: Char# -> Char# -> Int#+eqChar# = eqChar#++neChar# :: Char# -> Char# -> Int#+neChar# = neChar#++ltChar# :: Char# -> Char# -> Int#+ltChar# = ltChar#++leChar# :: Char# -> Char# -> Int#+leChar# = leChar#++ord# :: Char# -> Int#+ord# = ord#++data Int#++infixl 6 +#+(+#) :: Int# -> Int# -> Int#+(+#) = (+#)++infixl 6 -#+(-#) :: Int# -> Int# -> Int#+(-#) = (-#)++-- |Low word of signed integer multiply.++infixl 7 *#+(*#) :: Int# -> Int# -> Int#+(*#) = (*#)++-- |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# = mulIntMayOflo#++-- |Rounds towards zero.++quotInt# :: Int# -> Int# -> Int#+quotInt# = quotInt#++-- |Satisfies @(quotInt\# x y) *\# y +\# (remInt\# x y) == x@.++remInt# :: Int# -> Int# -> Int#+remInt# = remInt#++-- |Rounds towards zero.++quotRemInt# :: Int# -> Int# -> (# Int#,Int# #)+quotRemInt# = quotRemInt#++andI# :: Int# -> Int# -> Int#+andI# = andI#++orI# :: Int# -> Int# -> Int#+orI# = orI#++xorI# :: Int# -> Int# -> Int#+xorI# = xorI#++notI# :: Int# -> Int#+notI# = notI#++negateInt# :: Int# -> Int#+negateInt# = negateInt#++-- |Add signed integers reporting overflow.+--           First member of result is the sum truncated to an @Int#@;+--           second member is zero if the true sum fits in an @Int#@,+--           nonzero if overflow occurred (the sum is either too large+--           or too small to fit in an @Int#@).++addIntC# :: Int# -> Int# -> (# Int#,Int# #)+addIntC# = addIntC#++-- |Subtract signed integers reporting overflow.+--           First member of result is the difference truncated to an @Int#@;+--           second member is zero if the true difference fits in an @Int#@,+--           nonzero if overflow occurred (the difference is either too large+--           or too small to fit in an @Int#@).++subIntC# :: Int# -> Int# -> (# Int#,Int# #)+subIntC# = subIntC#++infix 4 >#+(>#) :: Int# -> Int# -> Int#+(>#) = (>#)++infix 4 >=#+(>=#) :: Int# -> Int# -> Int#+(>=#) = (>=#)++infix 4 ==#+(==#) :: Int# -> Int# -> Int#+(==#) = (==#)++infix 4 /=#+(/=#) :: Int# -> Int# -> Int#+(/=#) = (/=#)++infix 4 <#+(<#) :: Int# -> Int# -> Int#+(<#) = (<#)++infix 4 <=#+(<=#) :: Int# -> Int# -> Int#+(<=#) = (<=#)++chr# :: Int# -> Char#+chr# = chr#++int2Word# :: Int# -> Word#+int2Word# = int2Word#++int2Float# :: Int# -> Float#+int2Float# = int2Float#++int2Double# :: Int# -> Double#+int2Double# = int2Double#++word2Float# :: Word# -> Float#+word2Float# = word2Float#++word2Double# :: Word# -> Double#+word2Double# = word2Double#++-- |Shift left.  Result undefined if shift amount is not+--           in the range 0 to word size - 1 inclusive.++uncheckedIShiftL# :: Int# -> Int# -> Int#+uncheckedIShiftL# = uncheckedIShiftL#++-- |Shift right arithmetic.  Result undefined if shift amount is not+--           in the range 0 to word size - 1 inclusive.++uncheckedIShiftRA# :: Int# -> Int# -> Int#+uncheckedIShiftRA# = uncheckedIShiftRA#++-- |Shift right logical.  Result undefined if shift amount is not+--           in the range 0 to word size - 1 inclusive.++uncheckedIShiftRL# :: Int# -> Int# -> Int#+uncheckedIShiftRL# = uncheckedIShiftRL#++data Word#++plusWord# :: Word# -> Word# -> Word#+plusWord# = plusWord#++-- |Subtract unsigned integers reporting overflow.+--           The first element of the pair is the result.  The second element is+--           the carry flag, which is nonzero on overflow.++subWordC# :: Word# -> Word# -> (# Word#,Int# #)+subWordC# = subWordC#++plusWord2# :: Word# -> Word# -> (# Word#,Word# #)+plusWord2# = plusWord2#++minusWord# :: Word# -> Word# -> Word#+minusWord# = minusWord#++timesWord# :: Word# -> Word# -> Word#+timesWord# = timesWord#++timesWord2# :: Word# -> Word# -> (# Word#,Word# #)+timesWord2# = timesWord2#++quotWord# :: Word# -> Word# -> Word#+quotWord# = quotWord#++remWord# :: Word# -> Word# -> Word#+remWord# = remWord#++quotRemWord# :: Word# -> Word# -> (# Word#,Word# #)+quotRemWord# = quotRemWord#++quotRemWord2# :: Word# -> Word# -> Word# -> (# Word#,Word# #)+quotRemWord2# = quotRemWord2#++and# :: Word# -> Word# -> Word#+and# = and#++or# :: Word# -> Word# -> Word#+or# = or#++xor# :: Word# -> Word# -> Word#+xor# = xor#++not# :: Word# -> Word#+not# = not#++-- |Shift left logical.   Result undefined if shift amount is not+--           in the range 0 to word size - 1 inclusive.++uncheckedShiftL# :: Word# -> Int# -> Word#+uncheckedShiftL# = uncheckedShiftL#++-- |Shift right logical.   Result undefined if shift  amount is not+--           in the range 0 to word size - 1 inclusive.++uncheckedShiftRL# :: Word# -> Int# -> Word#+uncheckedShiftRL# = uncheckedShiftRL#++word2Int# :: Word# -> Int#+word2Int# = word2Int#++gtWord# :: Word# -> Word# -> Int#+gtWord# = gtWord#++geWord# :: Word# -> Word# -> Int#+geWord# = geWord#++eqWord# :: Word# -> Word# -> Int#+eqWord# = eqWord#++neWord# :: Word# -> Word# -> Int#+neWord# = neWord#++ltWord# :: Word# -> Word# -> Int#+ltWord# = ltWord#++leWord# :: Word# -> Word# -> Int#+leWord# = leWord#++-- |Count the number of set bits in the lower 8 bits of a word.++popCnt8# :: Word# -> Word#+popCnt8# = popCnt8#++-- |Count the number of set bits in the lower 16 bits of a word.++popCnt16# :: Word# -> Word#+popCnt16# = popCnt16#++-- |Count the number of set bits in the lower 32 bits of a word.++popCnt32# :: Word# -> Word#+popCnt32# = popCnt32#++-- |Count the number of set bits in a 64-bit word.++popCnt64# :: Word# -> Word#+popCnt64# = popCnt64#++-- |Count the number of set bits in a word.++popCnt# :: Word# -> Word#+popCnt# = popCnt#++-- |Count leading zeros in the lower 8 bits of a word.++clz8# :: Word# -> Word#+clz8# = clz8#++-- |Count leading zeros in the lower 16 bits of a word.++clz16# :: Word# -> Word#+clz16# = clz16#++-- |Count leading zeros in the lower 32 bits of a word.++clz32# :: Word# -> Word#+clz32# = clz32#++-- |Count leading zeros in a 64-bit word.++clz64# :: Word# -> Word#+clz64# = clz64#++-- |Count leading zeros in a word.++clz# :: Word# -> Word#+clz# = clz#++-- |Count trailing zeros in the lower 8 bits of a word.++ctz8# :: Word# -> Word#+ctz8# = ctz8#++-- |Count trailing zeros in the lower 16 bits of a word.++ctz16# :: Word# -> Word#+ctz16# = ctz16#++-- |Count trailing zeros in the lower 32 bits of a word.++ctz32# :: Word# -> Word#+ctz32# = ctz32#++-- |Count trailing zeros in a 64-bit word.++ctz64# :: Word# -> Word#+ctz64# = ctz64#++-- |Count trailing zeros in a word.++ctz# :: Word# -> Word#+ctz# = ctz#++-- |Swap bytes in the lower 16 bits of a word. The higher bytes are undefined. ++byteSwap16# :: Word# -> Word#+byteSwap16# = byteSwap16#++-- |Swap bytes in the lower 32 bits of a word. The higher bytes are undefined. ++byteSwap32# :: Word# -> Word#+byteSwap32# = byteSwap32#++-- |Swap bytes in a 64 bits of a word.++byteSwap64# :: Word# -> Word#+byteSwap64# = byteSwap64#++-- |Swap bytes in a word.++byteSwap# :: Word# -> Word#+byteSwap# = byteSwap#++narrow8Int# :: Int# -> Int#+narrow8Int# = narrow8Int#++narrow16Int# :: Int# -> Int#+narrow16Int# = narrow16Int#++narrow32Int# :: Int# -> Int#+narrow32Int# = narrow32Int#++narrow8Word# :: Word# -> Word#+narrow8Word# = narrow8Word#++narrow16Word# :: Word# -> Word#+narrow16Word# = narrow16Word#++narrow32Word# :: Word# -> Word#+narrow32Word# = narrow32Word#++data Double#++infix 4 >##+(>##) :: Double# -> Double# -> Int#+(>##) = (>##)++infix 4 >=##+(>=##) :: Double# -> Double# -> Int#+(>=##) = (>=##)++infix 4 ==##+(==##) :: Double# -> Double# -> Int#+(==##) = (==##)++infix 4 /=##+(/=##) :: Double# -> Double# -> Int#+(/=##) = (/=##)++infix 4 <##+(<##) :: Double# -> Double# -> Int#+(<##) = (<##)++infix 4 <=##+(<=##) :: Double# -> Double# -> Int#+(<=##) = (<=##)++infixl 6 +##+(+##) :: Double# -> Double# -> Double#+(+##) = (+##)++infixl 6 -##+(-##) :: Double# -> Double# -> Double#+(-##) = (-##)++infixl 7 *##+(*##) :: Double# -> Double# -> Double#+(*##) = (*##)++infixl 7 /##+(/##) :: Double# -> Double# -> Double#+(/##) = (/##)++negateDouble# :: Double# -> Double#+negateDouble# = negateDouble#++-- |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# = double2Int#++double2Float# :: Double# -> Float#+double2Float# = double2Float#++expDouble# :: Double# -> Double#+expDouble# = expDouble#++logDouble# :: Double# -> Double#+logDouble# = logDouble#++sqrtDouble# :: Double# -> Double#+sqrtDouble# = sqrtDouble#++sinDouble# :: Double# -> Double#+sinDouble# = sinDouble#++cosDouble# :: Double# -> Double#+cosDouble# = cosDouble#++tanDouble# :: Double# -> Double#+tanDouble# = tanDouble#++asinDouble# :: Double# -> Double#+asinDouble# = asinDouble#++acosDouble# :: Double# -> Double#+acosDouble# = acosDouble#++atanDouble# :: Double# -> Double#+atanDouble# = atanDouble#++sinhDouble# :: Double# -> Double#+sinhDouble# = sinhDouble#++coshDouble# :: Double# -> Double#+coshDouble# = coshDouble#++tanhDouble# :: Double# -> Double#+tanhDouble# = tanhDouble#++-- |Exponentiation.++(**##) :: Double# -> Double# -> Double#+(**##) = (**##)++-- |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# = decodeDouble_2Int#++-- |Decode @Double\#@ into mantissa and base-2 exponent.++decodeDouble_Int64# :: Double# -> (# Int#,Int# #)+decodeDouble_Int64# = decodeDouble_Int64#++data Float#++gtFloat# :: Float# -> Float# -> Int#+gtFloat# = gtFloat#++geFloat# :: Float# -> Float# -> Int#+geFloat# = geFloat#++eqFloat# :: Float# -> Float# -> Int#+eqFloat# = eqFloat#++neFloat# :: Float# -> Float# -> Int#+neFloat# = neFloat#++ltFloat# :: Float# -> Float# -> Int#+ltFloat# = ltFloat#++leFloat# :: Float# -> Float# -> Int#+leFloat# = leFloat#++plusFloat# :: Float# -> Float# -> Float#+plusFloat# = plusFloat#++minusFloat# :: Float# -> Float# -> Float#+minusFloat# = minusFloat#++timesFloat# :: Float# -> Float# -> Float#+timesFloat# = timesFloat#++divideFloat# :: Float# -> Float# -> Float#+divideFloat# = divideFloat#++negateFloat# :: Float# -> Float#+negateFloat# = negateFloat#++-- |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# = float2Int#++expFloat# :: Float# -> Float#+expFloat# = expFloat#++logFloat# :: Float# -> Float#+logFloat# = logFloat#++sqrtFloat# :: Float# -> Float#+sqrtFloat# = sqrtFloat#++sinFloat# :: Float# -> Float#+sinFloat# = sinFloat#++cosFloat# :: Float# -> Float#+cosFloat# = cosFloat#++tanFloat# :: Float# -> Float#+tanFloat# = tanFloat#++asinFloat# :: Float# -> Float#+asinFloat# = asinFloat#++acosFloat# :: Float# -> Float#+acosFloat# = acosFloat#++atanFloat# :: Float# -> Float#+atanFloat# = atanFloat#++sinhFloat# :: Float# -> Float#+sinhFloat# = sinhFloat#++coshFloat# :: Float# -> Float#+coshFloat# = coshFloat#++tanhFloat# :: Float# -> Float#+tanhFloat# = tanhFloat#++powerFloat# :: Float# -> Float# -> Float#+powerFloat# = powerFloat#++float2Double# :: Float# -> Double#+float2Double# = float2Double#++-- |Convert to integers.+--     First @Int\#@ in result is the mantissa; second is the exponent.++decodeFloat_Int# :: Float# -> (# Int#,Int# #)+decodeFloat_Int# = decodeFloat_Int#++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# = newArray#++sameMutableArray# :: MutableArray# s a -> MutableArray# s a -> Int#+sameMutableArray# = sameMutableArray#++-- |Read from specified index of mutable array. Result is not yet evaluated.++readArray# :: MutableArray# s a -> Int# -> State# s -> (# State# s,a #)+readArray# = readArray#++-- |Write to specified index of mutable array.++writeArray# :: MutableArray# s a -> Int# -> a -> State# s -> State# s+writeArray# = writeArray#++-- |Return the number of elements in the array.++sizeofArray# :: Array# a -> Int#+sizeofArray# = sizeofArray#++-- |Return the number of elements in the array.++sizeofMutableArray# :: MutableArray# s a -> Int#+sizeofMutableArray# = sizeofMutableArray#++-- |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# = indexArray#++-- |Make a mutable array immutable, without copying.++unsafeFreezeArray# :: MutableArray# s a -> State# s -> (# State# s,Array# a #)+unsafeFreezeArray# = unsafeFreezeArray#++-- |Make an immutable array mutable, without copying.++unsafeThawArray# :: Array# a -> State# s -> (# State# s,MutableArray# s a #)+unsafeThawArray# = unsafeThawArray#++-- |Given a source array, an offset into the source array, a+--    destination array, an offset into the destination array, and a+--    number of elements to copy, copy the elements from the source array+--    to the destination array. 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# = copyArray#++-- |Given a source array, an offset into the source array, a+--    destination array, an offset into the destination array, and a+--    number of elements to copy, copy the elements from the source array+--    to the destination array. The source and destination arrays can+--    refer to the same array. 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# = copyMutableArray#++-- |Given a source array, an offset into the source array, and a number+--    of elements to copy, create a new array with the elements from the+--    source array. The provided array must fully contain the specified+--    range, but this is not checked.++cloneArray# :: Array# a -> Int# -> Int# -> Array# a+cloneArray# = cloneArray#++-- |Given a source array, an offset into the source array, and a number+--    of elements to copy, create a new array with the elements from the+--    source array. The provided array must fully contain the specified+--    range, but this is not checked.++cloneMutableArray# :: MutableArray# s a -> Int# -> Int# -> State# s -> (# State# s,MutableArray# s a #)+cloneMutableArray# = cloneMutableArray#++-- |Given a source array, an offset into the source array, and a number+--    of elements to copy, create a new array with the elements from the+--    source array. The provided array must fully contain the specified+--    range, but this is not checked.++freezeArray# :: MutableArray# s a -> Int# -> Int# -> State# s -> (# State# s,Array# a #)+freezeArray# = freezeArray#++-- |Given a source array, an offset into the source array, and a number+--    of elements to copy, create a new array with the elements from the+--    source array. The provided array must fully contain the specified+--    range, but this is not checked.++thawArray# :: Array# a -> Int# -> Int# -> State# s -> (# State# s,MutableArray# s a #)+thawArray# = thawArray#++-- |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# = casArray#++data SmallArray# a++data SmallMutableArray# 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.++newSmallArray# :: Int# -> a -> State# s -> (# State# s,SmallMutableArray# s a #)+newSmallArray# = newSmallArray#++sameSmallMutableArray# :: SmallMutableArray# s a -> SmallMutableArray# s a -> Int#+sameSmallMutableArray# = sameSmallMutableArray#++-- |Read from specified index of mutable array. Result is not yet evaluated.++readSmallArray# :: SmallMutableArray# s a -> Int# -> State# s -> (# State# s,a #)+readSmallArray# = readSmallArray#++-- |Write to specified index of mutable array.++writeSmallArray# :: SmallMutableArray# s a -> Int# -> a -> State# s -> State# s+writeSmallArray# = writeSmallArray#++-- |Return the number of elements in the array.++sizeofSmallArray# :: SmallArray# a -> Int#+sizeofSmallArray# = sizeofSmallArray#++-- |Return the number of elements in the array.++sizeofSmallMutableArray# :: SmallMutableArray# s a -> Int#+sizeofSmallMutableArray# = sizeofSmallMutableArray#++-- |Read from specified index of immutable array. Result is packaged into+--     an unboxed singleton; the result itself is not yet evaluated.++indexSmallArray# :: SmallArray# a -> Int# -> (# a #)+indexSmallArray# = indexSmallArray#++-- |Make a mutable array immutable, without copying.++unsafeFreezeSmallArray# :: SmallMutableArray# s a -> State# s -> (# State# s,SmallArray# a #)+unsafeFreezeSmallArray# = unsafeFreezeSmallArray#++-- |Make an immutable array mutable, without copying.++unsafeThawSmallArray# :: SmallArray# a -> State# s -> (# State# s,SmallMutableArray# s a #)+unsafeThawSmallArray# = unsafeThawSmallArray#++-- |Given a source array, an offset into the source array, a+--    destination array, an offset into the destination array, and a+--    number of elements to copy, copy the elements from the source array+--    to the destination array. 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.++copySmallArray# :: SmallArray# a -> Int# -> SmallMutableArray# s a -> Int# -> Int# -> State# s -> State# s+copySmallArray# = copySmallArray#++-- |Given a source array, an offset into the source array, a+--    destination array, an offset into the destination array, and a+--    number of elements to copy, copy the elements from the source array+--    to the destination array. The source and destination arrays can+--    refer to the same array. Both arrays must fully contain the+--    specified ranges, but this is not checked.++copySmallMutableArray# :: SmallMutableArray# s a -> Int# -> SmallMutableArray# s a -> Int# -> Int# -> State# s -> State# s+copySmallMutableArray# = copySmallMutableArray#++-- |Given a source array, an offset into the source array, and a number+--    of elements to copy, create a new array with the elements from the+--    source array. The provided array must fully contain the specified+--    range, but this is not checked.++cloneSmallArray# :: SmallArray# a -> Int# -> Int# -> SmallArray# a+cloneSmallArray# = cloneSmallArray#++-- |Given a source array, an offset into the source array, and a number+--    of elements to copy, create a new array with the elements from the+--    source array. The provided array must fully contain the specified+--    range, but this is not checked.++cloneSmallMutableArray# :: SmallMutableArray# s a -> Int# -> Int# -> State# s -> (# State# s,SmallMutableArray# s a #)+cloneSmallMutableArray# = cloneSmallMutableArray#++-- |Given a source array, an offset into the source array, and a number+--    of elements to copy, create a new array with the elements from the+--    source array. The provided array must fully contain the specified+--    range, but this is not checked.++freezeSmallArray# :: SmallMutableArray# s a -> Int# -> Int# -> State# s -> (# State# s,SmallArray# a #)+freezeSmallArray# = freezeSmallArray#++-- |Given a source array, an offset into the source array, and a number+--    of elements to copy, create a new array with the elements from the+--    source array. The provided array must fully contain the specified+--    range, but this is not checked.++thawSmallArray# :: SmallArray# a -> Int# -> Int# -> State# s -> (# State# s,SmallMutableArray# s a #)+thawSmallArray# = thawSmallArray#++-- |Unsafe, machine-level atomic compare and swap on an element within an array.++casSmallArray# :: SmallMutableArray# s a -> Int# -> a -> a -> State# s -> (# State# s,Int#,a #)+casSmallArray# = casSmallArray#++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# = newByteArray#++-- |Create a mutable byte array that the GC guarantees not to move.++newPinnedByteArray# :: Int# -> State# s -> (# State# s,MutableByteArray# s #)+newPinnedByteArray# = newPinnedByteArray#++-- |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# = newAlignedPinnedByteArray#++-- |Intended for use with pinned arrays; otherwise very unsafe!++byteArrayContents# :: ByteArray# -> Addr#+byteArrayContents# = byteArrayContents#++sameMutableByteArray# :: MutableByteArray# s -> MutableByteArray# s -> Int#+sameMutableByteArray# = sameMutableByteArray#++-- |Shrink mutable byte array to new specified size (in bytes), in+--     the specified state thread. The new size argument must be less than or+--     equal to the current size as reported by @sizeofMutableArray\#@.++shrinkMutableByteArray# :: MutableByteArray# s -> Int# -> State# s -> State# s+shrinkMutableByteArray# = shrinkMutableByteArray#++-- |Resize (unpinned) mutable byte array to new specified size (in bytes).+--     The returned @MutableByteArray\#@ is either the original+--     @MutableByteArray\#@ resized in-place or, if not possible, a newly+--     allocated (unpinned) @MutableByteArray\#@ (with the original content+--     copied over).+-- +--     To avoid undefined behaviour, the original @MutableByteArray\#@ shall+--     not be accessed anymore after a @resizeMutableByteArray\#@ has been+--     performed.  Moreover, no reference to the old one should be kept in order+--     to allow garbage collection of the original @MutableByteArray\#@ in+--     case a new @MutableByteArray\#@ had to be allocated.++resizeMutableByteArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,MutableByteArray# s #)+resizeMutableByteArray# = resizeMutableByteArray#++-- |Make a mutable byte array immutable, without copying.++unsafeFreezeByteArray# :: MutableByteArray# s -> State# s -> (# State# s,ByteArray# #)+unsafeFreezeByteArray# = unsafeFreezeByteArray#++-- |Return the size of the array in bytes.++sizeofByteArray# :: ByteArray# -> Int#+sizeofByteArray# = sizeofByteArray#++-- |Return the size of the array in bytes. Note that this is deprecated as it is+--    unsafe in the presence of concurrent resize operations on the same byte+--    array. See @getSizeofMutableByteArray@.++sizeofMutableByteArray# :: MutableByteArray# s -> Int#+sizeofMutableByteArray# = sizeofMutableByteArray#++-- |Return the number of elements in the array.++getSizeofMutableByteArray# :: MutableByteArray# s -> State# s -> (# State# s,Int# #)+getSizeofMutableByteArray# = getSizeofMutableByteArray#++-- |Read 8-bit character; offset in bytes.++indexCharArray# :: ByteArray# -> Int# -> Char#+indexCharArray# = indexCharArray#++-- |Read 31-bit character; offset in 4-byte words.++indexWideCharArray# :: ByteArray# -> Int# -> Char#+indexWideCharArray# = indexWideCharArray#++indexIntArray# :: ByteArray# -> Int# -> Int#+indexIntArray# = indexIntArray#++indexWordArray# :: ByteArray# -> Int# -> Word#+indexWordArray# = indexWordArray#++indexAddrArray# :: ByteArray# -> Int# -> Addr#+indexAddrArray# = indexAddrArray#++indexFloatArray# :: ByteArray# -> Int# -> Float#+indexFloatArray# = indexFloatArray#++indexDoubleArray# :: ByteArray# -> Int# -> Double#+indexDoubleArray# = indexDoubleArray#++indexStablePtrArray# :: ByteArray# -> Int# -> StablePtr# a+indexStablePtrArray# = indexStablePtrArray#++-- |Read 8-bit integer; offset in bytes.++indexInt8Array# :: ByteArray# -> Int# -> Int#+indexInt8Array# = indexInt8Array#++-- |Read 16-bit integer; offset in 16-bit words.++indexInt16Array# :: ByteArray# -> Int# -> Int#+indexInt16Array# = indexInt16Array#++-- |Read 32-bit integer; offset in 32-bit words.++indexInt32Array# :: ByteArray# -> Int# -> Int#+indexInt32Array# = indexInt32Array#++-- |Read 64-bit integer; offset in 64-bit words.++indexInt64Array# :: ByteArray# -> Int# -> Int#+indexInt64Array# = indexInt64Array#++-- |Read 8-bit word; offset in bytes.++indexWord8Array# :: ByteArray# -> Int# -> Word#+indexWord8Array# = indexWord8Array#++-- |Read 16-bit word; offset in 16-bit words.++indexWord16Array# :: ByteArray# -> Int# -> Word#+indexWord16Array# = indexWord16Array#++-- |Read 32-bit word; offset in 32-bit words.++indexWord32Array# :: ByteArray# -> Int# -> Word#+indexWord32Array# = indexWord32Array#++-- |Read 64-bit word; offset in 64-bit words.++indexWord64Array# :: ByteArray# -> Int# -> Word#+indexWord64Array# = indexWord64Array#++-- |Read 8-bit character; offset in bytes.++readCharArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Char# #)+readCharArray# = readCharArray#++-- |Read 31-bit character; offset in 4-byte words.++readWideCharArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Char# #)+readWideCharArray# = readWideCharArray#++-- |Read intger; offset in words.++readIntArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int# #)+readIntArray# = readIntArray#++-- |Read word; offset in words.++readWordArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word# #)+readWordArray# = readWordArray#++readAddrArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Addr# #)+readAddrArray# = readAddrArray#++readFloatArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Float# #)+readFloatArray# = readFloatArray#++readDoubleArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Double# #)+readDoubleArray# = readDoubleArray#++readStablePtrArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,StablePtr# a #)+readStablePtrArray# = readStablePtrArray#++readInt8Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int# #)+readInt8Array# = readInt8Array#++readInt16Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int# #)+readInt16Array# = readInt16Array#++readInt32Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int# #)+readInt32Array# = readInt32Array#++readInt64Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int# #)+readInt64Array# = readInt64Array#++readWord8Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word# #)+readWord8Array# = readWord8Array#++readWord16Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word# #)+readWord16Array# = readWord16Array#++readWord32Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word# #)+readWord32Array# = readWord32Array#++readWord64Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word# #)+readWord64Array# = readWord64Array#++-- |Write 8-bit character; offset in bytes.++writeCharArray# :: MutableByteArray# s -> Int# -> Char# -> State# s -> State# s+writeCharArray# = writeCharArray#++-- |Write 31-bit character; offset in 4-byte words.++writeWideCharArray# :: MutableByteArray# s -> Int# -> Char# -> State# s -> State# s+writeWideCharArray# = writeWideCharArray#++writeIntArray# :: MutableByteArray# s -> Int# -> Int# -> State# s -> State# s+writeIntArray# = writeIntArray#++writeWordArray# :: MutableByteArray# s -> Int# -> Word# -> State# s -> State# s+writeWordArray# = writeWordArray#++writeAddrArray# :: MutableByteArray# s -> Int# -> Addr# -> State# s -> State# s+writeAddrArray# = writeAddrArray#++writeFloatArray# :: MutableByteArray# s -> Int# -> Float# -> State# s -> State# s+writeFloatArray# = writeFloatArray#++writeDoubleArray# :: MutableByteArray# s -> Int# -> Double# -> State# s -> State# s+writeDoubleArray# = writeDoubleArray#++writeStablePtrArray# :: MutableByteArray# s -> Int# -> StablePtr# a -> State# s -> State# s+writeStablePtrArray# = writeStablePtrArray#++writeInt8Array# :: MutableByteArray# s -> Int# -> Int# -> State# s -> State# s+writeInt8Array# = writeInt8Array#++writeInt16Array# :: MutableByteArray# s -> Int# -> Int# -> State# s -> State# s+writeInt16Array# = writeInt16Array#++writeInt32Array# :: MutableByteArray# s -> Int# -> Int# -> State# s -> State# s+writeInt32Array# = writeInt32Array#++writeInt64Array# :: MutableByteArray# s -> Int# -> Int# -> State# s -> State# s+writeInt64Array# = writeInt64Array#++writeWord8Array# :: MutableByteArray# s -> Int# -> Word# -> State# s -> State# s+writeWord8Array# = writeWord8Array#++writeWord16Array# :: MutableByteArray# s -> Int# -> Word# -> State# s -> State# s+writeWord16Array# = writeWord16Array#++writeWord32Array# :: MutableByteArray# s -> Int# -> Word# -> State# s -> State# s+writeWord32Array# = writeWord32Array#++writeWord64Array# :: MutableByteArray# s -> Int# -> Word# -> State# s -> State# s+writeWord64Array# = writeWord64Array#++-- |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# = copyByteArray#++-- |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# = copyMutableByteArray#++-- |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# = copyByteArrayToAddr#++-- |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# = copyMutableByteArrayToAddr#++-- |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# = copyAddrToByteArray#++-- |Set the range of the MutableByteArray# to the specified character.++setByteArray# :: MutableByteArray# s -> Int# -> Int# -> Int# -> State# s -> State# s+setByteArray# = setByteArray#++-- |Given an array and an offset in Int units, read an element. The+--     index is assumed to be in bounds. Implies a full memory barrier.++atomicReadIntArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int# #)+atomicReadIntArray# = atomicReadIntArray#++-- |Given an array and an offset in Int units, write an element. The+--     index is assumed to be in bounds. Implies a full memory barrier.++atomicWriteIntArray# :: MutableByteArray# s -> Int# -> Int# -> State# s -> State# s+atomicWriteIntArray# = atomicWriteIntArray#++-- |Given an array, an offset in Int units, the expected old value, and+--     the new value, perform an atomic compare and swap i.e. write the new+--     value if the current value matches the provided old value. Returns+--     the value of the element before the operation. Implies a full memory+--     barrier.++casIntArray# :: MutableByteArray# s -> Int# -> Int# -> Int# -> State# s -> (# State# s,Int# #)+casIntArray# = casIntArray#++-- |Given an array, and offset in Int units, and a value to add,+--     atomically add the value to the element. Returns the value of the+--     element before the operation. Implies a full memory barrier.++fetchAddIntArray# :: MutableByteArray# s -> Int# -> Int# -> State# s -> (# State# s,Int# #)+fetchAddIntArray# = fetchAddIntArray#++-- |Given an array, and offset in Int units, and a value to subtract,+--     atomically substract the value to the element. Returns the value of+--     the element before the operation. Implies a full memory barrier.++fetchSubIntArray# :: MutableByteArray# s -> Int# -> Int# -> State# s -> (# State# s,Int# #)+fetchSubIntArray# = fetchSubIntArray#++-- |Given an array, and offset in Int units, and a value to AND,+--     atomically AND the value to the element. Returns the value of the+--     element before the operation. Implies a full memory barrier.++fetchAndIntArray# :: MutableByteArray# s -> Int# -> Int# -> State# s -> (# State# s,Int# #)+fetchAndIntArray# = fetchAndIntArray#++-- |Given an array, and offset in Int units, and a value to NAND,+--     atomically NAND the value to the element. Returns the value of the+--     element before the operation. Implies a full memory barrier.++fetchNandIntArray# :: MutableByteArray# s -> Int# -> Int# -> State# s -> (# State# s,Int# #)+fetchNandIntArray# = fetchNandIntArray#++-- |Given an array, and offset in Int units, and a value to OR,+--     atomically OR the value to the element. Returns the value of the+--     element before the operation. Implies a full memory barrier.++fetchOrIntArray# :: MutableByteArray# s -> Int# -> Int# -> State# s -> (# State# s,Int# #)+fetchOrIntArray# = fetchOrIntArray#++-- |Given an array, and offset in Int units, and a value to XOR,+--     atomically XOR the value to the element. Returns the value of the+--     element before the operation. Implies a full memory barrier.++fetchXorIntArray# :: MutableByteArray# s -> Int# -> Int# -> State# s -> (# State# s,Int# #)+fetchXorIntArray# = fetchXorIntArray#++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# = newArrayArray#++sameMutableArrayArray# :: MutableArrayArray# s -> MutableArrayArray# s -> Int#+sameMutableArrayArray# = sameMutableArrayArray#++-- |Make a mutable array of arrays immutable, without copying.++unsafeFreezeArrayArray# :: MutableArrayArray# s -> State# s -> (# State# s,ArrayArray# #)+unsafeFreezeArrayArray# = unsafeFreezeArrayArray#++-- |Return the number of elements in the array.++sizeofArrayArray# :: ArrayArray# -> Int#+sizeofArrayArray# = sizeofArrayArray#++-- |Return the number of elements in the array.++sizeofMutableArrayArray# :: MutableArrayArray# s -> Int#+sizeofMutableArrayArray# = sizeofMutableArrayArray#++indexByteArrayArray# :: ArrayArray# -> Int# -> ByteArray#+indexByteArrayArray# = indexByteArrayArray#++indexArrayArrayArray# :: ArrayArray# -> Int# -> ArrayArray#+indexArrayArrayArray# = indexArrayArrayArray#++readByteArrayArray# :: MutableArrayArray# s -> Int# -> State# s -> (# State# s,ByteArray# #)+readByteArrayArray# = readByteArrayArray#++readMutableByteArrayArray# :: MutableArrayArray# s -> Int# -> State# s -> (# State# s,MutableByteArray# s #)+readMutableByteArrayArray# = readMutableByteArrayArray#++readArrayArrayArray# :: MutableArrayArray# s -> Int# -> State# s -> (# State# s,ArrayArray# #)+readArrayArrayArray# = readArrayArrayArray#++readMutableArrayArrayArray# :: MutableArrayArray# s -> Int# -> State# s -> (# State# s,MutableArrayArray# s #)+readMutableArrayArrayArray# = readMutableArrayArrayArray#++writeByteArrayArray# :: MutableArrayArray# s -> Int# -> ByteArray# -> State# s -> State# s+writeByteArrayArray# = writeByteArrayArray#++writeMutableByteArrayArray# :: MutableArrayArray# s -> Int# -> MutableByteArray# s -> State# s -> State# s+writeMutableByteArrayArray# = writeMutableByteArrayArray#++writeArrayArrayArray# :: MutableArrayArray# s -> Int# -> ArrayArray# -> State# s -> State# s+writeArrayArrayArray# = writeArrayArrayArray#++writeMutableArrayArrayArray# :: MutableArrayArray# s -> Int# -> MutableArrayArray# s -> State# s -> State# s+writeMutableArrayArrayArray# = writeMutableArrayArrayArray#++-- |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# = copyArrayArray#++-- |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# = copyMutableArrayArray#++-- | An arbitrary machine address assumed to point outside+--          the garbage-collected heap. ++data Addr#++-- | The null address. ++nullAddr# :: Addr#+nullAddr# = nullAddr#++plusAddr# :: Addr# -> Int# -> Addr#+plusAddr# = plusAddr#++-- |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# = minusAddr#++-- |Return the remainder when the @Addr\#@ arg, treated like an @Int\#@,+--           is divided by the @Int\#@ arg.++remAddr# :: Addr# -> Int# -> Int#+remAddr# = remAddr#++-- |Coerce directly from address to int. Strongly deprecated.++addr2Int# :: Addr# -> Int#+addr2Int# = addr2Int#++-- |Coerce directly from int to address. Strongly deprecated.++int2Addr# :: Int# -> Addr#+int2Addr# = int2Addr#++gtAddr# :: Addr# -> Addr# -> Int#+gtAddr# = gtAddr#++geAddr# :: Addr# -> Addr# -> Int#+geAddr# = geAddr#++eqAddr# :: Addr# -> Addr# -> Int#+eqAddr# = eqAddr#++neAddr# :: Addr# -> Addr# -> Int#+neAddr# = neAddr#++ltAddr# :: Addr# -> Addr# -> Int#+ltAddr# = ltAddr#++leAddr# :: Addr# -> Addr# -> Int#+leAddr# = leAddr#++-- |Reads 8-bit character; offset in bytes.++indexCharOffAddr# :: Addr# -> Int# -> Char#+indexCharOffAddr# = indexCharOffAddr#++-- |Reads 31-bit character; offset in 4-byte words.++indexWideCharOffAddr# :: Addr# -> Int# -> Char#+indexWideCharOffAddr# = indexWideCharOffAddr#++indexIntOffAddr# :: Addr# -> Int# -> Int#+indexIntOffAddr# = indexIntOffAddr#++indexWordOffAddr# :: Addr# -> Int# -> Word#+indexWordOffAddr# = indexWordOffAddr#++indexAddrOffAddr# :: Addr# -> Int# -> Addr#+indexAddrOffAddr# = indexAddrOffAddr#++indexFloatOffAddr# :: Addr# -> Int# -> Float#+indexFloatOffAddr# = indexFloatOffAddr#++indexDoubleOffAddr# :: Addr# -> Int# -> Double#+indexDoubleOffAddr# = indexDoubleOffAddr#++indexStablePtrOffAddr# :: Addr# -> Int# -> StablePtr# a+indexStablePtrOffAddr# = indexStablePtrOffAddr#++indexInt8OffAddr# :: Addr# -> Int# -> Int#+indexInt8OffAddr# = indexInt8OffAddr#++indexInt16OffAddr# :: Addr# -> Int# -> Int#+indexInt16OffAddr# = indexInt16OffAddr#++indexInt32OffAddr# :: Addr# -> Int# -> Int#+indexInt32OffAddr# = indexInt32OffAddr#++indexInt64OffAddr# :: Addr# -> Int# -> Int#+indexInt64OffAddr# = indexInt64OffAddr#++indexWord8OffAddr# :: Addr# -> Int# -> Word#+indexWord8OffAddr# = indexWord8OffAddr#++indexWord16OffAddr# :: Addr# -> Int# -> Word#+indexWord16OffAddr# = indexWord16OffAddr#++indexWord32OffAddr# :: Addr# -> Int# -> Word#+indexWord32OffAddr# = indexWord32OffAddr#++indexWord64OffAddr# :: Addr# -> Int# -> Word#+indexWord64OffAddr# = indexWord64OffAddr#++-- |Reads 8-bit character; offset in bytes.++readCharOffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Char# #)+readCharOffAddr# = readCharOffAddr#++-- |Reads 31-bit character; offset in 4-byte words.++readWideCharOffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Char# #)+readWideCharOffAddr# = readWideCharOffAddr#++readIntOffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int# #)+readIntOffAddr# = readIntOffAddr#++readWordOffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word# #)+readWordOffAddr# = readWordOffAddr#++readAddrOffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Addr# #)+readAddrOffAddr# = readAddrOffAddr#++readFloatOffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Float# #)+readFloatOffAddr# = readFloatOffAddr#++readDoubleOffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Double# #)+readDoubleOffAddr# = readDoubleOffAddr#++readStablePtrOffAddr# :: Addr# -> Int# -> State# s -> (# State# s,StablePtr# a #)+readStablePtrOffAddr# = readStablePtrOffAddr#++readInt8OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int# #)+readInt8OffAddr# = readInt8OffAddr#++readInt16OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int# #)+readInt16OffAddr# = readInt16OffAddr#++readInt32OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int# #)+readInt32OffAddr# = readInt32OffAddr#++readInt64OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int# #)+readInt64OffAddr# = readInt64OffAddr#++readWord8OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word# #)+readWord8OffAddr# = readWord8OffAddr#++readWord16OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word# #)+readWord16OffAddr# = readWord16OffAddr#++readWord32OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word# #)+readWord32OffAddr# = readWord32OffAddr#++readWord64OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word# #)+readWord64OffAddr# = readWord64OffAddr#++writeCharOffAddr# :: Addr# -> Int# -> Char# -> State# s -> State# s+writeCharOffAddr# = writeCharOffAddr#++writeWideCharOffAddr# :: Addr# -> Int# -> Char# -> State# s -> State# s+writeWideCharOffAddr# = writeWideCharOffAddr#++writeIntOffAddr# :: Addr# -> Int# -> Int# -> State# s -> State# s+writeIntOffAddr# = writeIntOffAddr#++writeWordOffAddr# :: Addr# -> Int# -> Word# -> State# s -> State# s+writeWordOffAddr# = writeWordOffAddr#++writeAddrOffAddr# :: Addr# -> Int# -> Addr# -> State# s -> State# s+writeAddrOffAddr# = writeAddrOffAddr#++writeFloatOffAddr# :: Addr# -> Int# -> Float# -> State# s -> State# s+writeFloatOffAddr# = writeFloatOffAddr#++writeDoubleOffAddr# :: Addr# -> Int# -> Double# -> State# s -> State# s+writeDoubleOffAddr# = writeDoubleOffAddr#++writeStablePtrOffAddr# :: Addr# -> Int# -> StablePtr# a -> State# s -> State# s+writeStablePtrOffAddr# = writeStablePtrOffAddr#++writeInt8OffAddr# :: Addr# -> Int# -> Int# -> State# s -> State# s+writeInt8OffAddr# = writeInt8OffAddr#++writeInt16OffAddr# :: Addr# -> Int# -> Int# -> State# s -> State# s+writeInt16OffAddr# = writeInt16OffAddr#++writeInt32OffAddr# :: Addr# -> Int# -> Int# -> State# s -> State# s+writeInt32OffAddr# = writeInt32OffAddr#++writeInt64OffAddr# :: Addr# -> Int# -> Int# -> State# s -> State# s+writeInt64OffAddr# = writeInt64OffAddr#++writeWord8OffAddr# :: Addr# -> Int# -> Word# -> State# s -> State# s+writeWord8OffAddr# = writeWord8OffAddr#++writeWord16OffAddr# :: Addr# -> Int# -> Word# -> State# s -> State# s+writeWord16OffAddr# = writeWord16OffAddr#++writeWord32OffAddr# :: Addr# -> Int# -> Word# -> State# s -> State# s+writeWord32OffAddr# = writeWord32OffAddr#++writeWord64OffAddr# :: Addr# -> Int# -> Word# -> State# s -> State# s+writeWord64OffAddr# = writeWord64OffAddr#++-- |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# = newMutVar#++-- |Read contents of @MutVar\#@. Result is not yet evaluated.++readMutVar# :: MutVar# s a -> State# s -> (# State# s,a #)+readMutVar# = readMutVar#++-- |Write contents of @MutVar\#@.++writeMutVar# :: MutVar# s a -> a -> State# s -> State# s+writeMutVar# = writeMutVar#++sameMutVar# :: MutVar# s a -> MutVar# s a -> Int#+sameMutVar# = sameMutVar#++atomicModifyMutVar# :: MutVar# s a -> (a -> b) -> State# s -> (# State# s,c #)+atomicModifyMutVar# = atomicModifyMutVar#++casMutVar# :: MutVar# s a -> a -> a -> State# s -> (# State# s,Int#,a #)+casMutVar# = casMutVar#++catch# :: (State# (RealWorld) -> (# State# (RealWorld),a #)) -> (b -> State# (RealWorld) -> (# State# (RealWorld),a #)) -> State# (RealWorld) -> (# State# (RealWorld),a #)+catch# = catch#++raise# :: b -> o+raise# = raise#++raiseIO# :: a -> State# (RealWorld) -> (# State# (RealWorld),b #)+raiseIO# = raiseIO#++maskAsyncExceptions# :: (State# (RealWorld) -> (# State# (RealWorld),a #)) -> State# (RealWorld) -> (# State# (RealWorld),a #)+maskAsyncExceptions# = maskAsyncExceptions#++maskUninterruptible# :: (State# (RealWorld) -> (# State# (RealWorld),a #)) -> State# (RealWorld) -> (# State# (RealWorld),a #)+maskUninterruptible# = maskUninterruptible#++unmaskAsyncExceptions# :: (State# (RealWorld) -> (# State# (RealWorld),a #)) -> State# (RealWorld) -> (# State# (RealWorld),a #)+unmaskAsyncExceptions# = unmaskAsyncExceptions#++getMaskingState# :: State# (RealWorld) -> (# State# (RealWorld),Int# #)+getMaskingState# = getMaskingState#++data TVar# s a++atomically# :: (State# (RealWorld) -> (# State# (RealWorld),a #)) -> State# (RealWorld) -> (# State# (RealWorld),a #)+atomically# = atomically#++retry# :: State# (RealWorld) -> (# State# (RealWorld),a #)+retry# = retry#++catchRetry# :: (State# (RealWorld) -> (# State# (RealWorld),a #)) -> (State# (RealWorld) -> (# State# (RealWorld),a #)) -> State# (RealWorld) -> (# State# (RealWorld),a #)+catchRetry# = catchRetry#++catchSTM# :: (State# (RealWorld) -> (# State# (RealWorld),a #)) -> (b -> State# (RealWorld) -> (# State# (RealWorld),a #)) -> State# (RealWorld) -> (# State# (RealWorld),a #)+catchSTM# = catchSTM#++check# :: (State# (RealWorld) -> (# State# (RealWorld),a #)) -> State# (RealWorld) -> State# (RealWorld)+check# = check#++-- |Create a new @TVar\#@ holding a specified initial value.++newTVar# :: a -> State# s -> (# State# s,TVar# s a #)+newTVar# = newTVar#++-- |Read contents of @TVar\#@.  Result is not yet evaluated.++readTVar# :: TVar# s a -> State# s -> (# State# s,a #)+readTVar# = readTVar#++-- |Read contents of @TVar\#@ outside an STM transaction++readTVarIO# :: TVar# s a -> State# s -> (# State# s,a #)+readTVarIO# = readTVarIO#++-- |Write contents of @TVar\#@.++writeTVar# :: TVar# s a -> a -> State# s -> State# s+writeTVar# = writeTVar#++sameTVar# :: TVar# s a -> TVar# s a -> Int#+sameTVar# = sameTVar#++-- | 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# = newMVar#++-- |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# = takeMVar#++-- |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# = tryTakeMVar#++-- |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# = putMVar#++-- |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# = tryPutMVar#++-- |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# = readMVar#++-- |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# = tryReadMVar#++sameMVar# :: MVar# s a -> MVar# s a -> Int#+sameMVar# = sameMVar#++-- |Return 1 if @MVar\#@ is empty; 0 otherwise.++isEmptyMVar# :: MVar# s a -> State# s -> (# State# s,Int# #)+isEmptyMVar# = isEmptyMVar#++-- |Sleep specified number of microseconds.++delay# :: Int# -> State# s -> State# s+delay# = delay#++-- |Block until input is available on specified file descriptor.++waitRead# :: Int# -> State# s -> State# s+waitRead# = waitRead#++-- |Block until output is possible on specified file descriptor.++waitWrite# :: Int# -> State# s -> State# s+waitWrite# = waitWrite#++-- | @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# = fork#++forkOn# :: Int# -> a -> State# (RealWorld) -> (# State# (RealWorld),ThreadId# #)+forkOn# = forkOn#++killThread# :: ThreadId# -> a -> State# (RealWorld) -> State# (RealWorld)+killThread# = killThread#++yield# :: State# (RealWorld) -> State# (RealWorld)+yield# = yield#++myThreadId# :: State# (RealWorld) -> (# State# (RealWorld),ThreadId# #)+myThreadId# = myThreadId#++labelThread# :: ThreadId# -> Addr# -> State# (RealWorld) -> State# (RealWorld)+labelThread# = labelThread#++isCurrentThreadBound# :: State# (RealWorld) -> (# State# (RealWorld),Int# #)+isCurrentThreadBound# = isCurrentThreadBound#++noDuplicate# :: State# (RealWorld) -> State# (RealWorld)+noDuplicate# = noDuplicate#++threadStatus# :: ThreadId# -> State# (RealWorld) -> (# State# (RealWorld),Int#,Int#,Int# #)+threadStatus# = threadStatus#++data Weak# b++mkWeak# :: o -> b -> (State# (RealWorld) -> (# State# (RealWorld),c #)) -> State# (RealWorld) -> (# State# (RealWorld),Weak# b #)+mkWeak# = mkWeak#++mkWeakNoFinalizer# :: o -> b -> State# (RealWorld) -> (# State# (RealWorld),Weak# b #)+mkWeakNoFinalizer# = mkWeakNoFinalizer#++-- | @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# = addCFinalizerToWeak#++deRefWeak# :: Weak# a -> State# (RealWorld) -> (# State# (RealWorld),Int#,a #)+deRefWeak# = deRefWeak#++-- | Finalize a weak pointer. The return value is an unboxed tuple+--      containing the new state of the world and an \"unboxed Maybe\",+--      represented by an @Int#@ and a (possibly invalid) finalization+--      action. An @Int#@ of @1@ indicates that the finalizer is valid. The+--      return value @b@ from the finalizer should be ignored. ++finalizeWeak# :: Weak# a -> State# (RealWorld) -> (# State# (RealWorld),Int#,State# (RealWorld) -> (# State# (RealWorld),b #) #)+finalizeWeak# = finalizeWeak#++touch# :: o -> State# (RealWorld) -> State# (RealWorld)+touch# = touch#++data StablePtr# a++data StableName# a++makeStablePtr# :: a -> State# (RealWorld) -> (# State# (RealWorld),StablePtr# a #)+makeStablePtr# = makeStablePtr#++deRefStablePtr# :: StablePtr# a -> State# (RealWorld) -> (# State# (RealWorld),a #)+deRefStablePtr# = deRefStablePtr#++eqStablePtr# :: StablePtr# a -> StablePtr# a -> Int#+eqStablePtr# = eqStablePtr#++makeStableName# :: a -> State# (RealWorld) -> (# State# (RealWorld),StableName# a #)+makeStableName# = makeStableName#++eqStableName# :: StableName# a -> StableName# b -> Int#+eqStableName# = eqStableName#++stableNameToInt# :: StableName# a -> Int#+stableNameToInt# = stableNameToInt#++reallyUnsafePtrEquality# :: a -> a -> Int#+reallyUnsafePtrEquality# = reallyUnsafePtrEquality#++par# :: a -> Int#+par# = par#++spark# :: a -> State# s -> (# State# s,a #)+spark# = spark#++seq# :: a -> State# s -> (# State# s,a #)+seq# = seq#++getSpark# :: State# s -> (# State# s,Int#,a #)+getSpark# = getSpark#++-- | Returns the number of sparks in the local spark pool. ++numSparks# :: State# s -> (# State# s,Int# #)+numSparks# = numSparks#++dataToTag# :: a -> Int#+dataToTag# = dataToTag#++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# = addrToAny#++-- | Wrap a BCO in a @AP_UPD@ thunk which will be updated with the value of+--      the BCO when evaluated. ++mkApUpd0# :: BCO# -> (# a #)+mkApUpd0# = mkApUpd0#++-- | @newBCO\# instrs lits ptrs arity bitmap@ creates a new bytecode object. The+--      resulting object encodes a function of the given arity with the instructions+--      encoded in @instrs@, and a static reference table usage bitmap given by+--      @bitmap@. ++newBCO# :: ByteArray# -> ByteArray# -> Array# a -> Int# -> ByteArray# -> State# s -> (# State# s,BCO# #)+newBCO# = newBCO#++unpackClosure# :: a -> (# Addr#,Array# b,ByteArray# #)+unpackClosure# = unpackClosure#++getApStackVal# :: a -> Int# -> (# Int#,b #)+getApStackVal# = getApStackVal#++getCCSOf# :: a -> State# s -> (# State# s,Addr# #)+getCCSOf# = getCCSOf#++-- | 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# = getCurrentCCS#++-- | Run the supplied IO action with an empty CCS.  For example, this+--      is used by the interpreter to run an interpreted computation+--      without the call stack showing that it was invoked from GHC. ++clearCCS# :: (State# s -> (# State# s,a #)) -> State# s -> (# State# s,a #)+clearCCS# = clearCCS#++-- | 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# = proxy#++-- | The value of @seq a b@ is bottom if @a@ is bottom, and+--      otherwise equal to @b@. @seq@ is usually introduced to+--      improve performance by avoiding unneeded laziness.+-- +--      A note on evaluation order: the expression @seq a b@ does+--      /not/ guarantee that @a@ will be evaluated before @b@.+--      The only guarantee given by @seq@ is that the both @a@+--      and @b@ will be evaluated before @seq@ returns a value.+--      In particular, this means that @b@ may be evaluated before+--      @a@. If you need to guarantee a specific order of evaluation,+--      you must use the function @pseq@ from the \"parallel\" package. ++seq :: a -> b -> b+seq = seq++-- | 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 *))@+-- +--         Above, we print kinds explicitly, as if with+--         @-fprint-explicit-kinds@.+-- +--         Note that @Any@ is kind polymorphic; its kind is thus+--         @forall k. k@.++data Any++-- | 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# = unsafeCoerce#++-- | 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# = traceEvent#++-- | 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# = traceMarker#++-- | 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 = coerce++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# = broadcastInt8X16#++-- | Broadcast a scalar to all elements of a vector. ++broadcastInt16X8# :: Int# -> Int16X8#+broadcastInt16X8# = broadcastInt16X8#++-- | Broadcast a scalar to all elements of a vector. ++broadcastInt32X4# :: Int# -> Int32X4#+broadcastInt32X4# = broadcastInt32X4#++-- | Broadcast a scalar to all elements of a vector. ++broadcastInt64X2# :: Int# -> Int64X2#+broadcastInt64X2# = broadcastInt64X2#++-- | Broadcast a scalar to all elements of a vector. ++broadcastInt8X32# :: Int# -> Int8X32#+broadcastInt8X32# = broadcastInt8X32#++-- | Broadcast a scalar to all elements of a vector. ++broadcastInt16X16# :: Int# -> Int16X16#+broadcastInt16X16# = broadcastInt16X16#++-- | Broadcast a scalar to all elements of a vector. ++broadcastInt32X8# :: Int# -> Int32X8#+broadcastInt32X8# = broadcastInt32X8#++-- | Broadcast a scalar to all elements of a vector. ++broadcastInt64X4# :: Int# -> Int64X4#+broadcastInt64X4# = broadcastInt64X4#++-- | Broadcast a scalar to all elements of a vector. ++broadcastInt8X64# :: Int# -> Int8X64#+broadcastInt8X64# = broadcastInt8X64#++-- | Broadcast a scalar to all elements of a vector. ++broadcastInt16X32# :: Int# -> Int16X32#+broadcastInt16X32# = broadcastInt16X32#++-- | Broadcast a scalar to all elements of a vector. ++broadcastInt32X16# :: Int# -> Int32X16#+broadcastInt32X16# = broadcastInt32X16#++-- | Broadcast a scalar to all elements of a vector. ++broadcastInt64X8# :: Int# -> Int64X8#+broadcastInt64X8# = broadcastInt64X8#++-- | Broadcast a scalar to all elements of a vector. ++broadcastWord8X16# :: Word# -> Word8X16#+broadcastWord8X16# = broadcastWord8X16#++-- | Broadcast a scalar to all elements of a vector. ++broadcastWord16X8# :: Word# -> Word16X8#+broadcastWord16X8# = broadcastWord16X8#++-- | Broadcast a scalar to all elements of a vector. ++broadcastWord32X4# :: Word# -> Word32X4#+broadcastWord32X4# = broadcastWord32X4#++-- | Broadcast a scalar to all elements of a vector. ++broadcastWord64X2# :: Word# -> Word64X2#+broadcastWord64X2# = broadcastWord64X2#++-- | Broadcast a scalar to all elements of a vector. ++broadcastWord8X32# :: Word# -> Word8X32#+broadcastWord8X32# = broadcastWord8X32#++-- | Broadcast a scalar to all elements of a vector. ++broadcastWord16X16# :: Word# -> Word16X16#+broadcastWord16X16# = broadcastWord16X16#++-- | Broadcast a scalar to all elements of a vector. ++broadcastWord32X8# :: Word# -> Word32X8#+broadcastWord32X8# = broadcastWord32X8#++-- | Broadcast a scalar to all elements of a vector. ++broadcastWord64X4# :: Word# -> Word64X4#+broadcastWord64X4# = broadcastWord64X4#++-- | Broadcast a scalar to all elements of a vector. ++broadcastWord8X64# :: Word# -> Word8X64#+broadcastWord8X64# = broadcastWord8X64#++-- | Broadcast a scalar to all elements of a vector. ++broadcastWord16X32# :: Word# -> Word16X32#+broadcastWord16X32# = broadcastWord16X32#++-- | Broadcast a scalar to all elements of a vector. ++broadcastWord32X16# :: Word# -> Word32X16#+broadcastWord32X16# = broadcastWord32X16#++-- | Broadcast a scalar to all elements of a vector. ++broadcastWord64X8# :: Word# -> Word64X8#+broadcastWord64X8# = broadcastWord64X8#++-- | Broadcast a scalar to all elements of a vector. ++broadcastFloatX4# :: Float# -> FloatX4#+broadcastFloatX4# = broadcastFloatX4#++-- | Broadcast a scalar to all elements of a vector. ++broadcastDoubleX2# :: Double# -> DoubleX2#+broadcastDoubleX2# = broadcastDoubleX2#++-- | Broadcast a scalar to all elements of a vector. ++broadcastFloatX8# :: Float# -> FloatX8#+broadcastFloatX8# = broadcastFloatX8#++-- | Broadcast a scalar to all elements of a vector. ++broadcastDoubleX4# :: Double# -> DoubleX4#+broadcastDoubleX4# = broadcastDoubleX4#++-- | Broadcast a scalar to all elements of a vector. ++broadcastFloatX16# :: Float# -> FloatX16#+broadcastFloatX16# = broadcastFloatX16#++-- | Broadcast a scalar to all elements of a vector. ++broadcastDoubleX8# :: Double# -> DoubleX8#+broadcastDoubleX8# = broadcastDoubleX8#++-- | 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# = packInt8X16#++-- | Pack the elements of an unboxed tuple into a vector. ++packInt16X8# :: (# Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int# #) -> Int16X8#+packInt16X8# = packInt16X8#++-- | Pack the elements of an unboxed tuple into a vector. ++packInt32X4# :: (# Int#,Int#,Int#,Int# #) -> Int32X4#+packInt32X4# = packInt32X4#++-- | Pack the elements of an unboxed tuple into a vector. ++packInt64X2# :: (# Int#,Int# #) -> Int64X2#+packInt64X2# = packInt64X2#++-- | 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# = packInt8X32#++-- | 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# = packInt16X16#++-- | Pack the elements of an unboxed tuple into a vector. ++packInt32X8# :: (# Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int# #) -> Int32X8#+packInt32X8# = packInt32X8#++-- | Pack the elements of an unboxed tuple into a vector. ++packInt64X4# :: (# Int#,Int#,Int#,Int# #) -> Int64X4#+packInt64X4# = packInt64X4#++-- | 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# = packInt8X64#++-- | 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# = packInt16X32#++-- | 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# = packInt32X16#++-- | Pack the elements of an unboxed tuple into a vector. ++packInt64X8# :: (# Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int# #) -> Int64X8#+packInt64X8# = packInt64X8#++-- | 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# = packWord8X16#++-- | Pack the elements of an unboxed tuple into a vector. ++packWord16X8# :: (# Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word# #) -> Word16X8#+packWord16X8# = packWord16X8#++-- | Pack the elements of an unboxed tuple into a vector. ++packWord32X4# :: (# Word#,Word#,Word#,Word# #) -> Word32X4#+packWord32X4# = packWord32X4#++-- | Pack the elements of an unboxed tuple into a vector. ++packWord64X2# :: (# Word#,Word# #) -> Word64X2#+packWord64X2# = packWord64X2#++-- | 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# = packWord8X32#++-- | 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# = packWord16X16#++-- | Pack the elements of an unboxed tuple into a vector. ++packWord32X8# :: (# Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word# #) -> Word32X8#+packWord32X8# = packWord32X8#++-- | Pack the elements of an unboxed tuple into a vector. ++packWord64X4# :: (# Word#,Word#,Word#,Word# #) -> Word64X4#+packWord64X4# = packWord64X4#++-- | 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# = packWord8X64#++-- | 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# = packWord16X32#++-- | 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# = packWord32X16#++-- | Pack the elements of an unboxed tuple into a vector. ++packWord64X8# :: (# Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word# #) -> Word64X8#+packWord64X8# = packWord64X8#++-- | Pack the elements of an unboxed tuple into a vector. ++packFloatX4# :: (# Float#,Float#,Float#,Float# #) -> FloatX4#+packFloatX4# = packFloatX4#++-- | Pack the elements of an unboxed tuple into a vector. ++packDoubleX2# :: (# Double#,Double# #) -> DoubleX2#+packDoubleX2# = packDoubleX2#++-- | Pack the elements of an unboxed tuple into a vector. ++packFloatX8# :: (# Float#,Float#,Float#,Float#,Float#,Float#,Float#,Float# #) -> FloatX8#+packFloatX8# = packFloatX8#++-- | Pack the elements of an unboxed tuple into a vector. ++packDoubleX4# :: (# Double#,Double#,Double#,Double# #) -> DoubleX4#+packDoubleX4# = packDoubleX4#++-- | 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# = packFloatX16#++-- | Pack the elements of an unboxed tuple into a vector. ++packDoubleX8# :: (# Double#,Double#,Double#,Double#,Double#,Double#,Double#,Double# #) -> DoubleX8#+packDoubleX8# = packDoubleX8#++-- | 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# = unpackInt8X16#++-- | Unpack the elements of a vector into an unboxed tuple. #++unpackInt16X8# :: Int16X8# -> (# Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int# #)+unpackInt16X8# = unpackInt16X8#++-- | Unpack the elements of a vector into an unboxed tuple. #++unpackInt32X4# :: Int32X4# -> (# Int#,Int#,Int#,Int# #)+unpackInt32X4# = unpackInt32X4#++-- | Unpack the elements of a vector into an unboxed tuple. #++unpackInt64X2# :: Int64X2# -> (# Int#,Int# #)+unpackInt64X2# = unpackInt64X2#++-- | 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# = unpackInt8X32#++-- | 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# = unpackInt16X16#++-- | Unpack the elements of a vector into an unboxed tuple. #++unpackInt32X8# :: Int32X8# -> (# Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int# #)+unpackInt32X8# = unpackInt32X8#++-- | Unpack the elements of a vector into an unboxed tuple. #++unpackInt64X4# :: Int64X4# -> (# Int#,Int#,Int#,Int# #)+unpackInt64X4# = unpackInt64X4#++-- | 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# = unpackInt8X64#++-- | 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# = unpackInt16X32#++-- | 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# = unpackInt32X16#++-- | Unpack the elements of a vector into an unboxed tuple. #++unpackInt64X8# :: Int64X8# -> (# Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int# #)+unpackInt64X8# = unpackInt64X8#++-- | 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# = unpackWord8X16#++-- | Unpack the elements of a vector into an unboxed tuple. #++unpackWord16X8# :: Word16X8# -> (# Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word# #)+unpackWord16X8# = unpackWord16X8#++-- | Unpack the elements of a vector into an unboxed tuple. #++unpackWord32X4# :: Word32X4# -> (# Word#,Word#,Word#,Word# #)+unpackWord32X4# = unpackWord32X4#++-- | Unpack the elements of a vector into an unboxed tuple. #++unpackWord64X2# :: Word64X2# -> (# Word#,Word# #)+unpackWord64X2# = unpackWord64X2#++-- | 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# = unpackWord8X32#++-- | 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# = unpackWord16X16#++-- | Unpack the elements of a vector into an unboxed tuple. #++unpackWord32X8# :: Word32X8# -> (# Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word# #)+unpackWord32X8# = unpackWord32X8#++-- | Unpack the elements of a vector into an unboxed tuple. #++unpackWord64X4# :: Word64X4# -> (# Word#,Word#,Word#,Word# #)+unpackWord64X4# = unpackWord64X4#++-- | 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# = unpackWord8X64#++-- | 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# = unpackWord16X32#++-- | 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# = unpackWord32X16#++-- | Unpack the elements of a vector into an unboxed tuple. #++unpackWord64X8# :: Word64X8# -> (# Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word# #)+unpackWord64X8# = unpackWord64X8#++-- | Unpack the elements of a vector into an unboxed tuple. #++unpackFloatX4# :: FloatX4# -> (# Float#,Float#,Float#,Float# #)+unpackFloatX4# = unpackFloatX4#++-- | Unpack the elements of a vector into an unboxed tuple. #++unpackDoubleX2# :: DoubleX2# -> (# Double#,Double# #)+unpackDoubleX2# = unpackDoubleX2#++-- | Unpack the elements of a vector into an unboxed tuple. #++unpackFloatX8# :: FloatX8# -> (# Float#,Float#,Float#,Float#,Float#,Float#,Float#,Float# #)+unpackFloatX8# = unpackFloatX8#++-- | Unpack the elements of a vector into an unboxed tuple. #++unpackDoubleX4# :: DoubleX4# -> (# Double#,Double#,Double#,Double# #)+unpackDoubleX4# = unpackDoubleX4#++-- | 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# = unpackFloatX16#++-- | Unpack the elements of a vector into an unboxed tuple. #++unpackDoubleX8# :: DoubleX8# -> (# Double#,Double#,Double#,Double#,Double#,Double#,Double#,Double# #)+unpackDoubleX8# = unpackDoubleX8#++-- | Insert a scalar at the given position in a vector. ++insertInt8X16# :: Int8X16# -> Int# -> Int# -> Int8X16#+insertInt8X16# = insertInt8X16#++-- | Insert a scalar at the given position in a vector. ++insertInt16X8# :: Int16X8# -> Int# -> Int# -> Int16X8#+insertInt16X8# = insertInt16X8#++-- | Insert a scalar at the given position in a vector. ++insertInt32X4# :: Int32X4# -> Int# -> Int# -> Int32X4#+insertInt32X4# = insertInt32X4#++-- | Insert a scalar at the given position in a vector. ++insertInt64X2# :: Int64X2# -> Int# -> Int# -> Int64X2#+insertInt64X2# = insertInt64X2#++-- | Insert a scalar at the given position in a vector. ++insertInt8X32# :: Int8X32# -> Int# -> Int# -> Int8X32#+insertInt8X32# = insertInt8X32#++-- | Insert a scalar at the given position in a vector. ++insertInt16X16# :: Int16X16# -> Int# -> Int# -> Int16X16#+insertInt16X16# = insertInt16X16#++-- | Insert a scalar at the given position in a vector. ++insertInt32X8# :: Int32X8# -> Int# -> Int# -> Int32X8#+insertInt32X8# = insertInt32X8#++-- | Insert a scalar at the given position in a vector. ++insertInt64X4# :: Int64X4# -> Int# -> Int# -> Int64X4#+insertInt64X4# = insertInt64X4#++-- | Insert a scalar at the given position in a vector. ++insertInt8X64# :: Int8X64# -> Int# -> Int# -> Int8X64#+insertInt8X64# = insertInt8X64#++-- | Insert a scalar at the given position in a vector. ++insertInt16X32# :: Int16X32# -> Int# -> Int# -> Int16X32#+insertInt16X32# = insertInt16X32#++-- | Insert a scalar at the given position in a vector. ++insertInt32X16# :: Int32X16# -> Int# -> Int# -> Int32X16#+insertInt32X16# = insertInt32X16#++-- | Insert a scalar at the given position in a vector. ++insertInt64X8# :: Int64X8# -> Int# -> Int# -> Int64X8#+insertInt64X8# = insertInt64X8#++-- | Insert a scalar at the given position in a vector. ++insertWord8X16# :: Word8X16# -> Word# -> Int# -> Word8X16#+insertWord8X16# = insertWord8X16#++-- | Insert a scalar at the given position in a vector. ++insertWord16X8# :: Word16X8# -> Word# -> Int# -> Word16X8#+insertWord16X8# = insertWord16X8#++-- | Insert a scalar at the given position in a vector. ++insertWord32X4# :: Word32X4# -> Word# -> Int# -> Word32X4#+insertWord32X4# = insertWord32X4#++-- | Insert a scalar at the given position in a vector. ++insertWord64X2# :: Word64X2# -> Word# -> Int# -> Word64X2#+insertWord64X2# = insertWord64X2#++-- | Insert a scalar at the given position in a vector. ++insertWord8X32# :: Word8X32# -> Word# -> Int# -> Word8X32#+insertWord8X32# = insertWord8X32#++-- | Insert a scalar at the given position in a vector. ++insertWord16X16# :: Word16X16# -> Word# -> Int# -> Word16X16#+insertWord16X16# = insertWord16X16#++-- | Insert a scalar at the given position in a vector. ++insertWord32X8# :: Word32X8# -> Word# -> Int# -> Word32X8#+insertWord32X8# = insertWord32X8#++-- | Insert a scalar at the given position in a vector. ++insertWord64X4# :: Word64X4# -> Word# -> Int# -> Word64X4#+insertWord64X4# = insertWord64X4#++-- | Insert a scalar at the given position in a vector. ++insertWord8X64# :: Word8X64# -> Word# -> Int# -> Word8X64#+insertWord8X64# = insertWord8X64#++-- | Insert a scalar at the given position in a vector. ++insertWord16X32# :: Word16X32# -> Word# -> Int# -> Word16X32#+insertWord16X32# = insertWord16X32#++-- | Insert a scalar at the given position in a vector. ++insertWord32X16# :: Word32X16# -> Word# -> Int# -> Word32X16#+insertWord32X16# = insertWord32X16#++-- | Insert a scalar at the given position in a vector. ++insertWord64X8# :: Word64X8# -> Word# -> Int# -> Word64X8#+insertWord64X8# = insertWord64X8#++-- | Insert a scalar at the given position in a vector. ++insertFloatX4# :: FloatX4# -> Float# -> Int# -> FloatX4#+insertFloatX4# = insertFloatX4#++-- | Insert a scalar at the given position in a vector. ++insertDoubleX2# :: DoubleX2# -> Double# -> Int# -> DoubleX2#+insertDoubleX2# = insertDoubleX2#++-- | Insert a scalar at the given position in a vector. ++insertFloatX8# :: FloatX8# -> Float# -> Int# -> FloatX8#+insertFloatX8# = insertFloatX8#++-- | Insert a scalar at the given position in a vector. ++insertDoubleX4# :: DoubleX4# -> Double# -> Int# -> DoubleX4#+insertDoubleX4# = insertDoubleX4#++-- | Insert a scalar at the given position in a vector. ++insertFloatX16# :: FloatX16# -> Float# -> Int# -> FloatX16#+insertFloatX16# = insertFloatX16#++-- | Insert a scalar at the given position in a vector. ++insertDoubleX8# :: DoubleX8# -> Double# -> Int# -> DoubleX8#+insertDoubleX8# = insertDoubleX8#++-- | Add two vectors element-wise. ++plusInt8X16# :: Int8X16# -> Int8X16# -> Int8X16#+plusInt8X16# = plusInt8X16#++-- | Add two vectors element-wise. ++plusInt16X8# :: Int16X8# -> Int16X8# -> Int16X8#+plusInt16X8# = plusInt16X8#++-- | Add two vectors element-wise. ++plusInt32X4# :: Int32X4# -> Int32X4# -> Int32X4#+plusInt32X4# = plusInt32X4#++-- | Add two vectors element-wise. ++plusInt64X2# :: Int64X2# -> Int64X2# -> Int64X2#+plusInt64X2# = plusInt64X2#++-- | Add two vectors element-wise. ++plusInt8X32# :: Int8X32# -> Int8X32# -> Int8X32#+plusInt8X32# = plusInt8X32#++-- | Add two vectors element-wise. ++plusInt16X16# :: Int16X16# -> Int16X16# -> Int16X16#+plusInt16X16# = plusInt16X16#++-- | Add two vectors element-wise. ++plusInt32X8# :: Int32X8# -> Int32X8# -> Int32X8#+plusInt32X8# = plusInt32X8#++-- | Add two vectors element-wise. ++plusInt64X4# :: Int64X4# -> Int64X4# -> Int64X4#+plusInt64X4# = plusInt64X4#++-- | Add two vectors element-wise. ++plusInt8X64# :: Int8X64# -> Int8X64# -> Int8X64#+plusInt8X64# = plusInt8X64#++-- | Add two vectors element-wise. ++plusInt16X32# :: Int16X32# -> Int16X32# -> Int16X32#+plusInt16X32# = plusInt16X32#++-- | Add two vectors element-wise. ++plusInt32X16# :: Int32X16# -> Int32X16# -> Int32X16#+plusInt32X16# = plusInt32X16#++-- | Add two vectors element-wise. ++plusInt64X8# :: Int64X8# -> Int64X8# -> Int64X8#+plusInt64X8# = plusInt64X8#++-- | Add two vectors element-wise. ++plusWord8X16# :: Word8X16# -> Word8X16# -> Word8X16#+plusWord8X16# = plusWord8X16#++-- | Add two vectors element-wise. ++plusWord16X8# :: Word16X8# -> Word16X8# -> Word16X8#+plusWord16X8# = plusWord16X8#++-- | Add two vectors element-wise. ++plusWord32X4# :: Word32X4# -> Word32X4# -> Word32X4#+plusWord32X4# = plusWord32X4#++-- | Add two vectors element-wise. ++plusWord64X2# :: Word64X2# -> Word64X2# -> Word64X2#+plusWord64X2# = plusWord64X2#++-- | Add two vectors element-wise. ++plusWord8X32# :: Word8X32# -> Word8X32# -> Word8X32#+plusWord8X32# = plusWord8X32#++-- | Add two vectors element-wise. ++plusWord16X16# :: Word16X16# -> Word16X16# -> Word16X16#+plusWord16X16# = plusWord16X16#++-- | Add two vectors element-wise. ++plusWord32X8# :: Word32X8# -> Word32X8# -> Word32X8#+plusWord32X8# = plusWord32X8#++-- | Add two vectors element-wise. ++plusWord64X4# :: Word64X4# -> Word64X4# -> Word64X4#+plusWord64X4# = plusWord64X4#++-- | Add two vectors element-wise. ++plusWord8X64# :: Word8X64# -> Word8X64# -> Word8X64#+plusWord8X64# = plusWord8X64#++-- | Add two vectors element-wise. ++plusWord16X32# :: Word16X32# -> Word16X32# -> Word16X32#+plusWord16X32# = plusWord16X32#++-- | Add two vectors element-wise. ++plusWord32X16# :: Word32X16# -> Word32X16# -> Word32X16#+plusWord32X16# = plusWord32X16#++-- | Add two vectors element-wise. ++plusWord64X8# :: Word64X8# -> Word64X8# -> Word64X8#+plusWord64X8# = plusWord64X8#++-- | Add two vectors element-wise. ++plusFloatX4# :: FloatX4# -> FloatX4# -> FloatX4#+plusFloatX4# = plusFloatX4#++-- | Add two vectors element-wise. ++plusDoubleX2# :: DoubleX2# -> DoubleX2# -> DoubleX2#+plusDoubleX2# = plusDoubleX2#++-- | Add two vectors element-wise. ++plusFloatX8# :: FloatX8# -> FloatX8# -> FloatX8#+plusFloatX8# = plusFloatX8#++-- | Add two vectors element-wise. ++plusDoubleX4# :: DoubleX4# -> DoubleX4# -> DoubleX4#+plusDoubleX4# = plusDoubleX4#++-- | Add two vectors element-wise. ++plusFloatX16# :: FloatX16# -> FloatX16# -> FloatX16#+plusFloatX16# = plusFloatX16#++-- | Add two vectors element-wise. ++plusDoubleX8# :: DoubleX8# -> DoubleX8# -> DoubleX8#+plusDoubleX8# = plusDoubleX8#++-- | Subtract two vectors element-wise. ++minusInt8X16# :: Int8X16# -> Int8X16# -> Int8X16#+minusInt8X16# = minusInt8X16#++-- | Subtract two vectors element-wise. ++minusInt16X8# :: Int16X8# -> Int16X8# -> Int16X8#+minusInt16X8# = minusInt16X8#++-- | Subtract two vectors element-wise. ++minusInt32X4# :: Int32X4# -> Int32X4# -> Int32X4#+minusInt32X4# = minusInt32X4#++-- | Subtract two vectors element-wise. ++minusInt64X2# :: Int64X2# -> Int64X2# -> Int64X2#+minusInt64X2# = minusInt64X2#++-- | Subtract two vectors element-wise. ++minusInt8X32# :: Int8X32# -> Int8X32# -> Int8X32#+minusInt8X32# = minusInt8X32#++-- | Subtract two vectors element-wise. ++minusInt16X16# :: Int16X16# -> Int16X16# -> Int16X16#+minusInt16X16# = minusInt16X16#++-- | Subtract two vectors element-wise. ++minusInt32X8# :: Int32X8# -> Int32X8# -> Int32X8#+minusInt32X8# = minusInt32X8#++-- | Subtract two vectors element-wise. ++minusInt64X4# :: Int64X4# -> Int64X4# -> Int64X4#+minusInt64X4# = minusInt64X4#++-- | Subtract two vectors element-wise. ++minusInt8X64# :: Int8X64# -> Int8X64# -> Int8X64#+minusInt8X64# = minusInt8X64#++-- | Subtract two vectors element-wise. ++minusInt16X32# :: Int16X32# -> Int16X32# -> Int16X32#+minusInt16X32# = minusInt16X32#++-- | Subtract two vectors element-wise. ++minusInt32X16# :: Int32X16# -> Int32X16# -> Int32X16#+minusInt32X16# = minusInt32X16#++-- | Subtract two vectors element-wise. ++minusInt64X8# :: Int64X8# -> Int64X8# -> Int64X8#+minusInt64X8# = minusInt64X8#++-- | Subtract two vectors element-wise. ++minusWord8X16# :: Word8X16# -> Word8X16# -> Word8X16#+minusWord8X16# = minusWord8X16#++-- | Subtract two vectors element-wise. ++minusWord16X8# :: Word16X8# -> Word16X8# -> Word16X8#+minusWord16X8# = minusWord16X8#++-- | Subtract two vectors element-wise. ++minusWord32X4# :: Word32X4# -> Word32X4# -> Word32X4#+minusWord32X4# = minusWord32X4#++-- | Subtract two vectors element-wise. ++minusWord64X2# :: Word64X2# -> Word64X2# -> Word64X2#+minusWord64X2# = minusWord64X2#++-- | Subtract two vectors element-wise. ++minusWord8X32# :: Word8X32# -> Word8X32# -> Word8X32#+minusWord8X32# = minusWord8X32#++-- | Subtract two vectors element-wise. ++minusWord16X16# :: Word16X16# -> Word16X16# -> Word16X16#+minusWord16X16# = minusWord16X16#++-- | Subtract two vectors element-wise. ++minusWord32X8# :: Word32X8# -> Word32X8# -> Word32X8#+minusWord32X8# = minusWord32X8#++-- | Subtract two vectors element-wise. ++minusWord64X4# :: Word64X4# -> Word64X4# -> Word64X4#+minusWord64X4# = minusWord64X4#++-- | Subtract two vectors element-wise. ++minusWord8X64# :: Word8X64# -> Word8X64# -> Word8X64#+minusWord8X64# = minusWord8X64#++-- | Subtract two vectors element-wise. ++minusWord16X32# :: Word16X32# -> Word16X32# -> Word16X32#+minusWord16X32# = minusWord16X32#++-- | Subtract two vectors element-wise. ++minusWord32X16# :: Word32X16# -> Word32X16# -> Word32X16#+minusWord32X16# = minusWord32X16#++-- | Subtract two vectors element-wise. ++minusWord64X8# :: Word64X8# -> Word64X8# -> Word64X8#+minusWord64X8# = minusWord64X8#++-- | Subtract two vectors element-wise. ++minusFloatX4# :: FloatX4# -> FloatX4# -> FloatX4#+minusFloatX4# = minusFloatX4#++-- | Subtract two vectors element-wise. ++minusDoubleX2# :: DoubleX2# -> DoubleX2# -> DoubleX2#+minusDoubleX2# = minusDoubleX2#++-- | Subtract two vectors element-wise. ++minusFloatX8# :: FloatX8# -> FloatX8# -> FloatX8#+minusFloatX8# = minusFloatX8#++-- | Subtract two vectors element-wise. ++minusDoubleX4# :: DoubleX4# -> DoubleX4# -> DoubleX4#+minusDoubleX4# = minusDoubleX4#++-- | Subtract two vectors element-wise. ++minusFloatX16# :: FloatX16# -> FloatX16# -> FloatX16#+minusFloatX16# = minusFloatX16#++-- | Subtract two vectors element-wise. ++minusDoubleX8# :: DoubleX8# -> DoubleX8# -> DoubleX8#+minusDoubleX8# = minusDoubleX8#++-- | Multiply two vectors element-wise. ++timesInt8X16# :: Int8X16# -> Int8X16# -> Int8X16#+timesInt8X16# = timesInt8X16#++-- | Multiply two vectors element-wise. ++timesInt16X8# :: Int16X8# -> Int16X8# -> Int16X8#+timesInt16X8# = timesInt16X8#++-- | Multiply two vectors element-wise. ++timesInt32X4# :: Int32X4# -> Int32X4# -> Int32X4#+timesInt32X4# = timesInt32X4#++-- | Multiply two vectors element-wise. ++timesInt64X2# :: Int64X2# -> Int64X2# -> Int64X2#+timesInt64X2# = timesInt64X2#++-- | Multiply two vectors element-wise. ++timesInt8X32# :: Int8X32# -> Int8X32# -> Int8X32#+timesInt8X32# = timesInt8X32#++-- | Multiply two vectors element-wise. ++timesInt16X16# :: Int16X16# -> Int16X16# -> Int16X16#+timesInt16X16# = timesInt16X16#++-- | Multiply two vectors element-wise. ++timesInt32X8# :: Int32X8# -> Int32X8# -> Int32X8#+timesInt32X8# = timesInt32X8#++-- | Multiply two vectors element-wise. ++timesInt64X4# :: Int64X4# -> Int64X4# -> Int64X4#+timesInt64X4# = timesInt64X4#++-- | Multiply two vectors element-wise. ++timesInt8X64# :: Int8X64# -> Int8X64# -> Int8X64#+timesInt8X64# = timesInt8X64#++-- | Multiply two vectors element-wise. ++timesInt16X32# :: Int16X32# -> Int16X32# -> Int16X32#+timesInt16X32# = timesInt16X32#++-- | Multiply two vectors element-wise. ++timesInt32X16# :: Int32X16# -> Int32X16# -> Int32X16#+timesInt32X16# = timesInt32X16#++-- | Multiply two vectors element-wise. ++timesInt64X8# :: Int64X8# -> Int64X8# -> Int64X8#+timesInt64X8# = timesInt64X8#++-- | Multiply two vectors element-wise. ++timesWord8X16# :: Word8X16# -> Word8X16# -> Word8X16#+timesWord8X16# = timesWord8X16#++-- | Multiply two vectors element-wise. ++timesWord16X8# :: Word16X8# -> Word16X8# -> Word16X8#+timesWord16X8# = timesWord16X8#++-- | Multiply two vectors element-wise. ++timesWord32X4# :: Word32X4# -> Word32X4# -> Word32X4#+timesWord32X4# = timesWord32X4#++-- | Multiply two vectors element-wise. ++timesWord64X2# :: Word64X2# -> Word64X2# -> Word64X2#+timesWord64X2# = timesWord64X2#++-- | Multiply two vectors element-wise. ++timesWord8X32# :: Word8X32# -> Word8X32# -> Word8X32#+timesWord8X32# = timesWord8X32#++-- | Multiply two vectors element-wise. ++timesWord16X16# :: Word16X16# -> Word16X16# -> Word16X16#+timesWord16X16# = timesWord16X16#++-- | Multiply two vectors element-wise. ++timesWord32X8# :: Word32X8# -> Word32X8# -> Word32X8#+timesWord32X8# = timesWord32X8#++-- | Multiply two vectors element-wise. ++timesWord64X4# :: Word64X4# -> Word64X4# -> Word64X4#+timesWord64X4# = timesWord64X4#++-- | Multiply two vectors element-wise. ++timesWord8X64# :: Word8X64# -> Word8X64# -> Word8X64#+timesWord8X64# = timesWord8X64#++-- | Multiply two vectors element-wise. ++timesWord16X32# :: Word16X32# -> Word16X32# -> Word16X32#+timesWord16X32# = timesWord16X32#++-- | Multiply two vectors element-wise. ++timesWord32X16# :: Word32X16# -> Word32X16# -> Word32X16#+timesWord32X16# = timesWord32X16#++-- | Multiply two vectors element-wise. ++timesWord64X8# :: Word64X8# -> Word64X8# -> Word64X8#+timesWord64X8# = timesWord64X8#++-- | Multiply two vectors element-wise. ++timesFloatX4# :: FloatX4# -> FloatX4# -> FloatX4#+timesFloatX4# = timesFloatX4#++-- | Multiply two vectors element-wise. ++timesDoubleX2# :: DoubleX2# -> DoubleX2# -> DoubleX2#+timesDoubleX2# = timesDoubleX2#++-- | Multiply two vectors element-wise. ++timesFloatX8# :: FloatX8# -> FloatX8# -> FloatX8#+timesFloatX8# = timesFloatX8#++-- | Multiply two vectors element-wise. ++timesDoubleX4# :: DoubleX4# -> DoubleX4# -> DoubleX4#+timesDoubleX4# = timesDoubleX4#++-- | Multiply two vectors element-wise. ++timesFloatX16# :: FloatX16# -> FloatX16# -> FloatX16#+timesFloatX16# = timesFloatX16#++-- | Multiply two vectors element-wise. ++timesDoubleX8# :: DoubleX8# -> DoubleX8# -> DoubleX8#+timesDoubleX8# = timesDoubleX8#++-- | Divide two vectors element-wise. ++divideFloatX4# :: FloatX4# -> FloatX4# -> FloatX4#+divideFloatX4# = divideFloatX4#++-- | Divide two vectors element-wise. ++divideDoubleX2# :: DoubleX2# -> DoubleX2# -> DoubleX2#+divideDoubleX2# = divideDoubleX2#++-- | Divide two vectors element-wise. ++divideFloatX8# :: FloatX8# -> FloatX8# -> FloatX8#+divideFloatX8# = divideFloatX8#++-- | Divide two vectors element-wise. ++divideDoubleX4# :: DoubleX4# -> DoubleX4# -> DoubleX4#+divideDoubleX4# = divideDoubleX4#++-- | Divide two vectors element-wise. ++divideFloatX16# :: FloatX16# -> FloatX16# -> FloatX16#+divideFloatX16# = divideFloatX16#++-- | Divide two vectors element-wise. ++divideDoubleX8# :: DoubleX8# -> DoubleX8# -> DoubleX8#+divideDoubleX8# = divideDoubleX8#++-- | Rounds towards zero element-wise. ++quotInt8X16# :: Int8X16# -> Int8X16# -> Int8X16#+quotInt8X16# = quotInt8X16#++-- | Rounds towards zero element-wise. ++quotInt16X8# :: Int16X8# -> Int16X8# -> Int16X8#+quotInt16X8# = quotInt16X8#++-- | Rounds towards zero element-wise. ++quotInt32X4# :: Int32X4# -> Int32X4# -> Int32X4#+quotInt32X4# = quotInt32X4#++-- | Rounds towards zero element-wise. ++quotInt64X2# :: Int64X2# -> Int64X2# -> Int64X2#+quotInt64X2# = quotInt64X2#++-- | Rounds towards zero element-wise. ++quotInt8X32# :: Int8X32# -> Int8X32# -> Int8X32#+quotInt8X32# = quotInt8X32#++-- | Rounds towards zero element-wise. ++quotInt16X16# :: Int16X16# -> Int16X16# -> Int16X16#+quotInt16X16# = quotInt16X16#++-- | Rounds towards zero element-wise. ++quotInt32X8# :: Int32X8# -> Int32X8# -> Int32X8#+quotInt32X8# = quotInt32X8#++-- | Rounds towards zero element-wise. ++quotInt64X4# :: Int64X4# -> Int64X4# -> Int64X4#+quotInt64X4# = quotInt64X4#++-- | Rounds towards zero element-wise. ++quotInt8X64# :: Int8X64# -> Int8X64# -> Int8X64#+quotInt8X64# = quotInt8X64#++-- | Rounds towards zero element-wise. ++quotInt16X32# :: Int16X32# -> Int16X32# -> Int16X32#+quotInt16X32# = quotInt16X32#++-- | Rounds towards zero element-wise. ++quotInt32X16# :: Int32X16# -> Int32X16# -> Int32X16#+quotInt32X16# = quotInt32X16#++-- | Rounds towards zero element-wise. ++quotInt64X8# :: Int64X8# -> Int64X8# -> Int64X8#+quotInt64X8# = quotInt64X8#++-- | Rounds towards zero element-wise. ++quotWord8X16# :: Word8X16# -> Word8X16# -> Word8X16#+quotWord8X16# = quotWord8X16#++-- | Rounds towards zero element-wise. ++quotWord16X8# :: Word16X8# -> Word16X8# -> Word16X8#+quotWord16X8# = quotWord16X8#++-- | Rounds towards zero element-wise. ++quotWord32X4# :: Word32X4# -> Word32X4# -> Word32X4#+quotWord32X4# = quotWord32X4#++-- | Rounds towards zero element-wise. ++quotWord64X2# :: Word64X2# -> Word64X2# -> Word64X2#+quotWord64X2# = quotWord64X2#++-- | Rounds towards zero element-wise. ++quotWord8X32# :: Word8X32# -> Word8X32# -> Word8X32#+quotWord8X32# = quotWord8X32#++-- | Rounds towards zero element-wise. ++quotWord16X16# :: Word16X16# -> Word16X16# -> Word16X16#+quotWord16X16# = quotWord16X16#++-- | Rounds towards zero element-wise. ++quotWord32X8# :: Word32X8# -> Word32X8# -> Word32X8#+quotWord32X8# = quotWord32X8#++-- | Rounds towards zero element-wise. ++quotWord64X4# :: Word64X4# -> Word64X4# -> Word64X4#+quotWord64X4# = quotWord64X4#++-- | Rounds towards zero element-wise. ++quotWord8X64# :: Word8X64# -> Word8X64# -> Word8X64#+quotWord8X64# = quotWord8X64#++-- | Rounds towards zero element-wise. ++quotWord16X32# :: Word16X32# -> Word16X32# -> Word16X32#+quotWord16X32# = quotWord16X32#++-- | Rounds towards zero element-wise. ++quotWord32X16# :: Word32X16# -> Word32X16# -> Word32X16#+quotWord32X16# = quotWord32X16#++-- | Rounds towards zero element-wise. ++quotWord64X8# :: Word64X8# -> Word64X8# -> Word64X8#+quotWord64X8# = quotWord64X8#++-- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. ++remInt8X16# :: Int8X16# -> Int8X16# -> Int8X16#+remInt8X16# = remInt8X16#++-- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. ++remInt16X8# :: Int16X8# -> Int16X8# -> Int16X8#+remInt16X8# = remInt16X8#++-- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. ++remInt32X4# :: Int32X4# -> Int32X4# -> Int32X4#+remInt32X4# = remInt32X4#++-- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. ++remInt64X2# :: Int64X2# -> Int64X2# -> Int64X2#+remInt64X2# = remInt64X2#++-- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. ++remInt8X32# :: Int8X32# -> Int8X32# -> Int8X32#+remInt8X32# = remInt8X32#++-- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. ++remInt16X16# :: Int16X16# -> Int16X16# -> Int16X16#+remInt16X16# = remInt16X16#++-- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. ++remInt32X8# :: Int32X8# -> Int32X8# -> Int32X8#+remInt32X8# = remInt32X8#++-- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. ++remInt64X4# :: Int64X4# -> Int64X4# -> Int64X4#+remInt64X4# = remInt64X4#++-- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. ++remInt8X64# :: Int8X64# -> Int8X64# -> Int8X64#+remInt8X64# = remInt8X64#++-- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. ++remInt16X32# :: Int16X32# -> Int16X32# -> Int16X32#+remInt16X32# = remInt16X32#++-- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. ++remInt32X16# :: Int32X16# -> Int32X16# -> Int32X16#+remInt32X16# = remInt32X16#++-- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. ++remInt64X8# :: Int64X8# -> Int64X8# -> Int64X8#+remInt64X8# = remInt64X8#++-- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. ++remWord8X16# :: Word8X16# -> Word8X16# -> Word8X16#+remWord8X16# = remWord8X16#++-- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. ++remWord16X8# :: Word16X8# -> Word16X8# -> Word16X8#+remWord16X8# = remWord16X8#++-- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. ++remWord32X4# :: Word32X4# -> Word32X4# -> Word32X4#+remWord32X4# = remWord32X4#++-- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. ++remWord64X2# :: Word64X2# -> Word64X2# -> Word64X2#+remWord64X2# = remWord64X2#++-- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. ++remWord8X32# :: Word8X32# -> Word8X32# -> Word8X32#+remWord8X32# = remWord8X32#++-- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. ++remWord16X16# :: Word16X16# -> Word16X16# -> Word16X16#+remWord16X16# = remWord16X16#++-- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. ++remWord32X8# :: Word32X8# -> Word32X8# -> Word32X8#+remWord32X8# = remWord32X8#++-- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. ++remWord64X4# :: Word64X4# -> Word64X4# -> Word64X4#+remWord64X4# = remWord64X4#++-- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. ++remWord8X64# :: Word8X64# -> Word8X64# -> Word8X64#+remWord8X64# = remWord8X64#++-- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. ++remWord16X32# :: Word16X32# -> Word16X32# -> Word16X32#+remWord16X32# = remWord16X32#++-- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. ++remWord32X16# :: Word32X16# -> Word32X16# -> Word32X16#+remWord32X16# = remWord32X16#++-- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. ++remWord64X8# :: Word64X8# -> Word64X8# -> Word64X8#+remWord64X8# = remWord64X8#++-- | Negate element-wise. ++negateInt8X16# :: Int8X16# -> Int8X16#+negateInt8X16# = negateInt8X16#++-- | Negate element-wise. ++negateInt16X8# :: Int16X8# -> Int16X8#+negateInt16X8# = negateInt16X8#++-- | Negate element-wise. ++negateInt32X4# :: Int32X4# -> Int32X4#+negateInt32X4# = negateInt32X4#++-- | Negate element-wise. ++negateInt64X2# :: Int64X2# -> Int64X2#+negateInt64X2# = negateInt64X2#++-- | Negate element-wise. ++negateInt8X32# :: Int8X32# -> Int8X32#+negateInt8X32# = negateInt8X32#++-- | Negate element-wise. ++negateInt16X16# :: Int16X16# -> Int16X16#+negateInt16X16# = negateInt16X16#++-- | Negate element-wise. ++negateInt32X8# :: Int32X8# -> Int32X8#+negateInt32X8# = negateInt32X8#++-- | Negate element-wise. ++negateInt64X4# :: Int64X4# -> Int64X4#+negateInt64X4# = negateInt64X4#++-- | Negate element-wise. ++negateInt8X64# :: Int8X64# -> Int8X64#+negateInt8X64# = negateInt8X64#++-- | Negate element-wise. ++negateInt16X32# :: Int16X32# -> Int16X32#+negateInt16X32# = negateInt16X32#++-- | Negate element-wise. ++negateInt32X16# :: Int32X16# -> Int32X16#+negateInt32X16# = negateInt32X16#++-- | Negate element-wise. ++negateInt64X8# :: Int64X8# -> Int64X8#+negateInt64X8# = negateInt64X8#++-- | Negate element-wise. ++negateFloatX4# :: FloatX4# -> FloatX4#+negateFloatX4# = negateFloatX4#++-- | Negate element-wise. ++negateDoubleX2# :: DoubleX2# -> DoubleX2#+negateDoubleX2# = negateDoubleX2#++-- | Negate element-wise. ++negateFloatX8# :: FloatX8# -> FloatX8#+negateFloatX8# = negateFloatX8#++-- | Negate element-wise. ++negateDoubleX4# :: DoubleX4# -> DoubleX4#+negateDoubleX4# = negateDoubleX4#++-- | Negate element-wise. ++negateFloatX16# :: FloatX16# -> FloatX16#+negateFloatX16# = negateFloatX16#++-- | Negate element-wise. ++negateDoubleX8# :: DoubleX8# -> DoubleX8#+negateDoubleX8# = negateDoubleX8#++-- | Read a vector from specified index of immutable array. ++indexInt8X16Array# :: ByteArray# -> Int# -> Int8X16#+indexInt8X16Array# = indexInt8X16Array#++-- | Read a vector from specified index of immutable array. ++indexInt16X8Array# :: ByteArray# -> Int# -> Int16X8#+indexInt16X8Array# = indexInt16X8Array#++-- | Read a vector from specified index of immutable array. ++indexInt32X4Array# :: ByteArray# -> Int# -> Int32X4#+indexInt32X4Array# = indexInt32X4Array#++-- | Read a vector from specified index of immutable array. ++indexInt64X2Array# :: ByteArray# -> Int# -> Int64X2#+indexInt64X2Array# = indexInt64X2Array#++-- | Read a vector from specified index of immutable array. ++indexInt8X32Array# :: ByteArray# -> Int# -> Int8X32#+indexInt8X32Array# = indexInt8X32Array#++-- | Read a vector from specified index of immutable array. ++indexInt16X16Array# :: ByteArray# -> Int# -> Int16X16#+indexInt16X16Array# = indexInt16X16Array#++-- | Read a vector from specified index of immutable array. ++indexInt32X8Array# :: ByteArray# -> Int# -> Int32X8#+indexInt32X8Array# = indexInt32X8Array#++-- | Read a vector from specified index of immutable array. ++indexInt64X4Array# :: ByteArray# -> Int# -> Int64X4#+indexInt64X4Array# = indexInt64X4Array#++-- | Read a vector from specified index of immutable array. ++indexInt8X64Array# :: ByteArray# -> Int# -> Int8X64#+indexInt8X64Array# = indexInt8X64Array#++-- | Read a vector from specified index of immutable array. ++indexInt16X32Array# :: ByteArray# -> Int# -> Int16X32#+indexInt16X32Array# = indexInt16X32Array#++-- | Read a vector from specified index of immutable array. ++indexInt32X16Array# :: ByteArray# -> Int# -> Int32X16#+indexInt32X16Array# = indexInt32X16Array#++-- | Read a vector from specified index of immutable array. ++indexInt64X8Array# :: ByteArray# -> Int# -> Int64X8#+indexInt64X8Array# = indexInt64X8Array#++-- | Read a vector from specified index of immutable array. ++indexWord8X16Array# :: ByteArray# -> Int# -> Word8X16#+indexWord8X16Array# = indexWord8X16Array#++-- | Read a vector from specified index of immutable array. ++indexWord16X8Array# :: ByteArray# -> Int# -> Word16X8#+indexWord16X8Array# = indexWord16X8Array#++-- | Read a vector from specified index of immutable array. ++indexWord32X4Array# :: ByteArray# -> Int# -> Word32X4#+indexWord32X4Array# = indexWord32X4Array#++-- | Read a vector from specified index of immutable array. ++indexWord64X2Array# :: ByteArray# -> Int# -> Word64X2#+indexWord64X2Array# = indexWord64X2Array#++-- | Read a vector from specified index of immutable array. ++indexWord8X32Array# :: ByteArray# -> Int# -> Word8X32#+indexWord8X32Array# = indexWord8X32Array#++-- | Read a vector from specified index of immutable array. ++indexWord16X16Array# :: ByteArray# -> Int# -> Word16X16#+indexWord16X16Array# = indexWord16X16Array#++-- | Read a vector from specified index of immutable array. ++indexWord32X8Array# :: ByteArray# -> Int# -> Word32X8#+indexWord32X8Array# = indexWord32X8Array#++-- | Read a vector from specified index of immutable array. ++indexWord64X4Array# :: ByteArray# -> Int# -> Word64X4#+indexWord64X4Array# = indexWord64X4Array#++-- | Read a vector from specified index of immutable array. ++indexWord8X64Array# :: ByteArray# -> Int# -> Word8X64#+indexWord8X64Array# = indexWord8X64Array#++-- | Read a vector from specified index of immutable array. ++indexWord16X32Array# :: ByteArray# -> Int# -> Word16X32#+indexWord16X32Array# = indexWord16X32Array#++-- | Read a vector from specified index of immutable array. ++indexWord32X16Array# :: ByteArray# -> Int# -> Word32X16#+indexWord32X16Array# = indexWord32X16Array#++-- | Read a vector from specified index of immutable array. ++indexWord64X8Array# :: ByteArray# -> Int# -> Word64X8#+indexWord64X8Array# = indexWord64X8Array#++-- | Read a vector from specified index of immutable array. ++indexFloatX4Array# :: ByteArray# -> Int# -> FloatX4#+indexFloatX4Array# = indexFloatX4Array#++-- | Read a vector from specified index of immutable array. ++indexDoubleX2Array# :: ByteArray# -> Int# -> DoubleX2#+indexDoubleX2Array# = indexDoubleX2Array#++-- | Read a vector from specified index of immutable array. ++indexFloatX8Array# :: ByteArray# -> Int# -> FloatX8#+indexFloatX8Array# = indexFloatX8Array#++-- | Read a vector from specified index of immutable array. ++indexDoubleX4Array# :: ByteArray# -> Int# -> DoubleX4#+indexDoubleX4Array# = indexDoubleX4Array#++-- | Read a vector from specified index of immutable array. ++indexFloatX16Array# :: ByteArray# -> Int# -> FloatX16#+indexFloatX16Array# = indexFloatX16Array#++-- | Read a vector from specified index of immutable array. ++indexDoubleX8Array# :: ByteArray# -> Int# -> DoubleX8#+indexDoubleX8Array# = indexDoubleX8Array#++-- | Read a vector from specified index of mutable array. ++readInt8X16Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int8X16# #)+readInt8X16Array# = readInt8X16Array#++-- | Read a vector from specified index of mutable array. ++readInt16X8Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int16X8# #)+readInt16X8Array# = readInt16X8Array#++-- | Read a vector from specified index of mutable array. ++readInt32X4Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int32X4# #)+readInt32X4Array# = readInt32X4Array#++-- | Read a vector from specified index of mutable array. ++readInt64X2Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int64X2# #)+readInt64X2Array# = readInt64X2Array#++-- | Read a vector from specified index of mutable array. ++readInt8X32Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int8X32# #)+readInt8X32Array# = readInt8X32Array#++-- | Read a vector from specified index of mutable array. ++readInt16X16Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int16X16# #)+readInt16X16Array# = readInt16X16Array#++-- | Read a vector from specified index of mutable array. ++readInt32X8Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int32X8# #)+readInt32X8Array# = readInt32X8Array#++-- | Read a vector from specified index of mutable array. ++readInt64X4Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int64X4# #)+readInt64X4Array# = readInt64X4Array#++-- | Read a vector from specified index of mutable array. ++readInt8X64Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int8X64# #)+readInt8X64Array# = readInt8X64Array#++-- | Read a vector from specified index of mutable array. ++readInt16X32Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int16X32# #)+readInt16X32Array# = readInt16X32Array#++-- | Read a vector from specified index of mutable array. ++readInt32X16Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int32X16# #)+readInt32X16Array# = readInt32X16Array#++-- | Read a vector from specified index of mutable array. ++readInt64X8Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int64X8# #)+readInt64X8Array# = readInt64X8Array#++-- | Read a vector from specified index of mutable array. ++readWord8X16Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word8X16# #)+readWord8X16Array# = readWord8X16Array#++-- | Read a vector from specified index of mutable array. ++readWord16X8Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word16X8# #)+readWord16X8Array# = readWord16X8Array#++-- | Read a vector from specified index of mutable array. ++readWord32X4Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word32X4# #)+readWord32X4Array# = readWord32X4Array#++-- | Read a vector from specified index of mutable array. ++readWord64X2Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word64X2# #)+readWord64X2Array# = readWord64X2Array#++-- | Read a vector from specified index of mutable array. ++readWord8X32Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word8X32# #)+readWord8X32Array# = readWord8X32Array#++-- | Read a vector from specified index of mutable array. ++readWord16X16Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word16X16# #)+readWord16X16Array# = readWord16X16Array#++-- | Read a vector from specified index of mutable array. ++readWord32X8Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word32X8# #)+readWord32X8Array# = readWord32X8Array#++-- | Read a vector from specified index of mutable array. ++readWord64X4Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word64X4# #)+readWord64X4Array# = readWord64X4Array#++-- | Read a vector from specified index of mutable array. ++readWord8X64Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word8X64# #)+readWord8X64Array# = readWord8X64Array#++-- | Read a vector from specified index of mutable array. ++readWord16X32Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word16X32# #)+readWord16X32Array# = readWord16X32Array#++-- | Read a vector from specified index of mutable array. ++readWord32X16Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word32X16# #)+readWord32X16Array# = readWord32X16Array#++-- | Read a vector from specified index of mutable array. ++readWord64X8Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word64X8# #)+readWord64X8Array# = readWord64X8Array#++-- | Read a vector from specified index of mutable array. ++readFloatX4Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,FloatX4# #)+readFloatX4Array# = readFloatX4Array#++-- | Read a vector from specified index of mutable array. ++readDoubleX2Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,DoubleX2# #)+readDoubleX2Array# = readDoubleX2Array#++-- | Read a vector from specified index of mutable array. ++readFloatX8Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,FloatX8# #)+readFloatX8Array# = readFloatX8Array#++-- | Read a vector from specified index of mutable array. ++readDoubleX4Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,DoubleX4# #)+readDoubleX4Array# = readDoubleX4Array#++-- | Read a vector from specified index of mutable array. ++readFloatX16Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,FloatX16# #)+readFloatX16Array# = readFloatX16Array#++-- | Read a vector from specified index of mutable array. ++readDoubleX8Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,DoubleX8# #)+readDoubleX8Array# = readDoubleX8Array#++-- | Write a vector to specified index of mutable array. ++writeInt8X16Array# :: MutableByteArray# s -> Int# -> Int8X16# -> State# s -> State# s+writeInt8X16Array# = writeInt8X16Array#++-- | Write a vector to specified index of mutable array. ++writeInt16X8Array# :: MutableByteArray# s -> Int# -> Int16X8# -> State# s -> State# s+writeInt16X8Array# = writeInt16X8Array#++-- | Write a vector to specified index of mutable array. ++writeInt32X4Array# :: MutableByteArray# s -> Int# -> Int32X4# -> State# s -> State# s+writeInt32X4Array# = writeInt32X4Array#++-- | Write a vector to specified index of mutable array. ++writeInt64X2Array# :: MutableByteArray# s -> Int# -> Int64X2# -> State# s -> State# s+writeInt64X2Array# = writeInt64X2Array#++-- | Write a vector to specified index of mutable array. ++writeInt8X32Array# :: MutableByteArray# s -> Int# -> Int8X32# -> State# s -> State# s+writeInt8X32Array# = writeInt8X32Array#++-- | Write a vector to specified index of mutable array. ++writeInt16X16Array# :: MutableByteArray# s -> Int# -> Int16X16# -> State# s -> State# s+writeInt16X16Array# = writeInt16X16Array#++-- | Write a vector to specified index of mutable array. ++writeInt32X8Array# :: MutableByteArray# s -> Int# -> Int32X8# -> State# s -> State# s+writeInt32X8Array# = writeInt32X8Array#++-- | Write a vector to specified index of mutable array. ++writeInt64X4Array# :: MutableByteArray# s -> Int# -> Int64X4# -> State# s -> State# s+writeInt64X4Array# = writeInt64X4Array#++-- | Write a vector to specified index of mutable array. ++writeInt8X64Array# :: MutableByteArray# s -> Int# -> Int8X64# -> State# s -> State# s+writeInt8X64Array# = writeInt8X64Array#++-- | Write a vector to specified index of mutable array. ++writeInt16X32Array# :: MutableByteArray# s -> Int# -> Int16X32# -> State# s -> State# s+writeInt16X32Array# = writeInt16X32Array#++-- | Write a vector to specified index of mutable array. ++writeInt32X16Array# :: MutableByteArray# s -> Int# -> Int32X16# -> State# s -> State# s+writeInt32X16Array# = writeInt32X16Array#++-- | Write a vector to specified index of mutable array. ++writeInt64X8Array# :: MutableByteArray# s -> Int# -> Int64X8# -> State# s -> State# s+writeInt64X8Array# = writeInt64X8Array#++-- | Write a vector to specified index of mutable array. ++writeWord8X16Array# :: MutableByteArray# s -> Int# -> Word8X16# -> State# s -> State# s+writeWord8X16Array# = writeWord8X16Array#++-- | Write a vector to specified index of mutable array. ++writeWord16X8Array# :: MutableByteArray# s -> Int# -> Word16X8# -> State# s -> State# s+writeWord16X8Array# = writeWord16X8Array#++-- | Write a vector to specified index of mutable array. ++writeWord32X4Array# :: MutableByteArray# s -> Int# -> Word32X4# -> State# s -> State# s+writeWord32X4Array# = writeWord32X4Array#++-- | Write a vector to specified index of mutable array. ++writeWord64X2Array# :: MutableByteArray# s -> Int# -> Word64X2# -> State# s -> State# s+writeWord64X2Array# = writeWord64X2Array#++-- | Write a vector to specified index of mutable array. ++writeWord8X32Array# :: MutableByteArray# s -> Int# -> Word8X32# -> State# s -> State# s+writeWord8X32Array# = writeWord8X32Array#++-- | Write a vector to specified index of mutable array. ++writeWord16X16Array# :: MutableByteArray# s -> Int# -> Word16X16# -> State# s -> State# s+writeWord16X16Array# = writeWord16X16Array#++-- | Write a vector to specified index of mutable array. ++writeWord32X8Array# :: MutableByteArray# s -> Int# -> Word32X8# -> State# s -> State# s+writeWord32X8Array# = writeWord32X8Array#++-- | Write a vector to specified index of mutable array. ++writeWord64X4Array# :: MutableByteArray# s -> Int# -> Word64X4# -> State# s -> State# s+writeWord64X4Array# = writeWord64X4Array#++-- | Write a vector to specified index of mutable array. ++writeWord8X64Array# :: MutableByteArray# s -> Int# -> Word8X64# -> State# s -> State# s+writeWord8X64Array# = writeWord8X64Array#++-- | Write a vector to specified index of mutable array. ++writeWord16X32Array# :: MutableByteArray# s -> Int# -> Word16X32# -> State# s -> State# s+writeWord16X32Array# = writeWord16X32Array#++-- | Write a vector to specified index of mutable array. ++writeWord32X16Array# :: MutableByteArray# s -> Int# -> Word32X16# -> State# s -> State# s+writeWord32X16Array# = writeWord32X16Array#++-- | Write a vector to specified index of mutable array. ++writeWord64X8Array# :: MutableByteArray# s -> Int# -> Word64X8# -> State# s -> State# s+writeWord64X8Array# = writeWord64X8Array#++-- | Write a vector to specified index of mutable array. ++writeFloatX4Array# :: MutableByteArray# s -> Int# -> FloatX4# -> State# s -> State# s+writeFloatX4Array# = writeFloatX4Array#++-- | Write a vector to specified index of mutable array. ++writeDoubleX2Array# :: MutableByteArray# s -> Int# -> DoubleX2# -> State# s -> State# s+writeDoubleX2Array# = writeDoubleX2Array#++-- | Write a vector to specified index of mutable array. ++writeFloatX8Array# :: MutableByteArray# s -> Int# -> FloatX8# -> State# s -> State# s+writeFloatX8Array# = writeFloatX8Array#++-- | Write a vector to specified index of mutable array. ++writeDoubleX4Array# :: MutableByteArray# s -> Int# -> DoubleX4# -> State# s -> State# s+writeDoubleX4Array# = writeDoubleX4Array#++-- | Write a vector to specified index of mutable array. ++writeFloatX16Array# :: MutableByteArray# s -> Int# -> FloatX16# -> State# s -> State# s+writeFloatX16Array# = writeFloatX16Array#++-- | Write a vector to specified index of mutable array. ++writeDoubleX8Array# :: MutableByteArray# s -> Int# -> DoubleX8# -> State# s -> State# s+writeDoubleX8Array# = writeDoubleX8Array#++-- | Reads vector; offset in bytes. ++indexInt8X16OffAddr# :: Addr# -> Int# -> Int8X16#+indexInt8X16OffAddr# = indexInt8X16OffAddr#++-- | Reads vector; offset in bytes. ++indexInt16X8OffAddr# :: Addr# -> Int# -> Int16X8#+indexInt16X8OffAddr# = indexInt16X8OffAddr#++-- | Reads vector; offset in bytes. ++indexInt32X4OffAddr# :: Addr# -> Int# -> Int32X4#+indexInt32X4OffAddr# = indexInt32X4OffAddr#++-- | Reads vector; offset in bytes. ++indexInt64X2OffAddr# :: Addr# -> Int# -> Int64X2#+indexInt64X2OffAddr# = indexInt64X2OffAddr#++-- | Reads vector; offset in bytes. ++indexInt8X32OffAddr# :: Addr# -> Int# -> Int8X32#+indexInt8X32OffAddr# = indexInt8X32OffAddr#++-- | Reads vector; offset in bytes. ++indexInt16X16OffAddr# :: Addr# -> Int# -> Int16X16#+indexInt16X16OffAddr# = indexInt16X16OffAddr#++-- | Reads vector; offset in bytes. ++indexInt32X8OffAddr# :: Addr# -> Int# -> Int32X8#+indexInt32X8OffAddr# = indexInt32X8OffAddr#++-- | Reads vector; offset in bytes. ++indexInt64X4OffAddr# :: Addr# -> Int# -> Int64X4#+indexInt64X4OffAddr# = indexInt64X4OffAddr#++-- | Reads vector; offset in bytes. ++indexInt8X64OffAddr# :: Addr# -> Int# -> Int8X64#+indexInt8X64OffAddr# = indexInt8X64OffAddr#++-- | Reads vector; offset in bytes. ++indexInt16X32OffAddr# :: Addr# -> Int# -> Int16X32#+indexInt16X32OffAddr# = indexInt16X32OffAddr#++-- | Reads vector; offset in bytes. ++indexInt32X16OffAddr# :: Addr# -> Int# -> Int32X16#+indexInt32X16OffAddr# = indexInt32X16OffAddr#++-- | Reads vector; offset in bytes. ++indexInt64X8OffAddr# :: Addr# -> Int# -> Int64X8#+indexInt64X8OffAddr# = indexInt64X8OffAddr#++-- | Reads vector; offset in bytes. ++indexWord8X16OffAddr# :: Addr# -> Int# -> Word8X16#+indexWord8X16OffAddr# = indexWord8X16OffAddr#++-- | Reads vector; offset in bytes. ++indexWord16X8OffAddr# :: Addr# -> Int# -> Word16X8#+indexWord16X8OffAddr# = indexWord16X8OffAddr#++-- | Reads vector; offset in bytes. ++indexWord32X4OffAddr# :: Addr# -> Int# -> Word32X4#+indexWord32X4OffAddr# = indexWord32X4OffAddr#++-- | Reads vector; offset in bytes. ++indexWord64X2OffAddr# :: Addr# -> Int# -> Word64X2#+indexWord64X2OffAddr# = indexWord64X2OffAddr#++-- | Reads vector; offset in bytes. ++indexWord8X32OffAddr# :: Addr# -> Int# -> Word8X32#+indexWord8X32OffAddr# = indexWord8X32OffAddr#++-- | Reads vector; offset in bytes. ++indexWord16X16OffAddr# :: Addr# -> Int# -> Word16X16#+indexWord16X16OffAddr# = indexWord16X16OffAddr#++-- | Reads vector; offset in bytes. ++indexWord32X8OffAddr# :: Addr# -> Int# -> Word32X8#+indexWord32X8OffAddr# = indexWord32X8OffAddr#++-- | Reads vector; offset in bytes. ++indexWord64X4OffAddr# :: Addr# -> Int# -> Word64X4#+indexWord64X4OffAddr# = indexWord64X4OffAddr#++-- | Reads vector; offset in bytes. ++indexWord8X64OffAddr# :: Addr# -> Int# -> Word8X64#+indexWord8X64OffAddr# = indexWord8X64OffAddr#++-- | Reads vector; offset in bytes. ++indexWord16X32OffAddr# :: Addr# -> Int# -> Word16X32#+indexWord16X32OffAddr# = indexWord16X32OffAddr#++-- | Reads vector; offset in bytes. ++indexWord32X16OffAddr# :: Addr# -> Int# -> Word32X16#+indexWord32X16OffAddr# = indexWord32X16OffAddr#++-- | Reads vector; offset in bytes. ++indexWord64X8OffAddr# :: Addr# -> Int# -> Word64X8#+indexWord64X8OffAddr# = indexWord64X8OffAddr#++-- | Reads vector; offset in bytes. ++indexFloatX4OffAddr# :: Addr# -> Int# -> FloatX4#+indexFloatX4OffAddr# = indexFloatX4OffAddr#++-- | Reads vector; offset in bytes. ++indexDoubleX2OffAddr# :: Addr# -> Int# -> DoubleX2#+indexDoubleX2OffAddr# = indexDoubleX2OffAddr#++-- | Reads vector; offset in bytes. ++indexFloatX8OffAddr# :: Addr# -> Int# -> FloatX8#+indexFloatX8OffAddr# = indexFloatX8OffAddr#++-- | Reads vector; offset in bytes. ++indexDoubleX4OffAddr# :: Addr# -> Int# -> DoubleX4#+indexDoubleX4OffAddr# = indexDoubleX4OffAddr#++-- | Reads vector; offset in bytes. ++indexFloatX16OffAddr# :: Addr# -> Int# -> FloatX16#+indexFloatX16OffAddr# = indexFloatX16OffAddr#++-- | Reads vector; offset in bytes. ++indexDoubleX8OffAddr# :: Addr# -> Int# -> DoubleX8#+indexDoubleX8OffAddr# = indexDoubleX8OffAddr#++-- | Reads vector; offset in bytes. ++readInt8X16OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int8X16# #)+readInt8X16OffAddr# = readInt8X16OffAddr#++-- | Reads vector; offset in bytes. ++readInt16X8OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int16X8# #)+readInt16X8OffAddr# = readInt16X8OffAddr#++-- | Reads vector; offset in bytes. ++readInt32X4OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int32X4# #)+readInt32X4OffAddr# = readInt32X4OffAddr#++-- | Reads vector; offset in bytes. ++readInt64X2OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int64X2# #)+readInt64X2OffAddr# = readInt64X2OffAddr#++-- | Reads vector; offset in bytes. ++readInt8X32OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int8X32# #)+readInt8X32OffAddr# = readInt8X32OffAddr#++-- | Reads vector; offset in bytes. ++readInt16X16OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int16X16# #)+readInt16X16OffAddr# = readInt16X16OffAddr#++-- | Reads vector; offset in bytes. ++readInt32X8OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int32X8# #)+readInt32X8OffAddr# = readInt32X8OffAddr#++-- | Reads vector; offset in bytes. ++readInt64X4OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int64X4# #)+readInt64X4OffAddr# = readInt64X4OffAddr#++-- | Reads vector; offset in bytes. ++readInt8X64OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int8X64# #)+readInt8X64OffAddr# = readInt8X64OffAddr#++-- | Reads vector; offset in bytes. ++readInt16X32OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int16X32# #)+readInt16X32OffAddr# = readInt16X32OffAddr#++-- | Reads vector; offset in bytes. ++readInt32X16OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int32X16# #)+readInt32X16OffAddr# = readInt32X16OffAddr#++-- | Reads vector; offset in bytes. ++readInt64X8OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int64X8# #)+readInt64X8OffAddr# = readInt64X8OffAddr#++-- | Reads vector; offset in bytes. ++readWord8X16OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word8X16# #)+readWord8X16OffAddr# = readWord8X16OffAddr#++-- | Reads vector; offset in bytes. ++readWord16X8OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word16X8# #)+readWord16X8OffAddr# = readWord16X8OffAddr#++-- | Reads vector; offset in bytes. ++readWord32X4OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word32X4# #)+readWord32X4OffAddr# = readWord32X4OffAddr#++-- | Reads vector; offset in bytes. ++readWord64X2OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word64X2# #)+readWord64X2OffAddr# = readWord64X2OffAddr#++-- | Reads vector; offset in bytes. ++readWord8X32OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word8X32# #)+readWord8X32OffAddr# = readWord8X32OffAddr#++-- | Reads vector; offset in bytes. ++readWord16X16OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word16X16# #)+readWord16X16OffAddr# = readWord16X16OffAddr#++-- | Reads vector; offset in bytes. ++readWord32X8OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word32X8# #)+readWord32X8OffAddr# = readWord32X8OffAddr#++-- | Reads vector; offset in bytes. ++readWord64X4OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word64X4# #)+readWord64X4OffAddr# = readWord64X4OffAddr#++-- | Reads vector; offset in bytes. ++readWord8X64OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word8X64# #)+readWord8X64OffAddr# = readWord8X64OffAddr#++-- | Reads vector; offset in bytes. ++readWord16X32OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word16X32# #)+readWord16X32OffAddr# = readWord16X32OffAddr#++-- | Reads vector; offset in bytes. ++readWord32X16OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word32X16# #)+readWord32X16OffAddr# = readWord32X16OffAddr#++-- | Reads vector; offset in bytes. ++readWord64X8OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word64X8# #)+readWord64X8OffAddr# = readWord64X8OffAddr#++-- | Reads vector; offset in bytes. ++readFloatX4OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,FloatX4# #)+readFloatX4OffAddr# = readFloatX4OffAddr#++-- | Reads vector; offset in bytes. ++readDoubleX2OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,DoubleX2# #)+readDoubleX2OffAddr# = readDoubleX2OffAddr#++-- | Reads vector; offset in bytes. ++readFloatX8OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,FloatX8# #)+readFloatX8OffAddr# = readFloatX8OffAddr#++-- | Reads vector; offset in bytes. ++readDoubleX4OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,DoubleX4# #)+readDoubleX4OffAddr# = readDoubleX4OffAddr#++-- | Reads vector; offset in bytes. ++readFloatX16OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,FloatX16# #)+readFloatX16OffAddr# = readFloatX16OffAddr#++-- | Reads vector; offset in bytes. ++readDoubleX8OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,DoubleX8# #)+readDoubleX8OffAddr# = readDoubleX8OffAddr#++-- | Write vector; offset in bytes. ++writeInt8X16OffAddr# :: Addr# -> Int# -> Int8X16# -> State# s -> State# s+writeInt8X16OffAddr# = writeInt8X16OffAddr#++-- | Write vector; offset in bytes. ++writeInt16X8OffAddr# :: Addr# -> Int# -> Int16X8# -> State# s -> State# s+writeInt16X8OffAddr# = writeInt16X8OffAddr#++-- | Write vector; offset in bytes. ++writeInt32X4OffAddr# :: Addr# -> Int# -> Int32X4# -> State# s -> State# s+writeInt32X4OffAddr# = writeInt32X4OffAddr#++-- | Write vector; offset in bytes. ++writeInt64X2OffAddr# :: Addr# -> Int# -> Int64X2# -> State# s -> State# s+writeInt64X2OffAddr# = writeInt64X2OffAddr#++-- | Write vector; offset in bytes. ++writeInt8X32OffAddr# :: Addr# -> Int# -> Int8X32# -> State# s -> State# s+writeInt8X32OffAddr# = writeInt8X32OffAddr#++-- | Write vector; offset in bytes. ++writeInt16X16OffAddr# :: Addr# -> Int# -> Int16X16# -> State# s -> State# s+writeInt16X16OffAddr# = writeInt16X16OffAddr#++-- | Write vector; offset in bytes. ++writeInt32X8OffAddr# :: Addr# -> Int# -> Int32X8# -> State# s -> State# s+writeInt32X8OffAddr# = writeInt32X8OffAddr#++-- | Write vector; offset in bytes. ++writeInt64X4OffAddr# :: Addr# -> Int# -> Int64X4# -> State# s -> State# s+writeInt64X4OffAddr# = writeInt64X4OffAddr#++-- | Write vector; offset in bytes. ++writeInt8X64OffAddr# :: Addr# -> Int# -> Int8X64# -> State# s -> State# s+writeInt8X64OffAddr# = writeInt8X64OffAddr#++-- | Write vector; offset in bytes. ++writeInt16X32OffAddr# :: Addr# -> Int# -> Int16X32# -> State# s -> State# s+writeInt16X32OffAddr# = writeInt16X32OffAddr#++-- | Write vector; offset in bytes. ++writeInt32X16OffAddr# :: Addr# -> Int# -> Int32X16# -> State# s -> State# s+writeInt32X16OffAddr# = writeInt32X16OffAddr#++-- | Write vector; offset in bytes. ++writeInt64X8OffAddr# :: Addr# -> Int# -> Int64X8# -> State# s -> State# s+writeInt64X8OffAddr# = writeInt64X8OffAddr#++-- | Write vector; offset in bytes. ++writeWord8X16OffAddr# :: Addr# -> Int# -> Word8X16# -> State# s -> State# s+writeWord8X16OffAddr# = writeWord8X16OffAddr#++-- | Write vector; offset in bytes. ++writeWord16X8OffAddr# :: Addr# -> Int# -> Word16X8# -> State# s -> State# s+writeWord16X8OffAddr# = writeWord16X8OffAddr#++-- | Write vector; offset in bytes. ++writeWord32X4OffAddr# :: Addr# -> Int# -> Word32X4# -> State# s -> State# s+writeWord32X4OffAddr# = writeWord32X4OffAddr#++-- | Write vector; offset in bytes. ++writeWord64X2OffAddr# :: Addr# -> Int# -> Word64X2# -> State# s -> State# s+writeWord64X2OffAddr# = writeWord64X2OffAddr#++-- | Write vector; offset in bytes. ++writeWord8X32OffAddr# :: Addr# -> Int# -> Word8X32# -> State# s -> State# s+writeWord8X32OffAddr# = writeWord8X32OffAddr#++-- | Write vector; offset in bytes. ++writeWord16X16OffAddr# :: Addr# -> Int# -> Word16X16# -> State# s -> State# s+writeWord16X16OffAddr# = writeWord16X16OffAddr#++-- | Write vector; offset in bytes. ++writeWord32X8OffAddr# :: Addr# -> Int# -> Word32X8# -> State# s -> State# s+writeWord32X8OffAddr# = writeWord32X8OffAddr#++-- | Write vector; offset in bytes. ++writeWord64X4OffAddr# :: Addr# -> Int# -> Word64X4# -> State# s -> State# s+writeWord64X4OffAddr# = writeWord64X4OffAddr#++-- | Write vector; offset in bytes. ++writeWord8X64OffAddr# :: Addr# -> Int# -> Word8X64# -> State# s -> State# s+writeWord8X64OffAddr# = writeWord8X64OffAddr#++-- | Write vector; offset in bytes. ++writeWord16X32OffAddr# :: Addr# -> Int# -> Word16X32# -> State# s -> State# s+writeWord16X32OffAddr# = writeWord16X32OffAddr#++-- | Write vector; offset in bytes. ++writeWord32X16OffAddr# :: Addr# -> Int# -> Word32X16# -> State# s -> State# s+writeWord32X16OffAddr# = writeWord32X16OffAddr#++-- | Write vector; offset in bytes. ++writeWord64X8OffAddr# :: Addr# -> Int# -> Word64X8# -> State# s -> State# s+writeWord64X8OffAddr# = writeWord64X8OffAddr#++-- | Write vector; offset in bytes. ++writeFloatX4OffAddr# :: Addr# -> Int# -> FloatX4# -> State# s -> State# s+writeFloatX4OffAddr# = writeFloatX4OffAddr#++-- | Write vector; offset in bytes. ++writeDoubleX2OffAddr# :: Addr# -> Int# -> DoubleX2# -> State# s -> State# s+writeDoubleX2OffAddr# = writeDoubleX2OffAddr#++-- | Write vector; offset in bytes. ++writeFloatX8OffAddr# :: Addr# -> Int# -> FloatX8# -> State# s -> State# s+writeFloatX8OffAddr# = writeFloatX8OffAddr#++-- | Write vector; offset in bytes. ++writeDoubleX4OffAddr# :: Addr# -> Int# -> DoubleX4# -> State# s -> State# s+writeDoubleX4OffAddr# = writeDoubleX4OffAddr#++-- | Write vector; offset in bytes. ++writeFloatX16OffAddr# :: Addr# -> Int# -> FloatX16# -> State# s -> State# s+writeFloatX16OffAddr# = writeFloatX16OffAddr#++-- | Write vector; offset in bytes. ++writeDoubleX8OffAddr# :: Addr# -> Int# -> DoubleX8# -> State# s -> State# s+writeDoubleX8OffAddr# = writeDoubleX8OffAddr#++-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. ++indexInt8ArrayAsInt8X16# :: ByteArray# -> Int# -> Int8X16#+indexInt8ArrayAsInt8X16# = indexInt8ArrayAsInt8X16#++-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. ++indexInt16ArrayAsInt16X8# :: ByteArray# -> Int# -> Int16X8#+indexInt16ArrayAsInt16X8# = indexInt16ArrayAsInt16X8#++-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. ++indexInt32ArrayAsInt32X4# :: ByteArray# -> Int# -> Int32X4#+indexInt32ArrayAsInt32X4# = indexInt32ArrayAsInt32X4#++-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. ++indexInt64ArrayAsInt64X2# :: ByteArray# -> Int# -> Int64X2#+indexInt64ArrayAsInt64X2# = indexInt64ArrayAsInt64X2#++-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. ++indexInt8ArrayAsInt8X32# :: ByteArray# -> Int# -> Int8X32#+indexInt8ArrayAsInt8X32# = indexInt8ArrayAsInt8X32#++-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. ++indexInt16ArrayAsInt16X16# :: ByteArray# -> Int# -> Int16X16#+indexInt16ArrayAsInt16X16# = indexInt16ArrayAsInt16X16#++-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. ++indexInt32ArrayAsInt32X8# :: ByteArray# -> Int# -> Int32X8#+indexInt32ArrayAsInt32X8# = indexInt32ArrayAsInt32X8#++-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. ++indexInt64ArrayAsInt64X4# :: ByteArray# -> Int# -> Int64X4#+indexInt64ArrayAsInt64X4# = indexInt64ArrayAsInt64X4#++-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. ++indexInt8ArrayAsInt8X64# :: ByteArray# -> Int# -> Int8X64#+indexInt8ArrayAsInt8X64# = indexInt8ArrayAsInt8X64#++-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. ++indexInt16ArrayAsInt16X32# :: ByteArray# -> Int# -> Int16X32#+indexInt16ArrayAsInt16X32# = indexInt16ArrayAsInt16X32#++-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. ++indexInt32ArrayAsInt32X16# :: ByteArray# -> Int# -> Int32X16#+indexInt32ArrayAsInt32X16# = indexInt32ArrayAsInt32X16#++-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. ++indexInt64ArrayAsInt64X8# :: ByteArray# -> Int# -> Int64X8#+indexInt64ArrayAsInt64X8# = indexInt64ArrayAsInt64X8#++-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. ++indexWord8ArrayAsWord8X16# :: ByteArray# -> Int# -> Word8X16#+indexWord8ArrayAsWord8X16# = indexWord8ArrayAsWord8X16#++-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. ++indexWord16ArrayAsWord16X8# :: ByteArray# -> Int# -> Word16X8#+indexWord16ArrayAsWord16X8# = indexWord16ArrayAsWord16X8#++-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. ++indexWord32ArrayAsWord32X4# :: ByteArray# -> Int# -> Word32X4#+indexWord32ArrayAsWord32X4# = indexWord32ArrayAsWord32X4#++-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. ++indexWord64ArrayAsWord64X2# :: ByteArray# -> Int# -> Word64X2#+indexWord64ArrayAsWord64X2# = indexWord64ArrayAsWord64X2#++-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. ++indexWord8ArrayAsWord8X32# :: ByteArray# -> Int# -> Word8X32#+indexWord8ArrayAsWord8X32# = indexWord8ArrayAsWord8X32#++-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. ++indexWord16ArrayAsWord16X16# :: ByteArray# -> Int# -> Word16X16#+indexWord16ArrayAsWord16X16# = indexWord16ArrayAsWord16X16#++-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. ++indexWord32ArrayAsWord32X8# :: ByteArray# -> Int# -> Word32X8#+indexWord32ArrayAsWord32X8# = indexWord32ArrayAsWord32X8#++-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. ++indexWord64ArrayAsWord64X4# :: ByteArray# -> Int# -> Word64X4#+indexWord64ArrayAsWord64X4# = indexWord64ArrayAsWord64X4#++-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. ++indexWord8ArrayAsWord8X64# :: ByteArray# -> Int# -> Word8X64#+indexWord8ArrayAsWord8X64# = indexWord8ArrayAsWord8X64#++-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. ++indexWord16ArrayAsWord16X32# :: ByteArray# -> Int# -> Word16X32#+indexWord16ArrayAsWord16X32# = indexWord16ArrayAsWord16X32#++-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. ++indexWord32ArrayAsWord32X16# :: ByteArray# -> Int# -> Word32X16#+indexWord32ArrayAsWord32X16# = indexWord32ArrayAsWord32X16#++-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. ++indexWord64ArrayAsWord64X8# :: ByteArray# -> Int# -> Word64X8#+indexWord64ArrayAsWord64X8# = indexWord64ArrayAsWord64X8#++-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. ++indexFloatArrayAsFloatX4# :: ByteArray# -> Int# -> FloatX4#+indexFloatArrayAsFloatX4# = indexFloatArrayAsFloatX4#++-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. ++indexDoubleArrayAsDoubleX2# :: ByteArray# -> Int# -> DoubleX2#+indexDoubleArrayAsDoubleX2# = indexDoubleArrayAsDoubleX2#++-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. ++indexFloatArrayAsFloatX8# :: ByteArray# -> Int# -> FloatX8#+indexFloatArrayAsFloatX8# = indexFloatArrayAsFloatX8#++-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. ++indexDoubleArrayAsDoubleX4# :: ByteArray# -> Int# -> DoubleX4#+indexDoubleArrayAsDoubleX4# = indexDoubleArrayAsDoubleX4#++-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. ++indexFloatArrayAsFloatX16# :: ByteArray# -> Int# -> FloatX16#+indexFloatArrayAsFloatX16# = indexFloatArrayAsFloatX16#++-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. ++indexDoubleArrayAsDoubleX8# :: ByteArray# -> Int# -> DoubleX8#+indexDoubleArrayAsDoubleX8# = indexDoubleArrayAsDoubleX8#++-- | 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# = readInt8ArrayAsInt8X16#++-- | 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# = readInt16ArrayAsInt16X8#++-- | 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# = readInt32ArrayAsInt32X4#++-- | 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# = readInt64ArrayAsInt64X2#++-- | 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# = readInt8ArrayAsInt8X32#++-- | 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# = readInt16ArrayAsInt16X16#++-- | 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# = readInt32ArrayAsInt32X8#++-- | 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# = readInt64ArrayAsInt64X4#++-- | 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# = readInt8ArrayAsInt8X64#++-- | 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# = readInt16ArrayAsInt16X32#++-- | 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# = readInt32ArrayAsInt32X16#++-- | 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# = readInt64ArrayAsInt64X8#++-- | 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# = readWord8ArrayAsWord8X16#++-- | 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# = readWord16ArrayAsWord16X8#++-- | 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# = readWord32ArrayAsWord32X4#++-- | 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# = readWord64ArrayAsWord64X2#++-- | 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# = readWord8ArrayAsWord8X32#++-- | 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# = readWord16ArrayAsWord16X16#++-- | 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# = readWord32ArrayAsWord32X8#++-- | 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# = readWord64ArrayAsWord64X4#++-- | 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# = readWord8ArrayAsWord8X64#++-- | 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# = readWord16ArrayAsWord16X32#++-- | 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# = readWord32ArrayAsWord32X16#++-- | 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# = readWord64ArrayAsWord64X8#++-- | 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# = readFloatArrayAsFloatX4#++-- | 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# = readDoubleArrayAsDoubleX2#++-- | 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# = readFloatArrayAsFloatX8#++-- | 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# = readDoubleArrayAsDoubleX4#++-- | 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# = readFloatArrayAsFloatX16#++-- | 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# = readDoubleArrayAsDoubleX8#++-- | 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# = writeInt8ArrayAsInt8X16#++-- | 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# = writeInt16ArrayAsInt16X8#++-- | 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# = writeInt32ArrayAsInt32X4#++-- | 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# = writeInt64ArrayAsInt64X2#++-- | 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# = writeInt8ArrayAsInt8X32#++-- | 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# = writeInt16ArrayAsInt16X16#++-- | 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# = writeInt32ArrayAsInt32X8#++-- | 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# = writeInt64ArrayAsInt64X4#++-- | 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# = writeInt8ArrayAsInt8X64#++-- | 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# = writeInt16ArrayAsInt16X32#++-- | 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# = writeInt32ArrayAsInt32X16#++-- | 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# = writeInt64ArrayAsInt64X8#++-- | 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# = writeWord8ArrayAsWord8X16#++-- | 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# = writeWord16ArrayAsWord16X8#++-- | 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# = writeWord32ArrayAsWord32X4#++-- | 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# = writeWord64ArrayAsWord64X2#++-- | 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# = writeWord8ArrayAsWord8X32#++-- | 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# = writeWord16ArrayAsWord16X16#++-- | 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# = writeWord32ArrayAsWord32X8#++-- | 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# = writeWord64ArrayAsWord64X4#++-- | 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# = writeWord8ArrayAsWord8X64#++-- | 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# = writeWord16ArrayAsWord16X32#++-- | 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# = writeWord32ArrayAsWord32X16#++-- | 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# = writeWord64ArrayAsWord64X8#++-- | 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# = writeFloatArrayAsFloatX4#++-- | 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# = writeDoubleArrayAsDoubleX2#++-- | 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# = writeFloatArrayAsFloatX8#++-- | 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# = writeDoubleArrayAsDoubleX4#++-- | 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# = writeFloatArrayAsFloatX16#++-- | 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# = writeDoubleArrayAsDoubleX8#++-- | Reads vector; offset in scalar elements. ++indexInt8OffAddrAsInt8X16# :: Addr# -> Int# -> Int8X16#+indexInt8OffAddrAsInt8X16# = indexInt8OffAddrAsInt8X16#++-- | Reads vector; offset in scalar elements. ++indexInt16OffAddrAsInt16X8# :: Addr# -> Int# -> Int16X8#+indexInt16OffAddrAsInt16X8# = indexInt16OffAddrAsInt16X8#++-- | Reads vector; offset in scalar elements. ++indexInt32OffAddrAsInt32X4# :: Addr# -> Int# -> Int32X4#+indexInt32OffAddrAsInt32X4# = indexInt32OffAddrAsInt32X4#++-- | Reads vector; offset in scalar elements. ++indexInt64OffAddrAsInt64X2# :: Addr# -> Int# -> Int64X2#+indexInt64OffAddrAsInt64X2# = indexInt64OffAddrAsInt64X2#++-- | Reads vector; offset in scalar elements. ++indexInt8OffAddrAsInt8X32# :: Addr# -> Int# -> Int8X32#+indexInt8OffAddrAsInt8X32# = indexInt8OffAddrAsInt8X32#++-- | Reads vector; offset in scalar elements. ++indexInt16OffAddrAsInt16X16# :: Addr# -> Int# -> Int16X16#+indexInt16OffAddrAsInt16X16# = indexInt16OffAddrAsInt16X16#++-- | Reads vector; offset in scalar elements. ++indexInt32OffAddrAsInt32X8# :: Addr# -> Int# -> Int32X8#+indexInt32OffAddrAsInt32X8# = indexInt32OffAddrAsInt32X8#++-- | Reads vector; offset in scalar elements. ++indexInt64OffAddrAsInt64X4# :: Addr# -> Int# -> Int64X4#+indexInt64OffAddrAsInt64X4# = indexInt64OffAddrAsInt64X4#++-- | Reads vector; offset in scalar elements. ++indexInt8OffAddrAsInt8X64# :: Addr# -> Int# -> Int8X64#+indexInt8OffAddrAsInt8X64# = indexInt8OffAddrAsInt8X64#++-- | Reads vector; offset in scalar elements. ++indexInt16OffAddrAsInt16X32# :: Addr# -> Int# -> Int16X32#+indexInt16OffAddrAsInt16X32# = indexInt16OffAddrAsInt16X32#++-- | Reads vector; offset in scalar elements. ++indexInt32OffAddrAsInt32X16# :: Addr# -> Int# -> Int32X16#+indexInt32OffAddrAsInt32X16# = indexInt32OffAddrAsInt32X16#++-- | Reads vector; offset in scalar elements. ++indexInt64OffAddrAsInt64X8# :: Addr# -> Int# -> Int64X8#+indexInt64OffAddrAsInt64X8# = indexInt64OffAddrAsInt64X8#++-- | Reads vector; offset in scalar elements. ++indexWord8OffAddrAsWord8X16# :: Addr# -> Int# -> Word8X16#+indexWord8OffAddrAsWord8X16# = indexWord8OffAddrAsWord8X16#++-- | Reads vector; offset in scalar elements. ++indexWord16OffAddrAsWord16X8# :: Addr# -> Int# -> Word16X8#+indexWord16OffAddrAsWord16X8# = indexWord16OffAddrAsWord16X8#++-- | Reads vector; offset in scalar elements. ++indexWord32OffAddrAsWord32X4# :: Addr# -> Int# -> Word32X4#+indexWord32OffAddrAsWord32X4# = indexWord32OffAddrAsWord32X4#++-- | Reads vector; offset in scalar elements. ++indexWord64OffAddrAsWord64X2# :: Addr# -> Int# -> Word64X2#+indexWord64OffAddrAsWord64X2# = indexWord64OffAddrAsWord64X2#++-- | Reads vector; offset in scalar elements. ++indexWord8OffAddrAsWord8X32# :: Addr# -> Int# -> Word8X32#+indexWord8OffAddrAsWord8X32# = indexWord8OffAddrAsWord8X32#++-- | Reads vector; offset in scalar elements. ++indexWord16OffAddrAsWord16X16# :: Addr# -> Int# -> Word16X16#+indexWord16OffAddrAsWord16X16# = indexWord16OffAddrAsWord16X16#++-- | Reads vector; offset in scalar elements. ++indexWord32OffAddrAsWord32X8# :: Addr# -> Int# -> Word32X8#+indexWord32OffAddrAsWord32X8# = indexWord32OffAddrAsWord32X8#++-- | Reads vector; offset in scalar elements. ++indexWord64OffAddrAsWord64X4# :: Addr# -> Int# -> Word64X4#+indexWord64OffAddrAsWord64X4# = indexWord64OffAddrAsWord64X4#++-- | Reads vector; offset in scalar elements. ++indexWord8OffAddrAsWord8X64# :: Addr# -> Int# -> Word8X64#+indexWord8OffAddrAsWord8X64# = indexWord8OffAddrAsWord8X64#++-- | Reads vector; offset in scalar elements. ++indexWord16OffAddrAsWord16X32# :: Addr# -> Int# -> Word16X32#+indexWord16OffAddrAsWord16X32# = indexWord16OffAddrAsWord16X32#++-- | Reads vector; offset in scalar elements. ++indexWord32OffAddrAsWord32X16# :: Addr# -> Int# -> Word32X16#+indexWord32OffAddrAsWord32X16# = indexWord32OffAddrAsWord32X16#++-- | Reads vector; offset in scalar elements. ++indexWord64OffAddrAsWord64X8# :: Addr# -> Int# -> Word64X8#+indexWord64OffAddrAsWord64X8# = indexWord64OffAddrAsWord64X8#++-- | Reads vector; offset in scalar elements. ++indexFloatOffAddrAsFloatX4# :: Addr# -> Int# -> FloatX4#+indexFloatOffAddrAsFloatX4# = indexFloatOffAddrAsFloatX4#++-- | Reads vector; offset in scalar elements. ++indexDoubleOffAddrAsDoubleX2# :: Addr# -> Int# -> DoubleX2#+indexDoubleOffAddrAsDoubleX2# = indexDoubleOffAddrAsDoubleX2#++-- | Reads vector; offset in scalar elements. ++indexFloatOffAddrAsFloatX8# :: Addr# -> Int# -> FloatX8#+indexFloatOffAddrAsFloatX8# = indexFloatOffAddrAsFloatX8#++-- | Reads vector; offset in scalar elements. ++indexDoubleOffAddrAsDoubleX4# :: Addr# -> Int# -> DoubleX4#+indexDoubleOffAddrAsDoubleX4# = indexDoubleOffAddrAsDoubleX4#++-- | Reads vector; offset in scalar elements. ++indexFloatOffAddrAsFloatX16# :: Addr# -> Int# -> FloatX16#+indexFloatOffAddrAsFloatX16# = indexFloatOffAddrAsFloatX16#++-- | Reads vector; offset in scalar elements. ++indexDoubleOffAddrAsDoubleX8# :: Addr# -> Int# -> DoubleX8#+indexDoubleOffAddrAsDoubleX8# = indexDoubleOffAddrAsDoubleX8#++-- | Reads vector; offset in scalar elements. ++readInt8OffAddrAsInt8X16# :: Addr# -> Int# -> State# s -> (# State# s,Int8X16# #)+readInt8OffAddrAsInt8X16# = readInt8OffAddrAsInt8X16#++-- | Reads vector; offset in scalar elements. ++readInt16OffAddrAsInt16X8# :: Addr# -> Int# -> State# s -> (# State# s,Int16X8# #)+readInt16OffAddrAsInt16X8# = readInt16OffAddrAsInt16X8#++-- | Reads vector; offset in scalar elements. ++readInt32OffAddrAsInt32X4# :: Addr# -> Int# -> State# s -> (# State# s,Int32X4# #)+readInt32OffAddrAsInt32X4# = readInt32OffAddrAsInt32X4#++-- | Reads vector; offset in scalar elements. ++readInt64OffAddrAsInt64X2# :: Addr# -> Int# -> State# s -> (# State# s,Int64X2# #)+readInt64OffAddrAsInt64X2# = readInt64OffAddrAsInt64X2#++-- | Reads vector; offset in scalar elements. ++readInt8OffAddrAsInt8X32# :: Addr# -> Int# -> State# s -> (# State# s,Int8X32# #)+readInt8OffAddrAsInt8X32# = readInt8OffAddrAsInt8X32#++-- | Reads vector; offset in scalar elements. ++readInt16OffAddrAsInt16X16# :: Addr# -> Int# -> State# s -> (# State# s,Int16X16# #)+readInt16OffAddrAsInt16X16# = readInt16OffAddrAsInt16X16#++-- | Reads vector; offset in scalar elements. ++readInt32OffAddrAsInt32X8# :: Addr# -> Int# -> State# s -> (# State# s,Int32X8# #)+readInt32OffAddrAsInt32X8# = readInt32OffAddrAsInt32X8#++-- | Reads vector; offset in scalar elements. ++readInt64OffAddrAsInt64X4# :: Addr# -> Int# -> State# s -> (# State# s,Int64X4# #)+readInt64OffAddrAsInt64X4# = readInt64OffAddrAsInt64X4#++-- | Reads vector; offset in scalar elements. ++readInt8OffAddrAsInt8X64# :: Addr# -> Int# -> State# s -> (# State# s,Int8X64# #)+readInt8OffAddrAsInt8X64# = readInt8OffAddrAsInt8X64#++-- | Reads vector; offset in scalar elements. ++readInt16OffAddrAsInt16X32# :: Addr# -> Int# -> State# s -> (# State# s,Int16X32# #)+readInt16OffAddrAsInt16X32# = readInt16OffAddrAsInt16X32#++-- | Reads vector; offset in scalar elements. ++readInt32OffAddrAsInt32X16# :: Addr# -> Int# -> State# s -> (# State# s,Int32X16# #)+readInt32OffAddrAsInt32X16# = readInt32OffAddrAsInt32X16#++-- | Reads vector; offset in scalar elements. ++readInt64OffAddrAsInt64X8# :: Addr# -> Int# -> State# s -> (# State# s,Int64X8# #)+readInt64OffAddrAsInt64X8# = readInt64OffAddrAsInt64X8#++-- | Reads vector; offset in scalar elements. ++readWord8OffAddrAsWord8X16# :: Addr# -> Int# -> State# s -> (# State# s,Word8X16# #)+readWord8OffAddrAsWord8X16# = readWord8OffAddrAsWord8X16#++-- | Reads vector; offset in scalar elements. ++readWord16OffAddrAsWord16X8# :: Addr# -> Int# -> State# s -> (# State# s,Word16X8# #)+readWord16OffAddrAsWord16X8# = readWord16OffAddrAsWord16X8#++-- | Reads vector; offset in scalar elements. ++readWord32OffAddrAsWord32X4# :: Addr# -> Int# -> State# s -> (# State# s,Word32X4# #)+readWord32OffAddrAsWord32X4# = readWord32OffAddrAsWord32X4#++-- | Reads vector; offset in scalar elements. ++readWord64OffAddrAsWord64X2# :: Addr# -> Int# -> State# s -> (# State# s,Word64X2# #)+readWord64OffAddrAsWord64X2# = readWord64OffAddrAsWord64X2#++-- | Reads vector; offset in scalar elements. ++readWord8OffAddrAsWord8X32# :: Addr# -> Int# -> State# s -> (# State# s,Word8X32# #)+readWord8OffAddrAsWord8X32# = readWord8OffAddrAsWord8X32#++-- | Reads vector; offset in scalar elements. ++readWord16OffAddrAsWord16X16# :: Addr# -> Int# -> State# s -> (# State# s,Word16X16# #)+readWord16OffAddrAsWord16X16# = readWord16OffAddrAsWord16X16#++-- | Reads vector; offset in scalar elements. ++readWord32OffAddrAsWord32X8# :: Addr# -> Int# -> State# s -> (# State# s,Word32X8# #)+readWord32OffAddrAsWord32X8# = readWord32OffAddrAsWord32X8#++-- | Reads vector; offset in scalar elements. ++readWord64OffAddrAsWord64X4# :: Addr# -> Int# -> State# s -> (# State# s,Word64X4# #)+readWord64OffAddrAsWord64X4# = readWord64OffAddrAsWord64X4#++-- | Reads vector; offset in scalar elements. ++readWord8OffAddrAsWord8X64# :: Addr# -> Int# -> State# s -> (# State# s,Word8X64# #)+readWord8OffAddrAsWord8X64# = readWord8OffAddrAsWord8X64#++-- | Reads vector; offset in scalar elements. ++readWord16OffAddrAsWord16X32# :: Addr# -> Int# -> State# s -> (# State# s,Word16X32# #)+readWord16OffAddrAsWord16X32# = readWord16OffAddrAsWord16X32#++-- | Reads vector; offset in scalar elements. ++readWord32OffAddrAsWord32X16# :: Addr# -> Int# -> State# s -> (# State# s,Word32X16# #)+readWord32OffAddrAsWord32X16# = readWord32OffAddrAsWord32X16#++-- | Reads vector; offset in scalar elements. ++readWord64OffAddrAsWord64X8# :: Addr# -> Int# -> State# s -> (# State# s,Word64X8# #)+readWord64OffAddrAsWord64X8# = readWord64OffAddrAsWord64X8#++-- | Reads vector; offset in scalar elements. ++readFloatOffAddrAsFloatX4# :: Addr# -> Int# -> State# s -> (# State# s,FloatX4# #)+readFloatOffAddrAsFloatX4# = readFloatOffAddrAsFloatX4#++-- | Reads vector; offset in scalar elements. ++readDoubleOffAddrAsDoubleX2# :: Addr# -> Int# -> State# s -> (# State# s,DoubleX2# #)+readDoubleOffAddrAsDoubleX2# = readDoubleOffAddrAsDoubleX2#++-- | Reads vector; offset in scalar elements. ++readFloatOffAddrAsFloatX8# :: Addr# -> Int# -> State# s -> (# State# s,FloatX8# #)+readFloatOffAddrAsFloatX8# = readFloatOffAddrAsFloatX8#++-- | Reads vector; offset in scalar elements. ++readDoubleOffAddrAsDoubleX4# :: Addr# -> Int# -> State# s -> (# State# s,DoubleX4# #)+readDoubleOffAddrAsDoubleX4# = readDoubleOffAddrAsDoubleX4#++-- | Reads vector; offset in scalar elements. ++readFloatOffAddrAsFloatX16# :: Addr# -> Int# -> State# s -> (# State# s,FloatX16# #)+readFloatOffAddrAsFloatX16# = readFloatOffAddrAsFloatX16#++-- | Reads vector; offset in scalar elements. ++readDoubleOffAddrAsDoubleX8# :: Addr# -> Int# -> State# s -> (# State# s,DoubleX8# #)+readDoubleOffAddrAsDoubleX8# = readDoubleOffAddrAsDoubleX8#++-- | Write vector; offset in scalar elements. ++writeInt8OffAddrAsInt8X16# :: Addr# -> Int# -> Int8X16# -> State# s -> State# s+writeInt8OffAddrAsInt8X16# = writeInt8OffAddrAsInt8X16#++-- | Write vector; offset in scalar elements. ++writeInt16OffAddrAsInt16X8# :: Addr# -> Int# -> Int16X8# -> State# s -> State# s+writeInt16OffAddrAsInt16X8# = writeInt16OffAddrAsInt16X8#++-- | Write vector; offset in scalar elements. ++writeInt32OffAddrAsInt32X4# :: Addr# -> Int# -> Int32X4# -> State# s -> State# s+writeInt32OffAddrAsInt32X4# = writeInt32OffAddrAsInt32X4#++-- | Write vector; offset in scalar elements. ++writeInt64OffAddrAsInt64X2# :: Addr# -> Int# -> Int64X2# -> State# s -> State# s+writeInt64OffAddrAsInt64X2# = writeInt64OffAddrAsInt64X2#++-- | Write vector; offset in scalar elements. ++writeInt8OffAddrAsInt8X32# :: Addr# -> Int# -> Int8X32# -> State# s -> State# s+writeInt8OffAddrAsInt8X32# = writeInt8OffAddrAsInt8X32#++-- | Write vector; offset in scalar elements. ++writeInt16OffAddrAsInt16X16# :: Addr# -> Int# -> Int16X16# -> State# s -> State# s+writeInt16OffAddrAsInt16X16# = writeInt16OffAddrAsInt16X16#++-- | Write vector; offset in scalar elements. ++writeInt32OffAddrAsInt32X8# :: Addr# -> Int# -> Int32X8# -> State# s -> State# s+writeInt32OffAddrAsInt32X8# = writeInt32OffAddrAsInt32X8#++-- | Write vector; offset in scalar elements. ++writeInt64OffAddrAsInt64X4# :: Addr# -> Int# -> Int64X4# -> State# s -> State# s+writeInt64OffAddrAsInt64X4# = writeInt64OffAddrAsInt64X4#++-- | Write vector; offset in scalar elements. ++writeInt8OffAddrAsInt8X64# :: Addr# -> Int# -> Int8X64# -> State# s -> State# s+writeInt8OffAddrAsInt8X64# = writeInt8OffAddrAsInt8X64#++-- | Write vector; offset in scalar elements. ++writeInt16OffAddrAsInt16X32# :: Addr# -> Int# -> Int16X32# -> State# s -> State# s+writeInt16OffAddrAsInt16X32# = writeInt16OffAddrAsInt16X32#++-- | Write vector; offset in scalar elements. ++writeInt32OffAddrAsInt32X16# :: Addr# -> Int# -> Int32X16# -> State# s -> State# s+writeInt32OffAddrAsInt32X16# = writeInt32OffAddrAsInt32X16#++-- | Write vector; offset in scalar elements. ++writeInt64OffAddrAsInt64X8# :: Addr# -> Int# -> Int64X8# -> State# s -> State# s+writeInt64OffAddrAsInt64X8# = writeInt64OffAddrAsInt64X8#++-- | Write vector; offset in scalar elements. ++writeWord8OffAddrAsWord8X16# :: Addr# -> Int# -> Word8X16# -> State# s -> State# s+writeWord8OffAddrAsWord8X16# = writeWord8OffAddrAsWord8X16#++-- | Write vector; offset in scalar elements. ++writeWord16OffAddrAsWord16X8# :: Addr# -> Int# -> Word16X8# -> State# s -> State# s+writeWord16OffAddrAsWord16X8# = writeWord16OffAddrAsWord16X8#++-- | Write vector; offset in scalar elements. ++writeWord32OffAddrAsWord32X4# :: Addr# -> Int# -> Word32X4# -> State# s -> State# s+writeWord32OffAddrAsWord32X4# = writeWord32OffAddrAsWord32X4#++-- | Write vector; offset in scalar elements. ++writeWord64OffAddrAsWord64X2# :: Addr# -> Int# -> Word64X2# -> State# s -> State# s+writeWord64OffAddrAsWord64X2# = writeWord64OffAddrAsWord64X2#++-- | Write vector; offset in scalar elements. ++writeWord8OffAddrAsWord8X32# :: Addr# -> Int# -> Word8X32# -> State# s -> State# s+writeWord8OffAddrAsWord8X32# = writeWord8OffAddrAsWord8X32#++-- | Write vector; offset in scalar elements. ++writeWord16OffAddrAsWord16X16# :: Addr# -> Int# -> Word16X16# -> State# s -> State# s+writeWord16OffAddrAsWord16X16# = writeWord16OffAddrAsWord16X16#++-- | Write vector; offset in scalar elements. ++writeWord32OffAddrAsWord32X8# :: Addr# -> Int# -> Word32X8# -> State# s -> State# s+writeWord32OffAddrAsWord32X8# = writeWord32OffAddrAsWord32X8#++-- | Write vector; offset in scalar elements. ++writeWord64OffAddrAsWord64X4# :: Addr# -> Int# -> Word64X4# -> State# s -> State# s+writeWord64OffAddrAsWord64X4# = writeWord64OffAddrAsWord64X4#++-- | Write vector; offset in scalar elements. ++writeWord8OffAddrAsWord8X64# :: Addr# -> Int# -> Word8X64# -> State# s -> State# s+writeWord8OffAddrAsWord8X64# = writeWord8OffAddrAsWord8X64#++-- | Write vector; offset in scalar elements. ++writeWord16OffAddrAsWord16X32# :: Addr# -> Int# -> Word16X32# -> State# s -> State# s+writeWord16OffAddrAsWord16X32# = writeWord16OffAddrAsWord16X32#++-- | Write vector; offset in scalar elements. ++writeWord32OffAddrAsWord32X16# :: Addr# -> Int# -> Word32X16# -> State# s -> State# s+writeWord32OffAddrAsWord32X16# = writeWord32OffAddrAsWord32X16#++-- | Write vector; offset in scalar elements. ++writeWord64OffAddrAsWord64X8# :: Addr# -> Int# -> Word64X8# -> State# s -> State# s+writeWord64OffAddrAsWord64X8# = writeWord64OffAddrAsWord64X8#++-- | Write vector; offset in scalar elements. ++writeFloatOffAddrAsFloatX4# :: Addr# -> Int# -> FloatX4# -> State# s -> State# s+writeFloatOffAddrAsFloatX4# = writeFloatOffAddrAsFloatX4#++-- | Write vector; offset in scalar elements. ++writeDoubleOffAddrAsDoubleX2# :: Addr# -> Int# -> DoubleX2# -> State# s -> State# s+writeDoubleOffAddrAsDoubleX2# = writeDoubleOffAddrAsDoubleX2#++-- | Write vector; offset in scalar elements. ++writeFloatOffAddrAsFloatX8# :: Addr# -> Int# -> FloatX8# -> State# s -> State# s+writeFloatOffAddrAsFloatX8# = writeFloatOffAddrAsFloatX8#++-- | Write vector; offset in scalar elements. ++writeDoubleOffAddrAsDoubleX4# :: Addr# -> Int# -> DoubleX4# -> State# s -> State# s+writeDoubleOffAddrAsDoubleX4# = writeDoubleOffAddrAsDoubleX4#++-- | Write vector; offset in scalar elements. ++writeFloatOffAddrAsFloatX16# :: Addr# -> Int# -> FloatX16# -> State# s -> State# s+writeFloatOffAddrAsFloatX16# = writeFloatOffAddrAsFloatX16#++-- | Write vector; offset in scalar elements. ++writeDoubleOffAddrAsDoubleX8# :: Addr# -> Int# -> DoubleX8# -> State# s -> State# s+writeDoubleOffAddrAsDoubleX8# = writeDoubleOffAddrAsDoubleX8#++prefetchByteArray3# :: ByteArray# -> Int# -> State# s -> State# s+prefetchByteArray3# = prefetchByteArray3#++prefetchMutableByteArray3# :: MutableByteArray# s -> Int# -> State# s -> State# s+prefetchMutableByteArray3# = prefetchMutableByteArray3#++prefetchAddr3# :: Addr# -> Int# -> State# s -> State# s+prefetchAddr3# = prefetchAddr3#++prefetchValue3# :: a -> State# s -> State# s+prefetchValue3# = prefetchValue3#++prefetchByteArray2# :: ByteArray# -> Int# -> State# s -> State# s+prefetchByteArray2# = prefetchByteArray2#++prefetchMutableByteArray2# :: MutableByteArray# s -> Int# -> State# s -> State# s+prefetchMutableByteArray2# = prefetchMutableByteArray2#++prefetchAddr2# :: Addr# -> Int# -> State# s -> State# s+prefetchAddr2# = prefetchAddr2#++prefetchValue2# :: a -> State# s -> State# s+prefetchValue2# = prefetchValue2#++prefetchByteArray1# :: ByteArray# -> Int# -> State# s -> State# s+prefetchByteArray1# = prefetchByteArray1#++prefetchMutableByteArray1# :: MutableByteArray# s -> Int# -> State# s -> State# s+prefetchMutableByteArray1# = prefetchMutableByteArray1#++prefetchAddr1# :: Addr# -> Int# -> State# s -> State# s+prefetchAddr1# = prefetchAddr1#++prefetchValue1# :: a -> State# s -> State# s+prefetchValue1# = prefetchValue1#++prefetchByteArray0# :: ByteArray# -> Int# -> State# s -> State# s+prefetchByteArray0# = prefetchByteArray0#++prefetchMutableByteArray0# :: MutableByteArray# s -> Int# -> State# s -> State# s+prefetchMutableByteArray0# = prefetchMutableByteArray0#++prefetchAddr0# :: Addr# -> Int# -> State# s -> State# s+prefetchAddr0# = prefetchAddr0#++prefetchValue0# :: a -> State# s -> State# s+prefetchValue0# = prefetchValue0#